GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 0.0% 0 / 0 / 4685
Functions: 0.0% 0 / 0 / 790
Branches: 0.0% 0 / 0 / 2982

src/modelica/antlr/modelicaParser.cpp
Line Branch Exec Source
1
2 // Generated from modelica.g4 by ANTLR 4.13.2
3
4 #include "modelicaListener.h"
5 #include "modelicaVisitor.h"
6
7 #include "modelicaParser.h"
8
9 using namespace antlrcpp;
10
11 using namespace antlr4;
12
13 namespace {
14
15 struct ModelicaParserStaticData final
16 {
17 ✗ ModelicaParserStaticData(std::vector<std::string> ruleNames, std::vector<std::string> literalNames, std::vector<std::string> symbolicNames)
18 ✗ : ruleNames(std::move(ruleNames)),
19 ✗ literalNames(std::move(literalNames)),
20 ✗ symbolicNames(std::move(symbolicNames)),
21 ✗ vocabulary(this->literalNames, this->symbolicNames) {}
22
23 ModelicaParserStaticData(const ModelicaParserStaticData&) = delete;
24 ModelicaParserStaticData(ModelicaParserStaticData&&) = delete;
25 ModelicaParserStaticData& operator=(const ModelicaParserStaticData&) = delete;
26 ModelicaParserStaticData& operator=(ModelicaParserStaticData&&) = delete;
27
28 std::vector<antlr4::dfa::DFA> decisionToDFA;
29 antlr4::atn::PredictionContextCache sharedContextCache;
30 const std::vector<std::string> ruleNames;
31 const std::vector<std::string> literalNames;
32 const std::vector<std::string> symbolicNames;
33 const antlr4::dfa::Vocabulary vocabulary;
34 antlr4::atn::SerializedATNView serializedATN;
35 std::unique_ptr<antlr4::atn::ATN> atn;
36 };
37
38 ::antlr4::internal::OnceFlag modelicaParserOnceFlag;
39 #if ANTLR4_USE_THREAD_LOCAL_CACHE
40 static thread_local
41 #endif
42 std::unique_ptr<ModelicaParserStaticData>
43 modelicaParserStaticData = nullptr;
44
45 ✗ void modelicaParserInitialize() {
46 #if ANTLR4_USE_THREAD_LOCAL_CACHE
47 if (modelicaParserStaticData != nullptr) {
48 return;
49 }
50 #else
51 assert(modelicaParserStaticData == nullptr);
52 #endif
53 auto staticData = std::make_unique<ModelicaParserStaticData>(
54 ✗ std::vector<std::string>{"stored_definition",
55 "within_statement",
56 "class_definition",
57 "class_specifier",
58 "class_prefixes",
59 "long_class_specifier",
60 "short_class_specifier",
61 "der_class_specifier",
62 "base_prefix",
63 "enum_list",
64 "enumeration_literal",
65 "composition",
66 "language_specification",
67 "external_function_call",
68 "element_list",
69 "element",
70 "import_clause",
71 "import_list",
72 "extends_clause",
73 "constraining_clause",
74 "component_clause",
75 "type_prefix",
76 "type_specifier",
77 "component_list",
78 "component_declaration",
79 "condition_attribute",
80 "declaration",
81 "modification",
82 "class_modification",
83 "argument_list",
84 "argument",
85 "element_modification_or_replaceable",
86 "element_modification",
87 "element_redeclaration",
88 "element_replaceable",
89 "component_clause1",
90 "component_declaration1",
91 "short_class_definition",
92 "equation_section",
93 "algorithm_section",
94 "equation",
95 "statement",
96 "if_equation",
97 "if_statement",
98 "for_equation",
99 "for_statement",
100 "for_indices",
101 "for_index",
102 "while_statement",
103 "when_equation",
104 "when_statement",
105 "connect_clause",
106 "expression",
107 "simple_expression",
108 "logical_expression",
109 "logical_term",
110 "logical_factor",
111 "relation",
112 "rel_op",
113 "arithmetic_expression",
114 "add_op",
115 "term",
116 "mul_op",
117 "factor",
118 "primary",
119 "name",
120 "component_reference",
121 "function_call_args",
122 "function_arguments",
123 "named_arguments",
124 "named_argument",
125 "function_argument",
126 "output_expression_list",
127 "expression_list",
128 "array_subscripts",
129 "subscript",
130 "comment",
131 "string_comment",
132 "model_annotation",
133 ✗ "annotation"},
134 ✗ std::vector<std::string>{"",
135 "'final'",
136 "';'",
137 "'within'",
138 "'encapsulated'",
139 "'partial'",
140 "'class'",
141 "'model'",
142 "'operator'",
143 "'record'",
144 "'block'",
145 "'expandable'",
146 "'connector'",
147 "'type'",
148 "'package'",
149 "'pure'",
150 "'impure'",
151 "'function'",
152 "'end'",
153 "'extends'",
154 "'='",
155 "'enumeration'",
156 "'('",
157 "':'",
158 "')'",
159 "'der'",
160 "','",
161 "'public'",
162 "'protected'",
163 "'external'",
164 "'redeclare'",
165 "'inner'",
166 "'outer'",
167 "'replaceable'",
168 "'import'",
169 "'.*'",
170 "'.{'",
171 "'}'",
172 "'constrainedby'",
173 "'flow'",
174 "'stream'",
175 "'discrete'",
176 "'parameter'",
177 "'constant'",
178 "'input'",
179 "'output'",
180 "'if'",
181 "':='",
182 "'each'",
183 "'initial'",
184 "'equation'",
185 "'algorithm'",
186 "'break'",
187 "'return'",
188 "'then'",
189 "'elseif'",
190 "'else'",
191 "'for'",
192 "'loop'",
193 "'in'",
194 "'while'",
195 "'when'",
196 "'elsewhen'",
197 "'connect'",
198 "'or'",
199 "'and'",
200 "'not'",
201 "'<'",
202 "'<='",
203 "'>'",
204 "'>='",
205 "'=='",
206 "'<>'",
207 "'+'",
208 "'-'",
209 "'.+'",
210 "'.-'",
211 "'*'",
212 "'/'",
213 "'./'",
214 "'^'",
215 "'.^'",
216 "'false'",
217 "'true'",
218 "'['",
219 "']'",
220 "'{'",
221 "'.'",
222 ✗ "'annotation'"},
223 ✗ std::vector<std::string>{"",
224 "",
225 "",
226 "",
227 "",
228 "",
229 "",
230 "",
231 "",
232 "",
233 "",
234 "",
235 "",
236 "",
237 "",
238 "",
239 "",
240 "",
241 "",
242 "",
243 "",
244 "",
245 "",
246 "",
247 "",
248 "",
249 "",
250 "",
251 "",
252 "",
253 "",
254 "",
255 "",
256 "",
257 "",
258 "",
259 "",
260 "",
261 "",
262 "",
263 "",
264 "",
265 "",
266 "",
267 "",
268 "",
269 "",
270 "",
271 "",
272 "",
273 "",
274 "",
275 "",
276 "",
277 "",
278 "",
279 "",
280 "",
281 "",
282 "",
283 "",
284 "",
285 "",
286 "",
287 "",
288 "",
289 "",
290 "",
291 "",
292 "",
293 "",
294 "",
295 "",
296 "",
297 "",
298 "",
299 "",
300 "",
301 "",
302 "",
303 "",
304 "",
305 "",
306 "",
307 "",
308 "",
309 "",
310 "",
311 "",
312 "IDENT",
313 "STRING",
314 "UNSIGNED_NUMBER",
315 "WS",
316 "COMMENT",
317 ✗ "LINE_COMMENT"});
318 static const int32_t serializedATNSegment[] = {
319 4, 1, 94, 1028, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4,
320 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10,
321 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16,
322 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22,
323 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28,
324 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34,
325 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40,
326 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46,
327 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52,
328 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58,
329 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64,
330 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70,
331 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76,
332 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 1, 0, 5, 0, 162, 8, 0, 10, 0, 12, 0, 165,
333 9, 0, 1, 0, 3, 0, 168, 8, 0, 1, 0, 1, 0, 1, 0, 5, 0, 173, 8, 0, 10, 0, 12, 0,
334 176, 9, 0, 1, 1, 1, 1, 3, 1, 180, 8, 1, 1, 1, 1, 1, 1, 2, 3, 2, 185, 8, 2, 1,
335 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 3, 3, 193, 8, 3, 1, 4, 3, 4, 196, 8, 4, 1,
336 4, 1, 4, 1, 4, 3, 4, 201, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 206, 8, 4, 1, 4, 1,
337 4, 1, 4, 1, 4, 3, 4, 212, 8, 4, 1, 4, 3, 4, 215, 8, 4, 1, 4, 1, 4, 3, 4, 219,
338 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 230, 8,
339 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 237, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6,
340 1, 6, 3, 6, 244, 8, 6, 1, 6, 3, 6, 247, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6,
341 1, 6, 1, 6, 3, 6, 256, 8, 6, 1, 6, 3, 6, 259, 8, 6, 1, 6, 1, 6, 3, 6, 263, 8,
342 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 5, 7, 274, 8, 7,
343 10, 7, 12, 7, 277, 9, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 5,
344 9, 287, 8, 9, 10, 9, 12, 9, 290, 9, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1,
345 11, 1, 11, 1, 11, 1, 11, 5, 11, 302, 8, 11, 10, 11, 12, 11, 305, 9, 11, 1, 11, 1, 11, 3,
346 11, 309, 8, 11, 1, 11, 3, 11, 312, 8, 11, 1, 11, 3, 11, 315, 8, 11, 1, 11, 3, 11, 318, 8,
347 11, 1, 11, 1, 11, 1, 11, 3, 11, 323, 8, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 3, 13,
348 330, 8, 13, 1, 13, 1, 13, 1, 13, 3, 13, 335, 8, 13, 1, 13, 1, 13, 1, 14, 5, 14, 340, 8,
349 14, 10, 14, 12, 14, 343, 9, 14, 1, 15, 1, 15, 1, 15, 3, 15, 348, 8, 15, 1, 15, 3, 15, 351,
350 8, 15, 1, 15, 3, 15, 354, 8, 15, 1, 15, 3, 15, 357, 8, 15, 1, 15, 1, 15, 3, 15, 361, 8,
351 15, 1, 15, 1, 15, 1, 15, 3, 15, 366, 8, 15, 1, 15, 1, 15, 1, 15, 3, 15, 371, 8, 15, 3,
352 15, 373, 8, 15, 3, 15, 375, 8, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1,
353 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 392, 8, 16, 1, 16, 1, 16,
354 1, 17, 1, 17, 1, 17, 5, 17, 399, 8, 17, 10, 17, 12, 17, 402, 9, 17, 1, 18, 1, 18, 1, 18,
355 3, 18, 407, 8, 18, 1, 18, 3, 18, 410, 8, 18, 1, 19, 1, 19, 1, 19, 3, 19, 415, 8, 19, 1,
356 20, 1, 20, 1, 20, 3, 20, 420, 8, 20, 1, 20, 1, 20, 1, 21, 3, 21, 425, 8, 21, 1, 21, 3,
357 21, 428, 8, 21, 1, 21, 3, 21, 431, 8, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 5, 23, 438,
358 8, 23, 10, 23, 12, 23, 441, 9, 23, 1, 24, 1, 24, 3, 24, 445, 8, 24, 1, 24, 1, 24, 1, 25,
359 1, 25, 1, 25, 1, 26, 1, 26, 3, 26, 454, 8, 26, 1, 26, 3, 26, 457, 8, 26, 1, 27, 1, 27,
360 1, 27, 3, 27, 462, 8, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 468, 8, 27, 1, 28, 1, 28,
361 3, 28, 472, 8, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 5, 29, 479, 8, 29, 10, 29, 12, 29,
362 482, 9, 29, 1, 30, 1, 30, 3, 30, 486, 8, 30, 1, 31, 3, 31, 489, 8, 31, 1, 31, 3, 31, 492,
363 8, 31, 1, 31, 1, 31, 3, 31, 496, 8, 31, 1, 32, 1, 32, 3, 32, 500, 8, 32, 1, 32, 1, 32,
364 1, 33, 1, 33, 3, 33, 506, 8, 33, 1, 33, 3, 33, 509, 8, 33, 1, 33, 1, 33, 3, 33, 513, 8,
365 33, 1, 33, 3, 33, 516, 8, 33, 1, 34, 1, 34, 1, 34, 3, 34, 521, 8, 34, 1, 34, 3, 34, 524,
366 8, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 38,
367 3, 38, 537, 8, 38, 1, 38, 1, 38, 5, 38, 541, 8, 38, 10, 38, 12, 38, 544, 9, 38, 1, 39, 3,
368 39, 547, 8, 39, 1, 39, 1, 39, 1, 39, 1, 39, 5, 39, 553, 8, 39, 10, 39, 12, 39, 556, 9, 39,
369 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40,
370 569, 8, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 3, 41, 578, 8, 41, 1, 41,
371 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41,
372 3, 41, 593, 8, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 5, 42, 601, 8, 42, 10, 42,
373 12, 42, 604, 9, 42, 1, 42, 1, 42, 1, 42, 1, 42, 5, 42, 610, 8, 42, 10, 42, 12, 42, 613, 9,
374 42, 5, 42, 615, 8, 42, 10, 42, 12, 42, 618, 9, 42, 1, 42, 1, 42, 5, 42, 622, 8, 42, 10, 42,
375 12, 42, 625, 9, 42, 3, 42, 627, 8, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43,
376 1, 43, 1, 43, 5, 43, 638, 8, 43, 10, 43, 12, 43, 641, 9, 43, 1, 43, 1, 43, 1, 43, 1, 43,
377 1, 43, 1, 43, 5, 43, 649, 8, 43, 10, 43, 12, 43, 652, 9, 43, 5, 43, 654, 8, 43, 10, 43, 12,
378 43, 657, 9, 43, 1, 43, 1, 43, 1, 43, 1, 43, 5, 43, 663, 8, 43, 10, 43, 12, 43, 666, 9, 43,
379 3, 43, 668, 8, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 5, 44, 677, 8, 44,
380 10, 44, 12, 44, 680, 9, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1,
381 45, 5, 45, 691, 8, 45, 10, 45, 12, 45, 694, 9, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1,
382 46, 5, 46, 702, 8, 46, 10, 46, 12, 46, 705, 9, 46, 1, 47, 1, 47, 1, 47, 3, 47, 710, 8, 47,
383 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 5, 48, 718, 8, 48, 10, 48, 12, 48, 721, 9, 48,
384 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 5, 49, 730, 8, 49, 10, 49, 12, 49, 733,
385 9, 49, 1, 49, 1, 49, 1, 49, 1, 49, 5, 49, 739, 8, 49, 10, 49, 12, 49, 742, 9, 49, 5, 49,
386 744, 8, 49, 10, 49, 12, 49, 747, 9, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50,
387 1, 50, 1, 50, 5, 50, 758, 8, 50, 10, 50, 12, 50, 761, 9, 50, 1, 50, 1, 50, 1, 50, 1, 50,
388 1, 50, 1, 50, 5, 50, 769, 8, 50, 10, 50, 12, 50, 772, 9, 50, 5, 50, 774, 8, 50, 10, 50, 12,
389 50, 777, 9, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51,
390 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 5, 52, 799, 8,
391 52, 10, 52, 12, 52, 802, 9, 52, 1, 52, 1, 52, 1, 52, 3, 52, 807, 8, 52, 1, 53, 1, 53, 1,
392 53, 1, 53, 1, 53, 3, 53, 814, 8, 53, 3, 53, 816, 8, 53, 1, 54, 1, 54, 1, 54, 5, 54, 821,
393 8, 54, 10, 54, 12, 54, 824, 9, 54, 1, 55, 1, 55, 1, 55, 5, 55, 829, 8, 55, 10, 55, 12, 55,
394 832, 9, 55, 1, 56, 3, 56, 835, 8, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57,
395 843, 8, 57, 1, 58, 1, 58, 1, 59, 3, 59, 848, 8, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59,
396 854, 8, 59, 10, 59, 12, 59, 857, 9, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 5, 61,
397 865, 8, 61, 10, 61, 12, 61, 868, 9, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 3, 63, 875, 8,
398 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 884, 8, 64, 1, 64, 1, 64,
399 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 5, 64, 896, 8, 64, 10, 64, 12,
400 64, 899, 9, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 908, 8, 64, 1,
401 65, 3, 65, 911, 8, 65, 1, 65, 1, 65, 1, 65, 5, 65, 916, 8, 65, 10, 65, 12, 65, 919, 9, 65,
402 1, 66, 3, 66, 922, 8, 66, 1, 66, 1, 66, 3, 66, 926, 8, 66, 1, 66, 1, 66, 1, 66, 3, 66,
403 931, 8, 66, 5, 66, 933, 8, 66, 10, 66, 12, 66, 936, 9, 66, 1, 67, 1, 67, 3, 67, 940, 8, 67,
404 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 949, 8, 68, 1, 68, 3, 68, 952,
405 8, 68, 1, 69, 1, 69, 1, 69, 3, 69, 957, 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1,
406 71, 1, 71, 1, 71, 3, 71, 967, 8, 71, 1, 71, 1, 71, 1, 71, 3, 71, 972, 8, 71, 1, 72, 3,
407 72, 975, 8, 72, 1, 72, 1, 72, 3, 72, 979, 8, 72, 5, 72, 981, 8, 72, 10, 72, 12, 72, 984, 9,
408 72, 1, 73, 1, 73, 1, 73, 5, 73, 989, 8, 73, 10, 73, 12, 73, 992, 9, 73, 1, 74, 1, 74, 1,
409 74, 1, 74, 5, 74, 998, 8, 74, 10, 74, 12, 74, 1001, 9, 74, 1, 74, 1, 74, 1, 75, 1, 75, 3,
410 75, 1007, 8, 75, 1, 76, 1, 76, 3, 76, 1011, 8, 76, 1, 77, 1, 77, 1, 77, 5, 77, 1016, 8, 77,
411 10, 77, 12, 77, 1019, 9, 77, 3, 77, 1021, 8, 77, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79,
412 0, 0, 80, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40,
413 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88,
414 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136,
415 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 0, 8, 1, 0, 15, 16, 1, 0, 39, 40, 1, 0, 41,
416 43, 1, 0, 44, 45, 1, 0, 67, 72, 1, 0, 73, 76, 2, 0, 35, 35, 77, 79, 1, 0, 80, 81, 1113,
417 0, 163, 1, 0, 0, 0, 2, 177, 1, 0, 0, 0, 4, 184, 1, 0, 0, 0, 6, 192, 1, 0, 0, 0,
418 8, 195, 1, 0, 0, 0, 10, 236, 1, 0, 0, 0, 12, 262, 1, 0, 0, 0, 14, 264, 1, 0, 0, 0,
419 16, 281, 1, 0, 0, 0, 18, 283, 1, 0, 0, 0, 20, 291, 1, 0, 0, 0, 22, 294, 1, 0, 0, 0,
420 24, 324, 1, 0, 0, 0, 26, 329, 1, 0, 0, 0, 28, 341, 1, 0, 0, 0, 30, 374, 1, 0, 0, 0,
421 32, 378, 1, 0, 0, 0, 34, 395, 1, 0, 0, 0, 36, 403, 1, 0, 0, 0, 38, 411, 1, 0, 0, 0,
422 40, 416, 1, 0, 0, 0, 42, 424, 1, 0, 0, 0, 44, 432, 1, 0, 0, 0, 46, 434, 1, 0, 0, 0,
423 48, 442, 1, 0, 0, 0, 50, 448, 1, 0, 0, 0, 52, 451, 1, 0, 0, 0, 54, 467, 1, 0, 0, 0,
424 56, 469, 1, 0, 0, 0, 58, 475, 1, 0, 0, 0, 60, 485, 1, 0, 0, 0, 62, 488, 1, 0, 0, 0,
425 64, 497, 1, 0, 0, 0, 66, 503, 1, 0, 0, 0, 68, 517, 1, 0, 0, 0, 70, 525, 1, 0, 0, 0,
426 72, 529, 1, 0, 0, 0, 74, 532, 1, 0, 0, 0, 76, 536, 1, 0, 0, 0, 78, 546, 1, 0, 0, 0,
427 80, 568, 1, 0, 0, 0, 82, 592, 1, 0, 0, 0, 84, 596, 1, 0, 0, 0, 86, 631, 1, 0, 0, 0,
428 88, 672, 1, 0, 0, 0, 90, 684, 1, 0, 0, 0, 92, 698, 1, 0, 0, 0, 94, 706, 1, 0, 0, 0,
429 96, 711, 1, 0, 0, 0, 98, 725, 1, 0, 0, 0, 100, 751, 1, 0, 0, 0, 102, 781, 1, 0, 0, 0,
430 104, 806, 1, 0, 0, 0, 106, 808, 1, 0, 0, 0, 108, 817, 1, 0, 0, 0, 110, 825, 1, 0, 0, 0,
431 112, 834, 1, 0, 0, 0, 114, 838, 1, 0, 0, 0, 116, 844, 1, 0, 0, 0, 118, 847, 1, 0, 0, 0,
432 120, 858, 1, 0, 0, 0, 122, 860, 1, 0, 0, 0, 124, 869, 1, 0, 0, 0, 126, 871, 1, 0, 0, 0,
433 128, 907, 1, 0, 0, 0, 130, 910, 1, 0, 0, 0, 132, 921, 1, 0, 0, 0, 134, 937, 1, 0, 0, 0,
434 136, 951, 1, 0, 0, 0, 138, 953, 1, 0, 0, 0, 140, 958, 1, 0, 0, 0, 142, 971, 1, 0, 0, 0,
435 144, 974, 1, 0, 0, 0, 146, 985, 1, 0, 0, 0, 148, 993, 1, 0, 0, 0, 150, 1006, 1, 0, 0, 0,
436 152, 1008, 1, 0, 0, 0, 154, 1020, 1, 0, 0, 0, 156, 1022, 1, 0, 0, 0, 158, 1024, 1, 0, 0, 0,
437 160, 162, 3, 2, 1, 0, 161, 160, 1, 0, 0, 0, 162, 165, 1, 0, 0, 0, 163, 161, 1, 0, 0, 0,
438 163, 164, 1, 0, 0, 0, 164, 174, 1, 0, 0, 0, 165, 163, 1, 0, 0, 0, 166, 168, 5, 1, 0, 0,
439 167, 166, 1, 0, 0, 0, 167, 168, 1, 0, 0, 0, 168, 169, 1, 0, 0, 0, 169, 170, 3, 4, 2, 0,
440 170, 171, 5, 2, 0, 0, 171, 173, 1, 0, 0, 0, 172, 167, 1, 0, 0, 0, 173, 176, 1, 0, 0, 0,
441 174, 172, 1, 0, 0, 0, 174, 175, 1, 0, 0, 0, 175, 1, 1, 0, 0, 0, 176, 174, 1, 0, 0, 0,
442 177, 179, 5, 3, 0, 0, 178, 180, 3, 130, 65, 0, 179, 178, 1, 0, 0, 0, 179, 180, 1, 0, 0, 0,
443 180, 181, 1, 0, 0, 0, 181, 182, 5, 2, 0, 0, 182, 3, 1, 0, 0, 0, 183, 185, 5, 4, 0, 0,
444 184, 183, 1, 0, 0, 0, 184, 185, 1, 0, 0, 0, 185, 186, 1, 0, 0, 0, 186, 187, 3, 8, 4, 0,
445 187, 188, 3, 6, 3, 0, 188, 5, 1, 0, 0, 0, 189, 193, 3, 10, 5, 0, 190, 193, 3, 12, 6, 0,
446 191, 193, 3, 14, 7, 0, 192, 189, 1, 0, 0, 0, 192, 190, 1, 0, 0, 0, 192, 191, 1, 0, 0, 0,
447 193, 7, 1, 0, 0, 0, 194, 196, 5, 5, 0, 0, 195, 194, 1, 0, 0, 0, 195, 196, 1, 0, 0, 0,
448 196, 218, 1, 0, 0, 0, 197, 219, 5, 6, 0, 0, 198, 219, 5, 7, 0, 0, 199, 201, 5, 8, 0, 0,
449 200, 199, 1, 0, 0, 0, 200, 201, 1, 0, 0, 0, 201, 202, 1, 0, 0, 0, 202, 219, 5, 9, 0, 0,
450 203, 219, 5, 10, 0, 0, 204, 206, 5, 11, 0, 0, 205, 204, 1, 0, 0, 0, 205, 206, 1, 0, 0, 0,
451 206, 207, 1, 0, 0, 0, 207, 219, 5, 12, 0, 0, 208, 219, 5, 13, 0, 0, 209, 219, 5, 14, 0, 0,
452 210, 212, 7, 0, 0, 0, 211, 210, 1, 0, 0, 0, 211, 212, 1, 0, 0, 0, 212, 214, 1, 0, 0, 0,
453 213, 215, 5, 8, 0, 0, 214, 213, 1, 0, 0, 0, 214, 215, 1, 0, 0, 0, 215, 216, 1, 0, 0, 0,
454 216, 219, 5, 17, 0, 0, 217, 219, 5, 8, 0, 0, 218, 197, 1, 0, 0, 0, 218, 198, 1, 0, 0, 0,
455 218, 200, 1, 0, 0, 0, 218, 203, 1, 0, 0, 0, 218, 205, 1, 0, 0, 0, 218, 208, 1, 0, 0, 0,
456 218, 209, 1, 0, 0, 0, 218, 211, 1, 0, 0, 0, 218, 217, 1, 0, 0, 0, 219, 9, 1, 0, 0, 0,
457 220, 221, 5, 89, 0, 0, 221, 222, 3, 154, 77, 0, 222, 223, 3, 22, 11, 0, 223, 224, 5, 18, 0, 0,
458 224, 225, 5, 89, 0, 0, 225, 237, 1, 0, 0, 0, 226, 227, 5, 19, 0, 0, 227, 229, 5, 89, 0, 0,
459 228, 230, 3, 56, 28, 0, 229, 228, 1, 0, 0, 0, 229, 230, 1, 0, 0, 0, 230, 231, 1, 0, 0, 0,
460 231, 232, 3, 154, 77, 0, 232, 233, 3, 22, 11, 0, 233, 234, 5, 18, 0, 0, 234, 235, 5, 89, 0, 0,
461 235, 237, 1, 0, 0, 0, 236, 220, 1, 0, 0, 0, 236, 226, 1, 0, 0, 0, 237, 11, 1, 0, 0, 0,
462 238, 239, 5, 89, 0, 0, 239, 240, 5, 20, 0, 0, 240, 241, 3, 16, 8, 0, 241, 243, 3, 130, 65, 0,
463 242, 244, 3, 148, 74, 0, 243, 242, 1, 0, 0, 0, 243, 244, 1, 0, 0, 0, 244, 246, 1, 0, 0, 0,
464 245, 247, 3, 56, 28, 0, 246, 245, 1, 0, 0, 0, 246, 247, 1, 0, 0, 0, 247, 248, 1, 0, 0, 0,
465 248, 249, 3, 152, 76, 0, 249, 263, 1, 0, 0, 0, 250, 251, 5, 89, 0, 0, 251, 252, 5, 20, 0, 0,
466 252, 253, 5, 21, 0, 0, 253, 258, 5, 22, 0, 0, 254, 256, 3, 18, 9, 0, 255, 254, 1, 0, 0, 0,
467 255, 256, 1, 0, 0, 0, 256, 259, 1, 0, 0, 0, 257, 259, 5, 23, 0, 0, 258, 255, 1, 0, 0, 0,
468 258, 257, 1, 0, 0, 0, 259, 260, 1, 0, 0, 0, 260, 261, 5, 24, 0, 0, 261, 263, 3, 152, 76, 0,
469 262, 238, 1, 0, 0, 0, 262, 250, 1, 0, 0, 0, 263, 13, 1, 0, 0, 0, 264, 265, 5, 89, 0, 0,
470 265, 266, 5, 20, 0, 0, 266, 267, 5, 25, 0, 0, 267, 268, 5, 22, 0, 0, 268, 269, 3, 130, 65, 0,
471 269, 270, 5, 26, 0, 0, 270, 275, 5, 89, 0, 0, 271, 272, 5, 26, 0, 0, 272, 274, 5, 89, 0, 0,
472 273, 271, 1, 0, 0, 0, 274, 277, 1, 0, 0, 0, 275, 273, 1, 0, 0, 0, 275, 276, 1, 0, 0, 0,
473 276, 278, 1, 0, 0, 0, 277, 275, 1, 0, 0, 0, 278, 279, 5, 24, 0, 0, 279, 280, 3, 152, 76, 0,
474 280, 15, 1, 0, 0, 0, 281, 282, 3, 42, 21, 0, 282, 17, 1, 0, 0, 0, 283, 288, 3, 20, 10, 0,
475 284, 285, 5, 26, 0, 0, 285, 287, 3, 20, 10, 0, 286, 284, 1, 0, 0, 0, 287, 290, 1, 0, 0, 0,
476 288, 286, 1, 0, 0, 0, 288, 289, 1, 0, 0, 0, 289, 19, 1, 0, 0, 0, 290, 288, 1, 0, 0, 0,
477 291, 292, 5, 89, 0, 0, 292, 293, 3, 152, 76, 0, 293, 21, 1, 0, 0, 0, 294, 303, 3, 28, 14, 0,
478 295, 296, 5, 27, 0, 0, 296, 302, 3, 28, 14, 0, 297, 298, 5, 28, 0, 0, 298, 302, 3, 28, 14, 0,
479 299, 302, 3, 76, 38, 0, 300, 302, 3, 78, 39, 0, 301, 295, 1, 0, 0, 0, 301, 297, 1, 0, 0, 0,
480 301, 299, 1, 0, 0, 0, 301, 300, 1, 0, 0, 0, 302, 305, 1, 0, 0, 0, 303, 301, 1, 0, 0, 0,
481 303, 304, 1, 0, 0, 0, 304, 317, 1, 0, 0, 0, 305, 303, 1, 0, 0, 0, 306, 308, 5, 29, 0, 0,
482 307, 309, 3, 24, 12, 0, 308, 307, 1, 0, 0, 0, 308, 309, 1, 0, 0, 0, 309, 311, 1, 0, 0, 0,
483 310, 312, 3, 26, 13, 0, 311, 310, 1, 0, 0, 0, 311, 312, 1, 0, 0, 0, 312, 314, 1, 0, 0, 0,
484 313, 315, 3, 158, 79, 0, 314, 313, 1, 0, 0, 0, 314, 315, 1, 0, 0, 0, 315, 316, 1, 0, 0, 0,
485 316, 318, 5, 2, 0, 0, 317, 306, 1, 0, 0, 0, 317, 318, 1, 0, 0, 0, 318, 322, 1, 0, 0, 0,
486 319, 320, 3, 156, 78, 0, 320, 321, 5, 2, 0, 0, 321, 323, 1, 0, 0, 0, 322, 319, 1, 0, 0, 0,
487 322, 323, 1, 0, 0, 0, 323, 23, 1, 0, 0, 0, 324, 325, 5, 90, 0, 0, 325, 25, 1, 0, 0, 0,
488 326, 327, 3, 132, 66, 0, 327, 328, 5, 20, 0, 0, 328, 330, 1, 0, 0, 0, 329, 326, 1, 0, 0, 0,
489 329, 330, 1, 0, 0, 0, 330, 331, 1, 0, 0, 0, 331, 332, 5, 89, 0, 0, 332, 334, 5, 22, 0, 0,
490 333, 335, 3, 146, 73, 0, 334, 333, 1, 0, 0, 0, 334, 335, 1, 0, 0, 0, 335, 336, 1, 0, 0, 0,
491 336, 337, 5, 24, 0, 0, 337, 27, 1, 0, 0, 0, 338, 340, 3, 30, 15, 0, 339, 338, 1, 0, 0, 0,
492 340, 343, 1, 0, 0, 0, 341, 339, 1, 0, 0, 0, 341, 342, 1, 0, 0, 0, 342, 29, 1, 0, 0, 0,
493 343, 341, 1, 0, 0, 0, 344, 375, 3, 32, 16, 0, 345, 375, 3, 36, 18, 0, 346, 348, 5, 30, 0, 0,
494 347, 346, 1, 0, 0, 0, 347, 348, 1, 0, 0, 0, 348, 350, 1, 0, 0, 0, 349, 351, 5, 1, 0, 0,
495 350, 349, 1, 0, 0, 0, 350, 351, 1, 0, 0, 0, 351, 353, 1, 0, 0, 0, 352, 354, 5, 31, 0, 0,
496 353, 352, 1, 0, 0, 0, 353, 354, 1, 0, 0, 0, 354, 356, 1, 0, 0, 0, 355, 357, 5, 32, 0, 0,
497 356, 355, 1, 0, 0, 0, 356, 357, 1, 0, 0, 0, 357, 372, 1, 0, 0, 0, 358, 361, 3, 4, 2, 0,
498 359, 361, 3, 40, 20, 0, 360, 358, 1, 0, 0, 0, 360, 359, 1, 0, 0, 0, 361, 373, 1, 0, 0, 0,
499 362, 365, 5, 33, 0, 0, 363, 366, 3, 4, 2, 0, 364, 366, 3, 40, 20, 0, 365, 363, 1, 0, 0, 0,
500 365, 364, 1, 0, 0, 0, 366, 370, 1, 0, 0, 0, 367, 368, 3, 38, 19, 0, 368, 369, 3, 152, 76, 0,
501 369, 371, 1, 0, 0, 0, 370, 367, 1, 0, 0, 0, 370, 371, 1, 0, 0, 0, 371, 373, 1, 0, 0, 0,
502 372, 360, 1, 0, 0, 0, 372, 362, 1, 0, 0, 0, 373, 375, 1, 0, 0, 0, 374, 344, 1, 0, 0, 0,
503 374, 345, 1, 0, 0, 0, 374, 347, 1, 0, 0, 0, 375, 376, 1, 0, 0, 0, 376, 377, 5, 2, 0, 0,
504 377, 31, 1, 0, 0, 0, 378, 391, 5, 34, 0, 0, 379, 380, 5, 89, 0, 0, 380, 381, 5, 20, 0, 0,
505 381, 392, 3, 130, 65, 0, 382, 383, 3, 130, 65, 0, 383, 384, 5, 35, 0, 0, 384, 392, 1, 0, 0, 0,
506 385, 386, 3, 130, 65, 0, 386, 387, 5, 36, 0, 0, 387, 388, 3, 34, 17, 0, 388, 389, 5, 37, 0, 0,
507 389, 392, 1, 0, 0, 0, 390, 392, 3, 130, 65, 0, 391, 379, 1, 0, 0, 0, 391, 382, 1, 0, 0, 0,
508 391, 385, 1, 0, 0, 0, 391, 390, 1, 0, 0, 0, 392, 393, 1, 0, 0, 0, 393, 394, 3, 152, 76, 0,
509 394, 33, 1, 0, 0, 0, 395, 400, 5, 89, 0, 0, 396, 397, 5, 26, 0, 0, 397, 399, 5, 89, 0, 0,
510 398, 396, 1, 0, 0, 0, 399, 402, 1, 0, 0, 0, 400, 398, 1, 0, 0, 0, 400, 401, 1, 0, 0, 0,
511 401, 35, 1, 0, 0, 0, 402, 400, 1, 0, 0, 0, 403, 404, 5, 19, 0, 0, 404, 406, 3, 130, 65, 0,
512 405, 407, 3, 56, 28, 0, 406, 405, 1, 0, 0, 0, 406, 407, 1, 0, 0, 0, 407, 409, 1, 0, 0, 0,
513 408, 410, 3, 158, 79, 0, 409, 408, 1, 0, 0, 0, 409, 410, 1, 0, 0, 0, 410, 37, 1, 0, 0, 0,
514 411, 412, 5, 38, 0, 0, 412, 414, 3, 130, 65, 0, 413, 415, 3, 56, 28, 0, 414, 413, 1, 0, 0, 0,
515 414, 415, 1, 0, 0, 0, 415, 39, 1, 0, 0, 0, 416, 417, 3, 42, 21, 0, 417, 419, 3, 44, 22, 0,
516 418, 420, 3, 148, 74, 0, 419, 418, 1, 0, 0, 0, 419, 420, 1, 0, 0, 0, 420, 421, 1, 0, 0, 0,
517 421, 422, 3, 46, 23, 0, 422, 41, 1, 0, 0, 0, 423, 425, 7, 1, 0, 0, 424, 423, 1, 0, 0, 0,
518 424, 425, 1, 0, 0, 0, 425, 427, 1, 0, 0, 0, 426, 428, 7, 2, 0, 0, 427, 426, 1, 0, 0, 0,
519 427, 428, 1, 0, 0, 0, 428, 430, 1, 0, 0, 0, 429, 431, 7, 3, 0, 0, 430, 429, 1, 0, 0, 0,
520 430, 431, 1, 0, 0, 0, 431, 43, 1, 0, 0, 0, 432, 433, 3, 130, 65, 0, 433, 45, 1, 0, 0, 0,
521 434, 439, 3, 48, 24, 0, 435, 436, 5, 26, 0, 0, 436, 438, 3, 48, 24, 0, 437, 435, 1, 0, 0, 0,
522 438, 441, 1, 0, 0, 0, 439, 437, 1, 0, 0, 0, 439, 440, 1, 0, 0, 0, 440, 47, 1, 0, 0, 0,
523 441, 439, 1, 0, 0, 0, 442, 444, 3, 52, 26, 0, 443, 445, 3, 50, 25, 0, 444, 443, 1, 0, 0, 0,
524 444, 445, 1, 0, 0, 0, 445, 446, 1, 0, 0, 0, 446, 447, 3, 152, 76, 0, 447, 49, 1, 0, 0, 0,
525 448, 449, 5, 46, 0, 0, 449, 450, 3, 104, 52, 0, 450, 51, 1, 0, 0, 0, 451, 453, 5, 89, 0, 0,
526 452, 454, 3, 148, 74, 0, 453, 452, 1, 0, 0, 0, 453, 454, 1, 0, 0, 0, 454, 456, 1, 0, 0, 0,
527 455, 457, 3, 54, 27, 0, 456, 455, 1, 0, 0, 0, 456, 457, 1, 0, 0, 0, 457, 53, 1, 0, 0, 0,
528 458, 461, 3, 56, 28, 0, 459, 460, 5, 20, 0, 0, 460, 462, 3, 104, 52, 0, 461, 459, 1, 0, 0, 0,
529 461, 462, 1, 0, 0, 0, 462, 468, 1, 0, 0, 0, 463, 464, 5, 20, 0, 0, 464, 468, 3, 104, 52, 0,
530 465, 466, 5, 47, 0, 0, 466, 468, 3, 104, 52, 0, 467, 458, 1, 0, 0, 0, 467, 463, 1, 0, 0, 0,
531 467, 465, 1, 0, 0, 0, 468, 55, 1, 0, 0, 0, 469, 471, 5, 22, 0, 0, 470, 472, 3, 58, 29, 0,
532 471, 470, 1, 0, 0, 0, 471, 472, 1, 0, 0, 0, 472, 473, 1, 0, 0, 0, 473, 474, 5, 24, 0, 0,
533 474, 57, 1, 0, 0, 0, 475, 480, 3, 60, 30, 0, 476, 477, 5, 26, 0, 0, 477, 479, 3, 60, 30, 0,
534 478, 476, 1, 0, 0, 0, 479, 482, 1, 0, 0, 0, 480, 478, 1, 0, 0, 0, 480, 481, 1, 0, 0, 0,
535 481, 59, 1, 0, 0, 0, 482, 480, 1, 0, 0, 0, 483, 486, 3, 62, 31, 0, 484, 486, 3, 66, 33, 0,
536 485, 483, 1, 0, 0, 0, 485, 484, 1, 0, 0, 0, 486, 61, 1, 0, 0, 0, 487, 489, 5, 48, 0, 0,
537 488, 487, 1, 0, 0, 0, 488, 489, 1, 0, 0, 0, 489, 491, 1, 0, 0, 0, 490, 492, 5, 1, 0, 0,
538 491, 490, 1, 0, 0, 0, 491, 492, 1, 0, 0, 0, 492, 495, 1, 0, 0, 0, 493, 496, 3, 64, 32, 0,
539 494, 496, 3, 68, 34, 0, 495, 493, 1, 0, 0, 0, 495, 494, 1, 0, 0, 0, 496, 63, 1, 0, 0, 0,
540 497, 499, 3, 130, 65, 0, 498, 500, 3, 54, 27, 0, 499, 498, 1, 0, 0, 0, 499, 500, 1, 0, 0, 0,
541 500, 501, 1, 0, 0, 0, 501, 502, 3, 154, 77, 0, 502, 65, 1, 0, 0, 0, 503, 505, 5, 30, 0, 0,
542 504, 506, 5, 48, 0, 0, 505, 504, 1, 0, 0, 0, 505, 506, 1, 0, 0, 0, 506, 508, 1, 0, 0, 0,
543 507, 509, 5, 1, 0, 0, 508, 507, 1, 0, 0, 0, 508, 509, 1, 0, 0, 0, 509, 515, 1, 0, 0, 0,
544 510, 513, 3, 74, 37, 0, 511, 513, 3, 70, 35, 0, 512, 510, 1, 0, 0, 0, 512, 511, 1, 0, 0, 0,
545 513, 516, 1, 0, 0, 0, 514, 516, 3, 68, 34, 0, 515, 512, 1, 0, 0, 0, 515, 514, 1, 0, 0, 0,
546 516, 67, 1, 0, 0, 0, 517, 520, 5, 33, 0, 0, 518, 521, 3, 74, 37, 0, 519, 521, 3, 70, 35, 0,
547 520, 518, 1, 0, 0, 0, 520, 519, 1, 0, 0, 0, 521, 523, 1, 0, 0, 0, 522, 524, 3, 38, 19, 0,
548 523, 522, 1, 0, 0, 0, 523, 524, 1, 0, 0, 0, 524, 69, 1, 0, 0, 0, 525, 526, 3, 42, 21, 0,
549 526, 527, 3, 44, 22, 0, 527, 528, 3, 72, 36, 0, 528, 71, 1, 0, 0, 0, 529, 530, 3, 52, 26, 0,
550 530, 531, 3, 152, 76, 0, 531, 73, 1, 0, 0, 0, 532, 533, 3, 8, 4, 0, 533, 534, 3, 12, 6, 0,
551 534, 75, 1, 0, 0, 0, 535, 537, 5, 49, 0, 0, 536, 535, 1, 0, 0, 0, 536, 537, 1, 0, 0, 0,
552 537, 538, 1, 0, 0, 0, 538, 542, 5, 50, 0, 0, 539, 541, 3, 80, 40, 0, 540, 539, 1, 0, 0, 0,
553 541, 544, 1, 0, 0, 0, 542, 540, 1, 0, 0, 0, 542, 543, 1, 0, 0, 0, 543, 77, 1, 0, 0, 0,
554 544, 542, 1, 0, 0, 0, 545, 547, 5, 49, 0, 0, 546, 545, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0,
555 547, 548, 1, 0, 0, 0, 548, 554, 5, 51, 0, 0, 549, 550, 3, 82, 41, 0, 550, 551, 5, 2, 0, 0,
556 551, 553, 1, 0, 0, 0, 552, 549, 1, 0, 0, 0, 553, 556, 1, 0, 0, 0, 554, 552, 1, 0, 0, 0,
557 554, 555, 1, 0, 0, 0, 555, 79, 1, 0, 0, 0, 556, 554, 1, 0, 0, 0, 557, 558, 3, 106, 53, 0,
558 558, 559, 5, 20, 0, 0, 559, 560, 3, 104, 52, 0, 560, 569, 1, 0, 0, 0, 561, 569, 3, 84, 42, 0,
559 562, 569, 3, 88, 44, 0, 563, 569, 3, 102, 51, 0, 564, 569, 3, 98, 49, 0, 565, 566, 3, 130, 65, 0,
560 566, 567, 3, 134, 67, 0, 567, 569, 1, 0, 0, 0, 568, 557, 1, 0, 0, 0, 568, 561, 1, 0, 0, 0,
561 568, 562, 1, 0, 0, 0, 568, 563, 1, 0, 0, 0, 568, 564, 1, 0, 0, 0, 568, 565, 1, 0, 0, 0,
562 569, 570, 1, 0, 0, 0, 570, 571, 3, 152, 76, 0, 571, 572, 5, 2, 0, 0, 572, 81, 1, 0, 0, 0,
563 573, 577, 3, 132, 66, 0, 574, 575, 5, 47, 0, 0, 575, 578, 3, 104, 52, 0, 576, 578, 3, 134, 67, 0,
564 577, 574, 1, 0, 0, 0, 577, 576, 1, 0, 0, 0, 578, 593, 1, 0, 0, 0, 579, 580, 5, 22, 0, 0,
565 580, 581, 3, 144, 72, 0, 581, 582, 5, 24, 0, 0, 582, 583, 5, 47, 0, 0, 583, 584, 3, 132, 66, 0,
566 584, 585, 3, 134, 67, 0, 585, 593, 1, 0, 0, 0, 586, 593, 5, 52, 0, 0, 587, 593, 5, 53, 0, 0,
567 588, 593, 3, 86, 43, 0, 589, 593, 3, 90, 45, 0, 590, 593, 3, 96, 48, 0, 591, 593, 3, 100, 50, 0,
568 592, 573, 1, 0, 0, 0, 592, 579, 1, 0, 0, 0, 592, 586, 1, 0, 0, 0, 592, 587, 1, 0, 0, 0,
569 592, 588, 1, 0, 0, 0, 592, 589, 1, 0, 0, 0, 592, 590, 1, 0, 0, 0, 592, 591, 1, 0, 0, 0,
570 593, 594, 1, 0, 0, 0, 594, 595, 3, 152, 76, 0, 595, 83, 1, 0, 0, 0, 596, 597, 5, 46, 0, 0,
571 597, 598, 3, 104, 52, 0, 598, 602, 5, 54, 0, 0, 599, 601, 3, 80, 40, 0, 600, 599, 1, 0, 0, 0,
572 601, 604, 1, 0, 0, 0, 602, 600, 1, 0, 0, 0, 602, 603, 1, 0, 0, 0, 603, 616, 1, 0, 0, 0,
573 604, 602, 1, 0, 0, 0, 605, 606, 5, 55, 0, 0, 606, 607, 3, 104, 52, 0, 607, 611, 5, 54, 0, 0,
574 608, 610, 3, 80, 40, 0, 609, 608, 1, 0, 0, 0, 610, 613, 1, 0, 0, 0, 611, 609, 1, 0, 0, 0,
575 611, 612, 1, 0, 0, 0, 612, 615, 1, 0, 0, 0, 613, 611, 1, 0, 0, 0, 614, 605, 1, 0, 0, 0,
576 615, 618, 1, 0, 0, 0, 616, 614, 1, 0, 0, 0, 616, 617, 1, 0, 0, 0, 617, 626, 1, 0, 0, 0,
577 618, 616, 1, 0, 0, 0, 619, 623, 5, 56, 0, 0, 620, 622, 3, 80, 40, 0, 621, 620, 1, 0, 0, 0,
578 622, 625, 1, 0, 0, 0, 623, 621, 1, 0, 0, 0, 623, 624, 1, 0, 0, 0, 624, 627, 1, 0, 0, 0,
579 625, 623, 1, 0, 0, 0, 626, 619, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 628, 1, 0, 0, 0,
580 628, 629, 5, 18, 0, 0, 629, 630, 5, 46, 0, 0, 630, 85, 1, 0, 0, 0, 631, 632, 5, 46, 0, 0,
581 632, 633, 3, 104, 52, 0, 633, 639, 5, 54, 0, 0, 634, 635, 3, 82, 41, 0, 635, 636, 5, 2, 0, 0,
582 636, 638, 1, 0, 0, 0, 637, 634, 1, 0, 0, 0, 638, 641, 1, 0, 0, 0, 639, 637, 1, 0, 0, 0,
583 639, 640, 1, 0, 0, 0, 640, 655, 1, 0, 0, 0, 641, 639, 1, 0, 0, 0, 642, 643, 5, 55, 0, 0,
584 643, 644, 3, 104, 52, 0, 644, 650, 5, 54, 0, 0, 645, 646, 3, 82, 41, 0, 646, 647, 5, 2, 0, 0,
585 647, 649, 1, 0, 0, 0, 648, 645, 1, 0, 0, 0, 649, 652, 1, 0, 0, 0, 650, 648, 1, 0, 0, 0,
586 650, 651, 1, 0, 0, 0, 651, 654, 1, 0, 0, 0, 652, 650, 1, 0, 0, 0, 653, 642, 1, 0, 0, 0,
587 654, 657, 1, 0, 0, 0, 655, 653, 1, 0, 0, 0, 655, 656, 1, 0, 0, 0, 656, 667, 1, 0, 0, 0,
588 657, 655, 1, 0, 0, 0, 658, 664, 5, 56, 0, 0, 659, 660, 3, 82, 41, 0, 660, 661, 5, 2, 0, 0,
589 661, 663, 1, 0, 0, 0, 662, 659, 1, 0, 0, 0, 663, 666, 1, 0, 0, 0, 664, 662, 1, 0, 0, 0,
590 664, 665, 1, 0, 0, 0, 665, 668, 1, 0, 0, 0, 666, 664, 1, 0, 0, 0, 667, 658, 1, 0, 0, 0,
591 667, 668, 1, 0, 0, 0, 668, 669, 1, 0, 0, 0, 669, 670, 5, 18, 0, 0, 670, 671, 5, 46, 0, 0,
592 671, 87, 1, 0, 0, 0, 672, 673, 5, 57, 0, 0, 673, 674, 3, 92, 46, 0, 674, 678, 5, 58, 0, 0,
593 675, 677, 3, 80, 40, 0, 676, 675, 1, 0, 0, 0, 677, 680, 1, 0, 0, 0, 678, 676, 1, 0, 0, 0,
594 678, 679, 1, 0, 0, 0, 679, 681, 1, 0, 0, 0, 680, 678, 1, 0, 0, 0, 681, 682, 5, 18, 0, 0,
595 682, 683, 5, 57, 0, 0, 683, 89, 1, 0, 0, 0, 684, 685, 5, 57, 0, 0, 685, 686, 3, 92, 46, 0,
596 686, 692, 5, 58, 0, 0, 687, 688, 3, 82, 41, 0, 688, 689, 5, 2, 0, 0, 689, 691, 1, 0, 0, 0,
597 690, 687, 1, 0, 0, 0, 691, 694, 1, 0, 0, 0, 692, 690, 1, 0, 0, 0, 692, 693, 1, 0, 0, 0,
598 693, 695, 1, 0, 0, 0, 694, 692, 1, 0, 0, 0, 695, 696, 5, 18, 0, 0, 696, 697, 5, 57, 0, 0,
599 697, 91, 1, 0, 0, 0, 698, 703, 3, 94, 47, 0, 699, 700, 5, 26, 0, 0, 700, 702, 3, 94, 47, 0,
600 701, 699, 1, 0, 0, 0, 702, 705, 1, 0, 0, 0, 703, 701, 1, 0, 0, 0, 703, 704, 1, 0, 0, 0,
601 704, 93, 1, 0, 0, 0, 705, 703, 1, 0, 0, 0, 706, 709, 5, 89, 0, 0, 707, 708, 5, 59, 0, 0,
602 708, 710, 3, 104, 52, 0, 709, 707, 1, 0, 0, 0, 709, 710, 1, 0, 0, 0, 710, 95, 1, 0, 0, 0,
603 711, 712, 5, 60, 0, 0, 712, 713, 3, 104, 52, 0, 713, 719, 5, 58, 0, 0, 714, 715, 3, 82, 41, 0,
604 715, 716, 5, 2, 0, 0, 716, 718, 1, 0, 0, 0, 717, 714, 1, 0, 0, 0, 718, 721, 1, 0, 0, 0,
605 719, 717, 1, 0, 0, 0, 719, 720, 1, 0, 0, 0, 720, 722, 1, 0, 0, 0, 721, 719, 1, 0, 0, 0,
606 722, 723, 5, 18, 0, 0, 723, 724, 5, 60, 0, 0, 724, 97, 1, 0, 0, 0, 725, 726, 5, 61, 0, 0,
607 726, 727, 3, 104, 52, 0, 727, 731, 5, 54, 0, 0, 728, 730, 3, 80, 40, 0, 729, 728, 1, 0, 0, 0,
608 730, 733, 1, 0, 0, 0, 731, 729, 1, 0, 0, 0, 731, 732, 1, 0, 0, 0, 732, 745, 1, 0, 0, 0,
609 733, 731, 1, 0, 0, 0, 734, 735, 5, 62, 0, 0, 735, 736, 3, 104, 52, 0, 736, 740, 5, 54, 0, 0,
610 737, 739, 3, 80, 40, 0, 738, 737, 1, 0, 0, 0, 739, 742, 1, 0, 0, 0, 740, 738, 1, 0, 0, 0,
611 740, 741, 1, 0, 0, 0, 741, 744, 1, 0, 0, 0, 742, 740, 1, 0, 0, 0, 743, 734, 1, 0, 0, 0,
612 744, 747, 1, 0, 0, 0, 745, 743, 1, 0, 0, 0, 745, 746, 1, 0, 0, 0, 746, 748, 1, 0, 0, 0,
613 747, 745, 1, 0, 0, 0, 748, 749, 5, 18, 0, 0, 749, 750, 5, 61, 0, 0, 750, 99, 1, 0, 0, 0,
614 751, 752, 5, 61, 0, 0, 752, 753, 3, 104, 52, 0, 753, 759, 5, 54, 0, 0, 754, 755, 3, 82, 41, 0,
615 755, 756, 5, 2, 0, 0, 756, 758, 1, 0, 0, 0, 757, 754, 1, 0, 0, 0, 758, 761, 1, 0, 0, 0,
616 759, 757, 1, 0, 0, 0, 759, 760, 1, 0, 0, 0, 760, 775, 1, 0, 0, 0, 761, 759, 1, 0, 0, 0,
617 762, 763, 5, 62, 0, 0, 763, 764, 3, 104, 52, 0, 764, 770, 5, 54, 0, 0, 765, 766, 3, 82, 41, 0,
618 766, 767, 5, 2, 0, 0, 767, 769, 1, 0, 0, 0, 768, 765, 1, 0, 0, 0, 769, 772, 1, 0, 0, 0,
619 770, 768, 1, 0, 0, 0, 770, 771, 1, 0, 0, 0, 771, 774, 1, 0, 0, 0, 772, 770, 1, 0, 0, 0,
620 773, 762, 1, 0, 0, 0, 774, 777, 1, 0, 0, 0, 775, 773, 1, 0, 0, 0, 775, 776, 1, 0, 0, 0,
621 776, 778, 1, 0, 0, 0, 777, 775, 1, 0, 0, 0, 778, 779, 5, 18, 0, 0, 779, 780, 5, 61, 0, 0,
622 780, 101, 1, 0, 0, 0, 781, 782, 5, 63, 0, 0, 782, 783, 5, 22, 0, 0, 783, 784, 3, 132, 66, 0,
623 784, 785, 5, 26, 0, 0, 785, 786, 3, 132, 66, 0, 786, 787, 5, 24, 0, 0, 787, 103, 1, 0, 0, 0,
624 788, 807, 3, 106, 53, 0, 789, 790, 5, 46, 0, 0, 790, 791, 3, 104, 52, 0, 791, 792, 5, 54, 0, 0,
625 792, 800, 3, 104, 52, 0, 793, 794, 5, 55, 0, 0, 794, 795, 3, 104, 52, 0, 795, 796, 5, 54, 0, 0,
626 796, 797, 3, 104, 52, 0, 797, 799, 1, 0, 0, 0, 798, 793, 1, 0, 0, 0, 799, 802, 1, 0, 0, 0,
627 800, 798, 1, 0, 0, 0, 800, 801, 1, 0, 0, 0, 801, 803, 1, 0, 0, 0, 802, 800, 1, 0, 0, 0,
628 803, 804, 5, 56, 0, 0, 804, 805, 3, 104, 52, 0, 805, 807, 1, 0, 0, 0, 806, 788, 1, 0, 0, 0,
629 806, 789, 1, 0, 0, 0, 807, 105, 1, 0, 0, 0, 808, 815, 3, 108, 54, 0, 809, 810, 5, 23, 0, 0,
630 810, 813, 3, 108, 54, 0, 811, 812, 5, 23, 0, 0, 812, 814, 3, 108, 54, 0, 813, 811, 1, 0, 0, 0,
631 813, 814, 1, 0, 0, 0, 814, 816, 1, 0, 0, 0, 815, 809, 1, 0, 0, 0, 815, 816, 1, 0, 0, 0,
632 816, 107, 1, 0, 0, 0, 817, 822, 3, 110, 55, 0, 818, 819, 5, 64, 0, 0, 819, 821, 3, 110, 55, 0,
633 820, 818, 1, 0, 0, 0, 821, 824, 1, 0, 0, 0, 822, 820, 1, 0, 0, 0, 822, 823, 1, 0, 0, 0,
634 823, 109, 1, 0, 0, 0, 824, 822, 1, 0, 0, 0, 825, 830, 3, 112, 56, 0, 826, 827, 5, 65, 0, 0,
635 827, 829, 3, 112, 56, 0, 828, 826, 1, 0, 0, 0, 829, 832, 1, 0, 0, 0, 830, 828, 1, 0, 0, 0,
636 830, 831, 1, 0, 0, 0, 831, 111, 1, 0, 0, 0, 832, 830, 1, 0, 0, 0, 833, 835, 5, 66, 0, 0,
637 834, 833, 1, 0, 0, 0, 834, 835, 1, 0, 0, 0, 835, 836, 1, 0, 0, 0, 836, 837, 3, 114, 57, 0,
638 837, 113, 1, 0, 0, 0, 838, 842, 3, 118, 59, 0, 839, 840, 3, 116, 58, 0, 840, 841, 3, 118, 59, 0,
639 841, 843, 1, 0, 0, 0, 842, 839, 1, 0, 0, 0, 842, 843, 1, 0, 0, 0, 843, 115, 1, 0, 0, 0,
640 844, 845, 7, 4, 0, 0, 845, 117, 1, 0, 0, 0, 846, 848, 3, 120, 60, 0, 847, 846, 1, 0, 0, 0,
641 847, 848, 1, 0, 0, 0, 848, 849, 1, 0, 0, 0, 849, 855, 3, 122, 61, 0, 850, 851, 3, 120, 60, 0,
642 851, 852, 3, 122, 61, 0, 852, 854, 1, 0, 0, 0, 853, 850, 1, 0, 0, 0, 854, 857, 1, 0, 0, 0,
643 855, 853, 1, 0, 0, 0, 855, 856, 1, 0, 0, 0, 856, 119, 1, 0, 0, 0, 857, 855, 1, 0, 0, 0,
644 858, 859, 7, 5, 0, 0, 859, 121, 1, 0, 0, 0, 860, 866, 3, 126, 63, 0, 861, 862, 3, 124, 62, 0,
645 862, 863, 3, 126, 63, 0, 863, 865, 1, 0, 0, 0, 864, 861, 1, 0, 0, 0, 865, 868, 1, 0, 0, 0,
646 866, 864, 1, 0, 0, 0, 866, 867, 1, 0, 0, 0, 867, 123, 1, 0, 0, 0, 868, 866, 1, 0, 0, 0,
647 869, 870, 7, 6, 0, 0, 870, 125, 1, 0, 0, 0, 871, 874, 3, 128, 64, 0, 872, 873, 7, 7, 0, 0,
648 873, 875, 3, 128, 64, 0, 874, 872, 1, 0, 0, 0, 874, 875, 1, 0, 0, 0, 875, 127, 1, 0, 0, 0,
649 876, 908, 5, 91, 0, 0, 877, 908, 5, 90, 0, 0, 878, 908, 5, 82, 0, 0, 879, 908, 5, 83, 0, 0,
650 880, 884, 3, 130, 65, 0, 881, 884, 5, 25, 0, 0, 882, 884, 5, 49, 0, 0, 883, 880, 1, 0, 0, 0,
651 883, 881, 1, 0, 0, 0, 883, 882, 1, 0, 0, 0, 884, 885, 1, 0, 0, 0, 885, 908, 3, 134, 67, 0,
652 886, 908, 3, 132, 66, 0, 887, 888, 5, 22, 0, 0, 888, 889, 3, 144, 72, 0, 889, 890, 5, 24, 0, 0,
653 890, 908, 1, 0, 0, 0, 891, 892, 5, 84, 0, 0, 892, 897, 3, 146, 73, 0, 893, 894, 5, 2, 0, 0,
654 894, 896, 3, 146, 73, 0, 895, 893, 1, 0, 0, 0, 896, 899, 1, 0, 0, 0, 897, 895, 1, 0, 0, 0,
655 897, 898, 1, 0, 0, 0, 898, 900, 1, 0, 0, 0, 899, 897, 1, 0, 0, 0, 900, 901, 5, 85, 0, 0,
656 901, 908, 1, 0, 0, 0, 902, 903, 5, 86, 0, 0, 903, 904, 3, 136, 68, 0, 904, 905, 5, 37, 0, 0,
657 905, 908, 1, 0, 0, 0, 906, 908, 5, 18, 0, 0, 907, 876, 1, 0, 0, 0, 907, 877, 1, 0, 0, 0,
658 907, 878, 1, 0, 0, 0, 907, 879, 1, 0, 0, 0, 907, 883, 1, 0, 0, 0, 907, 886, 1, 0, 0, 0,
659 907, 887, 1, 0, 0, 0, 907, 891, 1, 0, 0, 0, 907, 902, 1, 0, 0, 0, 907, 906, 1, 0, 0, 0,
660 908, 129, 1, 0, 0, 0, 909, 911, 5, 87, 0, 0, 910, 909, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0,
661 911, 912, 1, 0, 0, 0, 912, 917, 5, 89, 0, 0, 913, 914, 5, 87, 0, 0, 914, 916, 5, 89, 0, 0,
662 915, 913, 1, 0, 0, 0, 916, 919, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 917, 918, 1, 0, 0, 0,
663 918, 131, 1, 0, 0, 0, 919, 917, 1, 0, 0, 0, 920, 922, 5, 87, 0, 0, 921, 920, 1, 0, 0, 0,
664 921, 922, 1, 0, 0, 0, 922, 923, 1, 0, 0, 0, 923, 925, 5, 89, 0, 0, 924, 926, 3, 148, 74, 0,
665 925, 924, 1, 0, 0, 0, 925, 926, 1, 0, 0, 0, 926, 934, 1, 0, 0, 0, 927, 928, 5, 87, 0, 0,
666 928, 930, 5, 89, 0, 0, 929, 931, 3, 148, 74, 0, 930, 929, 1, 0, 0, 0, 930, 931, 1, 0, 0, 0,
667 931, 933, 1, 0, 0, 0, 932, 927, 1, 0, 0, 0, 933, 936, 1, 0, 0, 0, 934, 932, 1, 0, 0, 0,
668 934, 935, 1, 0, 0, 0, 935, 133, 1, 0, 0, 0, 936, 934, 1, 0, 0, 0, 937, 939, 5, 22, 0, 0,
669 938, 940, 3, 136, 68, 0, 939, 938, 1, 0, 0, 0, 939, 940, 1, 0, 0, 0, 940, 941, 1, 0, 0, 0,
670 941, 942, 5, 24, 0, 0, 942, 135, 1, 0, 0, 0, 943, 948, 3, 142, 71, 0, 944, 945, 5, 26, 0, 0,
671 945, 949, 3, 136, 68, 0, 946, 947, 5, 57, 0, 0, 947, 949, 3, 92, 46, 0, 948, 944, 1, 0, 0, 0,
672 948, 946, 1, 0, 0, 0, 948, 949, 1, 0, 0, 0, 949, 952, 1, 0, 0, 0, 950, 952, 3, 138, 69, 0,
673 951, 943, 1, 0, 0, 0, 951, 950, 1, 0, 0, 0, 952, 137, 1, 0, 0, 0, 953, 956, 3, 140, 70, 0,
674 954, 955, 5, 26, 0, 0, 955, 957, 3, 138, 69, 0, 956, 954, 1, 0, 0, 0, 956, 957, 1, 0, 0, 0,
675 957, 139, 1, 0, 0, 0, 958, 959, 5, 89, 0, 0, 959, 960, 5, 20, 0, 0, 960, 961, 3, 142, 71, 0,
676 961, 141, 1, 0, 0, 0, 962, 963, 5, 17, 0, 0, 963, 964, 3, 130, 65, 0, 964, 966, 5, 22, 0, 0,
677 965, 967, 3, 138, 69, 0, 966, 965, 1, 0, 0, 0, 966, 967, 1, 0, 0, 0, 967, 968, 1, 0, 0, 0,
678 968, 969, 5, 24, 0, 0, 969, 972, 1, 0, 0, 0, 970, 972, 3, 104, 52, 0, 971, 962, 1, 0, 0, 0,
679 971, 970, 1, 0, 0, 0, 972, 143, 1, 0, 0, 0, 973, 975, 3, 104, 52, 0, 974, 973, 1, 0, 0, 0,
680 974, 975, 1, 0, 0, 0, 975, 982, 1, 0, 0, 0, 976, 978, 5, 26, 0, 0, 977, 979, 3, 104, 52, 0,
681 978, 977, 1, 0, 0, 0, 978, 979, 1, 0, 0, 0, 979, 981, 1, 0, 0, 0, 980, 976, 1, 0, 0, 0,
682 981, 984, 1, 0, 0, 0, 982, 980, 1, 0, 0, 0, 982, 983, 1, 0, 0, 0, 983, 145, 1, 0, 0, 0,
683 984, 982, 1, 0, 0, 0, 985, 990, 3, 104, 52, 0, 986, 987, 5, 26, 0, 0, 987, 989, 3, 104, 52, 0,
684 988, 986, 1, 0, 0, 0, 989, 992, 1, 0, 0, 0, 990, 988, 1, 0, 0, 0, 990, 991, 1, 0, 0, 0,
685 991, 147, 1, 0, 0, 0, 992, 990, 1, 0, 0, 0, 993, 994, 5, 84, 0, 0, 994, 999, 3, 150, 75, 0,
686 995, 996, 5, 26, 0, 0, 996, 998, 3, 150, 75, 0, 997, 995, 1, 0, 0, 0, 998, 1001, 1, 0, 0, 0,
687 999, 997, 1, 0, 0, 0, 999, 1000, 1, 0, 0, 0, 1000, 1002, 1, 0, 0, 0, 1001, 999, 1, 0, 0, 0,
688 1002, 1003, 5, 85, 0, 0, 1003, 149, 1, 0, 0, 0, 1004, 1007, 5, 23, 0, 0, 1005, 1007, 3, 104, 52, 0,
689 1006, 1004, 1, 0, 0, 0, 1006, 1005, 1, 0, 0, 0, 1007, 151, 1, 0, 0, 0, 1008, 1010, 3, 154, 77, 0,
690 1009, 1011, 3, 158, 79, 0, 1010, 1009, 1, 0, 0, 0, 1010, 1011, 1, 0, 0, 0, 1011, 153, 1, 0, 0, 0,
691 1012, 1017, 5, 90, 0, 0, 1013, 1014, 5, 73, 0, 0, 1014, 1016, 5, 90, 0, 0, 1015, 1013, 1, 0, 0, 0,
692 1016, 1019, 1, 0, 0, 0, 1017, 1015, 1, 0, 0, 0, 1017, 1018, 1, 0, 0, 0, 1018, 1021, 1, 0, 0, 0,
693 1019, 1017, 1, 0, 0, 0, 1020, 1012, 1, 0, 0, 0, 1020, 1021, 1, 0, 0, 0, 1021, 155, 1, 0, 0, 0,
694 1022, 1023, 3, 158, 79, 0, 1023, 157, 1, 0, 0, 0, 1024, 1025, 5, 88, 0, 0, 1025, 1026, 3, 56, 28, 0,
695 1026, 159, 1, 0, 0, 0, 132, 163, 167, 174, 179, 184, 192, 195, 200, 205, 211, 214, 218, 229, 236, 243, 246, 255,
696 258, 262, 275, 288, 301, 303, 308, 311, 314, 317, 322, 329, 334, 341, 347, 350, 353, 356, 360, 365, 370, 372, 374, 391,
697 400, 406, 409, 414, 419, 424, 427, 430, 439, 444, 453, 456, 461, 467, 471, 480, 485, 488, 491, 495, 499, 505, 508, 512,
698 515, 520, 523, 536, 542, 546, 554, 568, 577, 592, 602, 611, 616, 623, 626, 639, 650, 655, 664, 667, 678, 692, 703, 709,
699 719, 731, 740, 745, 759, 770, 775, 800, 806, 813, 815, 822, 830, 834, 842, 847, 855, 866, 874, 883, 897, 907, 910, 917,
700 921, 925, 930, 934, 939, 948, 951, 956, 966, 971, 974, 978, 982, 990, 999, 1006, 1010, 1017, 1020};
701 ✗ staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
702
703 ✗ antlr4::atn::ATNDeserializer deserializer;
704 ✗ staticData->atn = deserializer.deserialize(staticData->serializedATN);
705
706 ✗ const size_t count = staticData->atn->getNumberOfDecisions();
707 ✗ staticData->decisionToDFA.reserve(count);
708 ✗ for (size_t i = 0; i < count; i++) {
709 ✗ staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
710 }
711 ✗ modelicaParserStaticData = std::move(staticData);
712 ✗ }
713
714 } // namespace
715
716 ✗ modelicaParser::modelicaParser(TokenStream* input) : modelicaParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}
717
718 ✗ modelicaParser::modelicaParser(TokenStream* input, const antlr4::atn::ParserATNSimulatorOptions& options) : Parser(input) {
719 ✗ modelicaParser::initialize();
720 ✗ _interpreter = new atn::ParserATNSimulator(this, *modelicaParserStaticData->atn, modelicaParserStaticData->decisionToDFA,
721 ✗ modelicaParserStaticData->sharedContextCache, options);
722 ✗ }
723
724 ✗ modelicaParser::~modelicaParser() {
725 ✗ delete _interpreter;
726 ✗ }
727
728 ✗ const atn::ATN& modelicaParser::getATN() const {
729 ✗ return *modelicaParserStaticData->atn;
730 }
731
732 ✗ std::string modelicaParser::getGrammarFileName() const {
733 ✗ return "modelica.g4";
734 }
735
736 ✗ const std::vector<std::string>& modelicaParser::getRuleNames() const {
737 ✗ return modelicaParserStaticData->ruleNames;
738 }
739
740 ✗ const dfa::Vocabulary& modelicaParser::getVocabulary() const {
741 ✗ return modelicaParserStaticData->vocabulary;
742 }
743
744 ✗ antlr4::atn::SerializedATNView modelicaParser::getSerializedATN() const {
745 ✗ return modelicaParserStaticData->serializedATN;
746 }
747
748 //----------------- Stored_definitionContext ------------------------------------------------------------------
749
750 ✗ modelicaParser::Stored_definitionContext::Stored_definitionContext(ParserRuleContext* parent, size_t invokingState)
751 ✗ : ParserRuleContext(parent, invokingState) {}
752
753 ✗ std::vector<modelicaParser::Within_statementContext*> modelicaParser::Stored_definitionContext::within_statement() {
754 ✗ return getRuleContexts<modelicaParser::Within_statementContext>();
755 }
756
757 ✗ modelicaParser::Within_statementContext* modelicaParser::Stored_definitionContext::within_statement(size_t i) {
758 ✗ return getRuleContext<modelicaParser::Within_statementContext>(i);
759 }
760
761 ✗ std::vector<modelicaParser::Class_definitionContext*> modelicaParser::Stored_definitionContext::class_definition() {
762 ✗ return getRuleContexts<modelicaParser::Class_definitionContext>();
763 }
764
765 ✗ modelicaParser::Class_definitionContext* modelicaParser::Stored_definitionContext::class_definition(size_t i) {
766 ✗ return getRuleContext<modelicaParser::Class_definitionContext>(i);
767 }
768
769 ✗ size_t modelicaParser::Stored_definitionContext::getRuleIndex() const {
770 ✗ return modelicaParser::RuleStored_definition;
771 }
772
773 ✗ void modelicaParser::Stored_definitionContext::enterRule(tree::ParseTreeListener* listener) {
774 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
775 ✗ if (parserListener != nullptr) parserListener->enterStored_definition(this);
776 ✗ }
777
778 ✗ void modelicaParser::Stored_definitionContext::exitRule(tree::ParseTreeListener* listener) {
779 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
780 ✗ if (parserListener != nullptr) parserListener->exitStored_definition(this);
781 ✗ }
782
783 ✗ std::any modelicaParser::Stored_definitionContext::accept(tree::ParseTreeVisitor* visitor) {
784 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
785 ✗ return parserVisitor->visitStored_definition(this);
786 else
787 ✗ return visitor->visitChildren(this);
788 }
789
790 ✗ modelicaParser::Stored_definitionContext* modelicaParser::stored_definition() {
791 ✗ Stored_definitionContext* _localctx = _tracker.createInstance<Stored_definitionContext>(_ctx, getState());
792 ✗ enterRule(_localctx, 0, modelicaParser::RuleStored_definition);
793 ✗ size_t _la = 0;
794
795 #if __cplusplus > 201703L
796 ✗ auto onExit = finally([=, this] {
797 #else
798 auto onExit = finally([=] {
799 #endif
800 ✗ exitRule();
801 ✗ });
802 try {
803 ✗ enterOuterAlt(_localctx, 1);
804 ✗ setState(163);
805 ✗ _errHandler->sync(this);
806 ✗ _la = _input->LA(1);
807 ✗ while (_la == modelicaParser::T__2) {
808 ✗ setState(160);
809 ✗ within_statement();
810 ✗ setState(165);
811 ✗ _errHandler->sync(this);
812 ✗ _la = _input->LA(1);
813 }
814 ✗ setState(174);
815 ✗ _errHandler->sync(this);
816 ✗ _la = _input->LA(1);
817 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 262130) != 0)) {
818 ✗ setState(167);
819 ✗ _errHandler->sync(this);
820
821 ✗ _la = _input->LA(1);
822 ✗ if (_la == modelicaParser::T__0) {
823 ✗ setState(166);
824 ✗ match(modelicaParser::T__0);
825 }
826 ✗ setState(169);
827 ✗ class_definition();
828 ✗ setState(170);
829 ✗ match(modelicaParser::T__1);
830 ✗ setState(176);
831 ✗ _errHandler->sync(this);
832 ✗ _la = _input->LA(1);
833 }
834
835 ✗ } catch (RecognitionException& e) {
836 ✗ _errHandler->reportError(this, e);
837 ✗ _localctx->exception = std::current_exception();
838 ✗ _errHandler->recover(this, _localctx->exception);
839 ✗ }
840
841 ✗ return _localctx;
842 ✗ }
843
844 //----------------- Within_statementContext ------------------------------------------------------------------
845
846 ✗ modelicaParser::Within_statementContext::Within_statementContext(ParserRuleContext* parent, size_t invokingState)
847 ✗ : ParserRuleContext(parent, invokingState) {}
848
849 ✗ modelicaParser::NameContext* modelicaParser::Within_statementContext::name() {
850 ✗ return getRuleContext<modelicaParser::NameContext>(0);
851 }
852
853 ✗ size_t modelicaParser::Within_statementContext::getRuleIndex() const {
854 ✗ return modelicaParser::RuleWithin_statement;
855 }
856
857 ✗ void modelicaParser::Within_statementContext::enterRule(tree::ParseTreeListener* listener) {
858 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
859 ✗ if (parserListener != nullptr) parserListener->enterWithin_statement(this);
860 ✗ }
861
862 ✗ void modelicaParser::Within_statementContext::exitRule(tree::ParseTreeListener* listener) {
863 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
864 ✗ if (parserListener != nullptr) parserListener->exitWithin_statement(this);
865 ✗ }
866
867 ✗ std::any modelicaParser::Within_statementContext::accept(tree::ParseTreeVisitor* visitor) {
868 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
869 ✗ return parserVisitor->visitWithin_statement(this);
870 else
871 ✗ return visitor->visitChildren(this);
872 }
873
874 ✗ modelicaParser::Within_statementContext* modelicaParser::within_statement() {
875 ✗ Within_statementContext* _localctx = _tracker.createInstance<Within_statementContext>(_ctx, getState());
876 ✗ enterRule(_localctx, 2, modelicaParser::RuleWithin_statement);
877 ✗ size_t _la = 0;
878
879 #if __cplusplus > 201703L
880 ✗ auto onExit = finally([=, this] {
881 #else
882 auto onExit = finally([=] {
883 #endif
884 ✗ exitRule();
885 ✗ });
886 try {
887 ✗ enterOuterAlt(_localctx, 1);
888 ✗ setState(177);
889 ✗ match(modelicaParser::T__2);
890 ✗ setState(179);
891 ✗ _errHandler->sync(this);
892
893 ✗ _la = _input->LA(1);
894 ✗ if (_la == modelicaParser::T__86
895
896 ✗ || _la == modelicaParser::IDENT) {
897 ✗ setState(178);
898 ✗ name();
899 }
900 ✗ setState(181);
901 ✗ match(modelicaParser::T__1);
902
903 ✗ } catch (RecognitionException& e) {
904 ✗ _errHandler->reportError(this, e);
905 ✗ _localctx->exception = std::current_exception();
906 ✗ _errHandler->recover(this, _localctx->exception);
907 ✗ }
908
909 ✗ return _localctx;
910 ✗ }
911
912 //----------------- Class_definitionContext ------------------------------------------------------------------
913
914 ✗ modelicaParser::Class_definitionContext::Class_definitionContext(ParserRuleContext* parent, size_t invokingState)
915 ✗ : ParserRuleContext(parent, invokingState) {}
916
917 ✗ modelicaParser::Class_prefixesContext* modelicaParser::Class_definitionContext::class_prefixes() {
918 ✗ return getRuleContext<modelicaParser::Class_prefixesContext>(0);
919 }
920
921 ✗ modelicaParser::Class_specifierContext* modelicaParser::Class_definitionContext::class_specifier() {
922 ✗ return getRuleContext<modelicaParser::Class_specifierContext>(0);
923 }
924
925 ✗ size_t modelicaParser::Class_definitionContext::getRuleIndex() const {
926 ✗ return modelicaParser::RuleClass_definition;
927 }
928
929 ✗ void modelicaParser::Class_definitionContext::enterRule(tree::ParseTreeListener* listener) {
930 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
931 ✗ if (parserListener != nullptr) parserListener->enterClass_definition(this);
932 ✗ }
933
934 ✗ void modelicaParser::Class_definitionContext::exitRule(tree::ParseTreeListener* listener) {
935 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
936 ✗ if (parserListener != nullptr) parserListener->exitClass_definition(this);
937 ✗ }
938
939 ✗ std::any modelicaParser::Class_definitionContext::accept(tree::ParseTreeVisitor* visitor) {
940 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
941 ✗ return parserVisitor->visitClass_definition(this);
942 else
943 ✗ return visitor->visitChildren(this);
944 }
945
946 ✗ modelicaParser::Class_definitionContext* modelicaParser::class_definition() {
947 ✗ Class_definitionContext* _localctx = _tracker.createInstance<Class_definitionContext>(_ctx, getState());
948 ✗ enterRule(_localctx, 4, modelicaParser::RuleClass_definition);
949 ✗ size_t _la = 0;
950
951 #if __cplusplus > 201703L
952 ✗ auto onExit = finally([=, this] {
953 #else
954 auto onExit = finally([=] {
955 #endif
956 ✗ exitRule();
957 ✗ });
958 try {
959 ✗ enterOuterAlt(_localctx, 1);
960 ✗ setState(184);
961 ✗ _errHandler->sync(this);
962
963 ✗ _la = _input->LA(1);
964 ✗ if (_la == modelicaParser::T__3) {
965 ✗ setState(183);
966 ✗ match(modelicaParser::T__3);
967 }
968 ✗ setState(186);
969 ✗ class_prefixes();
970 ✗ setState(187);
971 ✗ class_specifier();
972
973 ✗ } catch (RecognitionException& e) {
974 ✗ _errHandler->reportError(this, e);
975 ✗ _localctx->exception = std::current_exception();
976 ✗ _errHandler->recover(this, _localctx->exception);
977 ✗ }
978
979 ✗ return _localctx;
980 ✗ }
981
982 //----------------- Class_specifierContext ------------------------------------------------------------------
983
984 ✗ modelicaParser::Class_specifierContext::Class_specifierContext(ParserRuleContext* parent, size_t invokingState)
985 ✗ : ParserRuleContext(parent, invokingState) {}
986
987 ✗ modelicaParser::Long_class_specifierContext* modelicaParser::Class_specifierContext::long_class_specifier() {
988 ✗ return getRuleContext<modelicaParser::Long_class_specifierContext>(0);
989 }
990
991 ✗ modelicaParser::Short_class_specifierContext* modelicaParser::Class_specifierContext::short_class_specifier() {
992 ✗ return getRuleContext<modelicaParser::Short_class_specifierContext>(0);
993 }
994
995 ✗ modelicaParser::Der_class_specifierContext* modelicaParser::Class_specifierContext::der_class_specifier() {
996 ✗ return getRuleContext<modelicaParser::Der_class_specifierContext>(0);
997 }
998
999 ✗ size_t modelicaParser::Class_specifierContext::getRuleIndex() const {
1000 ✗ return modelicaParser::RuleClass_specifier;
1001 }
1002
1003 ✗ void modelicaParser::Class_specifierContext::enterRule(tree::ParseTreeListener* listener) {
1004 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1005 ✗ if (parserListener != nullptr) parserListener->enterClass_specifier(this);
1006 ✗ }
1007
1008 ✗ void modelicaParser::Class_specifierContext::exitRule(tree::ParseTreeListener* listener) {
1009 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1010 ✗ if (parserListener != nullptr) parserListener->exitClass_specifier(this);
1011 ✗ }
1012
1013 ✗ std::any modelicaParser::Class_specifierContext::accept(tree::ParseTreeVisitor* visitor) {
1014 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
1015 ✗ return parserVisitor->visitClass_specifier(this);
1016 else
1017 ✗ return visitor->visitChildren(this);
1018 }
1019
1020 ✗ modelicaParser::Class_specifierContext* modelicaParser::class_specifier() {
1021 ✗ Class_specifierContext* _localctx = _tracker.createInstance<Class_specifierContext>(_ctx, getState());
1022 ✗ enterRule(_localctx, 6, modelicaParser::RuleClass_specifier);
1023
1024 #if __cplusplus > 201703L
1025 ✗ auto onExit = finally([=, this] {
1026 #else
1027 auto onExit = finally([=] {
1028 #endif
1029 ✗ exitRule();
1030 ✗ });
1031 try {
1032 ✗ setState(192);
1033 ✗ _errHandler->sync(this);
1034 ✗ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx)) {
1035 ✗ case 1: {
1036 ✗ enterOuterAlt(_localctx, 1);
1037 ✗ setState(189);
1038 ✗ long_class_specifier();
1039 ✗ break;
1040 }
1041
1042 ✗ case 2: {
1043 ✗ enterOuterAlt(_localctx, 2);
1044 ✗ setState(190);
1045 ✗ short_class_specifier();
1046 ✗ break;
1047 }
1048
1049 ✗ case 3: {
1050 ✗ enterOuterAlt(_localctx, 3);
1051 ✗ setState(191);
1052 ✗ der_class_specifier();
1053 ✗ break;
1054 }
1055
1056 ✗ default:
1057 ✗ break;
1058 }
1059
1060 ✗ } catch (RecognitionException& e) {
1061 ✗ _errHandler->reportError(this, e);
1062 ✗ _localctx->exception = std::current_exception();
1063 ✗ _errHandler->recover(this, _localctx->exception);
1064 ✗ }
1065
1066 ✗ return _localctx;
1067 ✗ }
1068
1069 //----------------- Class_prefixesContext ------------------------------------------------------------------
1070
1071 ✗ modelicaParser::Class_prefixesContext::Class_prefixesContext(ParserRuleContext* parent, size_t invokingState)
1072 ✗ : ParserRuleContext(parent, invokingState) {}
1073
1074 ✗ size_t modelicaParser::Class_prefixesContext::getRuleIndex() const {
1075 ✗ return modelicaParser::RuleClass_prefixes;
1076 }
1077
1078 ✗ void modelicaParser::Class_prefixesContext::enterRule(tree::ParseTreeListener* listener) {
1079 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1080 ✗ if (parserListener != nullptr) parserListener->enterClass_prefixes(this);
1081 ✗ }
1082
1083 ✗ void modelicaParser::Class_prefixesContext::exitRule(tree::ParseTreeListener* listener) {
1084 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1085 ✗ if (parserListener != nullptr) parserListener->exitClass_prefixes(this);
1086 ✗ }
1087
1088 ✗ std::any modelicaParser::Class_prefixesContext::accept(tree::ParseTreeVisitor* visitor) {
1089 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
1090 ✗ return parserVisitor->visitClass_prefixes(this);
1091 else
1092 ✗ return visitor->visitChildren(this);
1093 }
1094
1095 ✗ modelicaParser::Class_prefixesContext* modelicaParser::class_prefixes() {
1096 ✗ Class_prefixesContext* _localctx = _tracker.createInstance<Class_prefixesContext>(_ctx, getState());
1097 ✗ enterRule(_localctx, 8, modelicaParser::RuleClass_prefixes);
1098 ✗ size_t _la = 0;
1099
1100 #if __cplusplus > 201703L
1101 ✗ auto onExit = finally([=, this] {
1102 #else
1103 auto onExit = finally([=] {
1104 #endif
1105 ✗ exitRule();
1106 ✗ });
1107 try {
1108 ✗ enterOuterAlt(_localctx, 1);
1109 ✗ setState(195);
1110 ✗ _errHandler->sync(this);
1111
1112 ✗ _la = _input->LA(1);
1113 ✗ if (_la == modelicaParser::T__4) {
1114 ✗ setState(194);
1115 ✗ match(modelicaParser::T__4);
1116 }
1117 ✗ setState(218);
1118 ✗ _errHandler->sync(this);
1119 ✗ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx)) {
1120 ✗ case 1: {
1121 ✗ setState(197);
1122 ✗ match(modelicaParser::T__5);
1123 ✗ break;
1124 }
1125
1126 ✗ case 2: {
1127 ✗ setState(198);
1128 ✗ match(modelicaParser::T__6);
1129 ✗ break;
1130 }
1131
1132 ✗ case 3: {
1133 ✗ setState(200);
1134 ✗ _errHandler->sync(this);
1135
1136 ✗ _la = _input->LA(1);
1137 ✗ if (_la == modelicaParser::T__7) {
1138 ✗ setState(199);
1139 ✗ match(modelicaParser::T__7);
1140 }
1141 ✗ setState(202);
1142 ✗ match(modelicaParser::T__8);
1143 ✗ break;
1144 }
1145
1146 ✗ case 4: {
1147 ✗ setState(203);
1148 ✗ match(modelicaParser::T__9);
1149 ✗ break;
1150 }
1151
1152 ✗ case 5: {
1153 ✗ setState(205);
1154 ✗ _errHandler->sync(this);
1155
1156 ✗ _la = _input->LA(1);
1157 ✗ if (_la == modelicaParser::T__10) {
1158 ✗ setState(204);
1159 ✗ match(modelicaParser::T__10);
1160 }
1161 ✗ setState(207);
1162 ✗ match(modelicaParser::T__11);
1163 ✗ break;
1164 }
1165
1166 ✗ case 6: {
1167 ✗ setState(208);
1168 ✗ match(modelicaParser::T__12);
1169 ✗ break;
1170 }
1171
1172 ✗ case 7: {
1173 ✗ setState(209);
1174 ✗ match(modelicaParser::T__13);
1175 ✗ break;
1176 }
1177
1178 ✗ case 8: {
1179 ✗ setState(211);
1180 ✗ _errHandler->sync(this);
1181
1182 ✗ _la = _input->LA(1);
1183 ✗ if (_la == modelicaParser::T__14
1184
1185 ✗ || _la == modelicaParser::T__15) {
1186 ✗ setState(210);
1187 ✗ _la = _input->LA(1);
1188 ✗ if (!(_la == modelicaParser::T__14
1189
1190 || _la == modelicaParser::T__15)) {
1191 ✗ _errHandler->recoverInline(this);
1192 } else {
1193 ✗ _errHandler->reportMatch(this);
1194 ✗ consume();
1195 }
1196 }
1197 ✗ setState(214);
1198 ✗ _errHandler->sync(this);
1199
1200 ✗ _la = _input->LA(1);
1201 ✗ if (_la == modelicaParser::T__7) {
1202 ✗ setState(213);
1203 ✗ match(modelicaParser::T__7);
1204 }
1205 ✗ setState(216);
1206 ✗ match(modelicaParser::T__16);
1207 ✗ break;
1208 }
1209
1210 ✗ case 9: {
1211 ✗ setState(217);
1212 ✗ match(modelicaParser::T__7);
1213 ✗ break;
1214 }
1215
1216 ✗ default:
1217 ✗ break;
1218 }
1219
1220 ✗ } catch (RecognitionException& e) {
1221 ✗ _errHandler->reportError(this, e);
1222 ✗ _localctx->exception = std::current_exception();
1223 ✗ _errHandler->recover(this, _localctx->exception);
1224 ✗ }
1225
1226 ✗ return _localctx;
1227 ✗ }
1228
1229 //----------------- Long_class_specifierContext ------------------------------------------------------------------
1230
1231 ✗ modelicaParser::Long_class_specifierContext::Long_class_specifierContext(ParserRuleContext* parent, size_t invokingState)
1232 ✗ : ParserRuleContext(parent, invokingState) {}
1233
1234 ✗ std::vector<tree::TerminalNode*> modelicaParser::Long_class_specifierContext::IDENT() {
1235 ✗ return getTokens(modelicaParser::IDENT);
1236 }
1237
1238 ✗ tree::TerminalNode* modelicaParser::Long_class_specifierContext::IDENT(size_t i) {
1239 ✗ return getToken(modelicaParser::IDENT, i);
1240 }
1241
1242 ✗ modelicaParser::String_commentContext* modelicaParser::Long_class_specifierContext::string_comment() {
1243 ✗ return getRuleContext<modelicaParser::String_commentContext>(0);
1244 }
1245
1246 ✗ modelicaParser::CompositionContext* modelicaParser::Long_class_specifierContext::composition() {
1247 ✗ return getRuleContext<modelicaParser::CompositionContext>(0);
1248 }
1249
1250 ✗ modelicaParser::Class_modificationContext* modelicaParser::Long_class_specifierContext::class_modification() {
1251 ✗ return getRuleContext<modelicaParser::Class_modificationContext>(0);
1252 }
1253
1254 ✗ size_t modelicaParser::Long_class_specifierContext::getRuleIndex() const {
1255 ✗ return modelicaParser::RuleLong_class_specifier;
1256 }
1257
1258 ✗ void modelicaParser::Long_class_specifierContext::enterRule(tree::ParseTreeListener* listener) {
1259 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1260 ✗ if (parserListener != nullptr) parserListener->enterLong_class_specifier(this);
1261 ✗ }
1262
1263 ✗ void modelicaParser::Long_class_specifierContext::exitRule(tree::ParseTreeListener* listener) {
1264 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1265 ✗ if (parserListener != nullptr) parserListener->exitLong_class_specifier(this);
1266 ✗ }
1267
1268 ✗ std::any modelicaParser::Long_class_specifierContext::accept(tree::ParseTreeVisitor* visitor) {
1269 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
1270 ✗ return parserVisitor->visitLong_class_specifier(this);
1271 else
1272 ✗ return visitor->visitChildren(this);
1273 }
1274
1275 ✗ modelicaParser::Long_class_specifierContext* modelicaParser::long_class_specifier() {
1276 ✗ Long_class_specifierContext* _localctx = _tracker.createInstance<Long_class_specifierContext>(_ctx, getState());
1277 ✗ enterRule(_localctx, 10, modelicaParser::RuleLong_class_specifier);
1278 ✗ size_t _la = 0;
1279
1280 #if __cplusplus > 201703L
1281 ✗ auto onExit = finally([=, this] {
1282 #else
1283 auto onExit = finally([=] {
1284 #endif
1285 ✗ exitRule();
1286 ✗ });
1287 try {
1288 ✗ setState(236);
1289 ✗ _errHandler->sync(this);
1290 ✗ switch (_input->LA(1)) {
1291 ✗ case modelicaParser::IDENT: {
1292 ✗ enterOuterAlt(_localctx, 1);
1293 ✗ setState(220);
1294 ✗ match(modelicaParser::IDENT);
1295 ✗ setState(221);
1296 ✗ string_comment();
1297 ✗ setState(222);
1298 ✗ composition();
1299 ✗ setState(223);
1300 ✗ match(modelicaParser::T__17);
1301 ✗ setState(224);
1302 ✗ match(modelicaParser::IDENT);
1303 ✗ break;
1304 }
1305
1306 ✗ case modelicaParser::T__18: {
1307 ✗ enterOuterAlt(_localctx, 2);
1308 ✗ setState(226);
1309 ✗ match(modelicaParser::T__18);
1310 ✗ setState(227);
1311 ✗ match(modelicaParser::IDENT);
1312 ✗ setState(229);
1313 ✗ _errHandler->sync(this);
1314
1315 ✗ _la = _input->LA(1);
1316 ✗ if (_la == modelicaParser::T__21) {
1317 ✗ setState(228);
1318 ✗ class_modification();
1319 }
1320 ✗ setState(231);
1321 ✗ string_comment();
1322 ✗ setState(232);
1323 ✗ composition();
1324 ✗ setState(233);
1325 ✗ match(modelicaParser::T__17);
1326 ✗ setState(234);
1327 ✗ match(modelicaParser::IDENT);
1328 ✗ break;
1329 }
1330
1331 ✗ default:
1332 ✗ throw NoViableAltException(this);
1333 }
1334
1335 ✗ } catch (RecognitionException& e) {
1336 ✗ _errHandler->reportError(this, e);
1337 ✗ _localctx->exception = std::current_exception();
1338 ✗ _errHandler->recover(this, _localctx->exception);
1339 ✗ }
1340
1341 ✗ return _localctx;
1342 ✗ }
1343
1344 //----------------- Short_class_specifierContext ------------------------------------------------------------------
1345
1346 ✗ modelicaParser::Short_class_specifierContext::Short_class_specifierContext(ParserRuleContext* parent, size_t invokingState)
1347 ✗ : ParserRuleContext(parent, invokingState) {}
1348
1349 ✗ tree::TerminalNode* modelicaParser::Short_class_specifierContext::IDENT() {
1350 ✗ return getToken(modelicaParser::IDENT, 0);
1351 }
1352
1353 ✗ modelicaParser::Base_prefixContext* modelicaParser::Short_class_specifierContext::base_prefix() {
1354 ✗ return getRuleContext<modelicaParser::Base_prefixContext>(0);
1355 }
1356
1357 ✗ modelicaParser::NameContext* modelicaParser::Short_class_specifierContext::name() {
1358 ✗ return getRuleContext<modelicaParser::NameContext>(0);
1359 }
1360
1361 ✗ modelicaParser::CommentContext* modelicaParser::Short_class_specifierContext::comment() {
1362 ✗ return getRuleContext<modelicaParser::CommentContext>(0);
1363 }
1364
1365 ✗ modelicaParser::Array_subscriptsContext* modelicaParser::Short_class_specifierContext::array_subscripts() {
1366 ✗ return getRuleContext<modelicaParser::Array_subscriptsContext>(0);
1367 }
1368
1369 ✗ modelicaParser::Class_modificationContext* modelicaParser::Short_class_specifierContext::class_modification() {
1370 ✗ return getRuleContext<modelicaParser::Class_modificationContext>(0);
1371 }
1372
1373 ✗ modelicaParser::Enum_listContext* modelicaParser::Short_class_specifierContext::enum_list() {
1374 ✗ return getRuleContext<modelicaParser::Enum_listContext>(0);
1375 }
1376
1377 ✗ size_t modelicaParser::Short_class_specifierContext::getRuleIndex() const {
1378 ✗ return modelicaParser::RuleShort_class_specifier;
1379 }
1380
1381 ✗ void modelicaParser::Short_class_specifierContext::enterRule(tree::ParseTreeListener* listener) {
1382 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1383 ✗ if (parserListener != nullptr) parserListener->enterShort_class_specifier(this);
1384 ✗ }
1385
1386 ✗ void modelicaParser::Short_class_specifierContext::exitRule(tree::ParseTreeListener* listener) {
1387 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1388 ✗ if (parserListener != nullptr) parserListener->exitShort_class_specifier(this);
1389 ✗ }
1390
1391 ✗ std::any modelicaParser::Short_class_specifierContext::accept(tree::ParseTreeVisitor* visitor) {
1392 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
1393 ✗ return parserVisitor->visitShort_class_specifier(this);
1394 else
1395 ✗ return visitor->visitChildren(this);
1396 }
1397
1398 ✗ modelicaParser::Short_class_specifierContext* modelicaParser::short_class_specifier() {
1399 ✗ Short_class_specifierContext* _localctx = _tracker.createInstance<Short_class_specifierContext>(_ctx, getState());
1400 ✗ enterRule(_localctx, 12, modelicaParser::RuleShort_class_specifier);
1401 ✗ size_t _la = 0;
1402
1403 #if __cplusplus > 201703L
1404 ✗ auto onExit = finally([=, this] {
1405 #else
1406 auto onExit = finally([=] {
1407 #endif
1408 ✗ exitRule();
1409 ✗ });
1410 try {
1411 ✗ setState(262);
1412 ✗ _errHandler->sync(this);
1413 ✗ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx)) {
1414 ✗ case 1: {
1415 ✗ enterOuterAlt(_localctx, 1);
1416 ✗ setState(238);
1417 ✗ match(modelicaParser::IDENT);
1418 ✗ setState(239);
1419 ✗ match(modelicaParser::T__19);
1420 ✗ setState(240);
1421 ✗ base_prefix();
1422 ✗ setState(241);
1423 ✗ name();
1424 ✗ setState(243);
1425 ✗ _errHandler->sync(this);
1426
1427 ✗ _la = _input->LA(1);
1428 ✗ if (_la == modelicaParser::T__83) {
1429 ✗ setState(242);
1430 ✗ array_subscripts();
1431 }
1432 ✗ setState(246);
1433 ✗ _errHandler->sync(this);
1434
1435 ✗ _la = _input->LA(1);
1436 ✗ if (_la == modelicaParser::T__21) {
1437 ✗ setState(245);
1438 ✗ class_modification();
1439 }
1440 ✗ setState(248);
1441 ✗ comment();
1442 ✗ break;
1443 }
1444
1445 ✗ case 2: {
1446 ✗ enterOuterAlt(_localctx, 2);
1447 ✗ setState(250);
1448 ✗ match(modelicaParser::IDENT);
1449 ✗ setState(251);
1450 ✗ match(modelicaParser::T__19);
1451 ✗ setState(252);
1452 ✗ match(modelicaParser::T__20);
1453 ✗ setState(253);
1454 ✗ match(modelicaParser::T__21);
1455 ✗ setState(258);
1456 ✗ _errHandler->sync(this);
1457 ✗ switch (_input->LA(1)) {
1458 ✗ case modelicaParser::T__23:
1459 case modelicaParser::IDENT: {
1460 ✗ setState(255);
1461 ✗ _errHandler->sync(this);
1462
1463 ✗ _la = _input->LA(1);
1464 ✗ if (_la == modelicaParser::IDENT) {
1465 ✗ setState(254);
1466 ✗ enum_list();
1467 }
1468 ✗ break;
1469 }
1470
1471 ✗ case modelicaParser::T__22: {
1472 ✗ setState(257);
1473 ✗ match(modelicaParser::T__22);
1474 ✗ break;
1475 }
1476
1477 ✗ default:
1478 ✗ throw NoViableAltException(this);
1479 }
1480 ✗ setState(260);
1481 ✗ match(modelicaParser::T__23);
1482 ✗ setState(261);
1483 ✗ comment();
1484 ✗ break;
1485 }
1486
1487 ✗ default:
1488 ✗ break;
1489 }
1490
1491 ✗ } catch (RecognitionException& e) {
1492 ✗ _errHandler->reportError(this, e);
1493 ✗ _localctx->exception = std::current_exception();
1494 ✗ _errHandler->recover(this, _localctx->exception);
1495 ✗ }
1496
1497 ✗ return _localctx;
1498 ✗ }
1499
1500 //----------------- Der_class_specifierContext ------------------------------------------------------------------
1501
1502 ✗ modelicaParser::Der_class_specifierContext::Der_class_specifierContext(ParserRuleContext* parent, size_t invokingState)
1503 ✗ : ParserRuleContext(parent, invokingState) {}
1504
1505 ✗ std::vector<tree::TerminalNode*> modelicaParser::Der_class_specifierContext::IDENT() {
1506 ✗ return getTokens(modelicaParser::IDENT);
1507 }
1508
1509 ✗ tree::TerminalNode* modelicaParser::Der_class_specifierContext::IDENT(size_t i) {
1510 ✗ return getToken(modelicaParser::IDENT, i);
1511 }
1512
1513 ✗ modelicaParser::NameContext* modelicaParser::Der_class_specifierContext::name() {
1514 ✗ return getRuleContext<modelicaParser::NameContext>(0);
1515 }
1516
1517 ✗ modelicaParser::CommentContext* modelicaParser::Der_class_specifierContext::comment() {
1518 ✗ return getRuleContext<modelicaParser::CommentContext>(0);
1519 }
1520
1521 ✗ size_t modelicaParser::Der_class_specifierContext::getRuleIndex() const {
1522 ✗ return modelicaParser::RuleDer_class_specifier;
1523 }
1524
1525 ✗ void modelicaParser::Der_class_specifierContext::enterRule(tree::ParseTreeListener* listener) {
1526 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1527 ✗ if (parserListener != nullptr) parserListener->enterDer_class_specifier(this);
1528 ✗ }
1529
1530 ✗ void modelicaParser::Der_class_specifierContext::exitRule(tree::ParseTreeListener* listener) {
1531 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1532 ✗ if (parserListener != nullptr) parserListener->exitDer_class_specifier(this);
1533 ✗ }
1534
1535 ✗ std::any modelicaParser::Der_class_specifierContext::accept(tree::ParseTreeVisitor* visitor) {
1536 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
1537 ✗ return parserVisitor->visitDer_class_specifier(this);
1538 else
1539 ✗ return visitor->visitChildren(this);
1540 }
1541
1542 ✗ modelicaParser::Der_class_specifierContext* modelicaParser::der_class_specifier() {
1543 ✗ Der_class_specifierContext* _localctx = _tracker.createInstance<Der_class_specifierContext>(_ctx, getState());
1544 ✗ enterRule(_localctx, 14, modelicaParser::RuleDer_class_specifier);
1545 ✗ size_t _la = 0;
1546
1547 #if __cplusplus > 201703L
1548 ✗ auto onExit = finally([=, this] {
1549 #else
1550 auto onExit = finally([=] {
1551 #endif
1552 ✗ exitRule();
1553 ✗ });
1554 try {
1555 ✗ enterOuterAlt(_localctx, 1);
1556 ✗ setState(264);
1557 ✗ match(modelicaParser::IDENT);
1558 ✗ setState(265);
1559 ✗ match(modelicaParser::T__19);
1560 ✗ setState(266);
1561 ✗ match(modelicaParser::T__24);
1562 ✗ setState(267);
1563 ✗ match(modelicaParser::T__21);
1564 ✗ setState(268);
1565 ✗ name();
1566 ✗ setState(269);
1567 ✗ match(modelicaParser::T__25);
1568 ✗ setState(270);
1569 ✗ match(modelicaParser::IDENT);
1570 ✗ setState(275);
1571 ✗ _errHandler->sync(this);
1572 ✗ _la = _input->LA(1);
1573 ✗ while (_la == modelicaParser::T__25) {
1574 ✗ setState(271);
1575 ✗ match(modelicaParser::T__25);
1576 ✗ setState(272);
1577 ✗ match(modelicaParser::IDENT);
1578 ✗ setState(277);
1579 ✗ _errHandler->sync(this);
1580 ✗ _la = _input->LA(1);
1581 }
1582 ✗ setState(278);
1583 ✗ match(modelicaParser::T__23);
1584 ✗ setState(279);
1585 ✗ comment();
1586
1587 ✗ } catch (RecognitionException& e) {
1588 ✗ _errHandler->reportError(this, e);
1589 ✗ _localctx->exception = std::current_exception();
1590 ✗ _errHandler->recover(this, _localctx->exception);
1591 ✗ }
1592
1593 ✗ return _localctx;
1594 ✗ }
1595
1596 //----------------- Base_prefixContext ------------------------------------------------------------------
1597
1598 ✗ modelicaParser::Base_prefixContext::Base_prefixContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
1599
1600 ✗ modelicaParser::Type_prefixContext* modelicaParser::Base_prefixContext::type_prefix() {
1601 ✗ return getRuleContext<modelicaParser::Type_prefixContext>(0);
1602 }
1603
1604 ✗ size_t modelicaParser::Base_prefixContext::getRuleIndex() const {
1605 ✗ return modelicaParser::RuleBase_prefix;
1606 }
1607
1608 ✗ void modelicaParser::Base_prefixContext::enterRule(tree::ParseTreeListener* listener) {
1609 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1610 ✗ if (parserListener != nullptr) parserListener->enterBase_prefix(this);
1611 ✗ }
1612
1613 ✗ void modelicaParser::Base_prefixContext::exitRule(tree::ParseTreeListener* listener) {
1614 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1615 ✗ if (parserListener != nullptr) parserListener->exitBase_prefix(this);
1616 ✗ }
1617
1618 ✗ std::any modelicaParser::Base_prefixContext::accept(tree::ParseTreeVisitor* visitor) {
1619 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
1620 ✗ return parserVisitor->visitBase_prefix(this);
1621 else
1622 ✗ return visitor->visitChildren(this);
1623 }
1624
1625 ✗ modelicaParser::Base_prefixContext* modelicaParser::base_prefix() {
1626 ✗ Base_prefixContext* _localctx = _tracker.createInstance<Base_prefixContext>(_ctx, getState());
1627 ✗ enterRule(_localctx, 16, modelicaParser::RuleBase_prefix);
1628
1629 #if __cplusplus > 201703L
1630 ✗ auto onExit = finally([=, this] {
1631 #else
1632 auto onExit = finally([=] {
1633 #endif
1634 ✗ exitRule();
1635 ✗ });
1636 try {
1637 ✗ enterOuterAlt(_localctx, 1);
1638 ✗ setState(281);
1639 ✗ type_prefix();
1640
1641 ✗ } catch (RecognitionException& e) {
1642 ✗ _errHandler->reportError(this, e);
1643 ✗ _localctx->exception = std::current_exception();
1644 ✗ _errHandler->recover(this, _localctx->exception);
1645 ✗ }
1646
1647 ✗ return _localctx;
1648 ✗ }
1649
1650 //----------------- Enum_listContext ------------------------------------------------------------------
1651
1652 ✗ modelicaParser::Enum_listContext::Enum_listContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
1653
1654 ✗ std::vector<modelicaParser::Enumeration_literalContext*> modelicaParser::Enum_listContext::enumeration_literal() {
1655 ✗ return getRuleContexts<modelicaParser::Enumeration_literalContext>();
1656 }
1657
1658 ✗ modelicaParser::Enumeration_literalContext* modelicaParser::Enum_listContext::enumeration_literal(size_t i) {
1659 ✗ return getRuleContext<modelicaParser::Enumeration_literalContext>(i);
1660 }
1661
1662 ✗ size_t modelicaParser::Enum_listContext::getRuleIndex() const {
1663 ✗ return modelicaParser::RuleEnum_list;
1664 }
1665
1666 ✗ void modelicaParser::Enum_listContext::enterRule(tree::ParseTreeListener* listener) {
1667 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1668 ✗ if (parserListener != nullptr) parserListener->enterEnum_list(this);
1669 ✗ }
1670
1671 ✗ void modelicaParser::Enum_listContext::exitRule(tree::ParseTreeListener* listener) {
1672 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1673 ✗ if (parserListener != nullptr) parserListener->exitEnum_list(this);
1674 ✗ }
1675
1676 ✗ std::any modelicaParser::Enum_listContext::accept(tree::ParseTreeVisitor* visitor) {
1677 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
1678 ✗ return parserVisitor->visitEnum_list(this);
1679 else
1680 ✗ return visitor->visitChildren(this);
1681 }
1682
1683 ✗ modelicaParser::Enum_listContext* modelicaParser::enum_list() {
1684 ✗ Enum_listContext* _localctx = _tracker.createInstance<Enum_listContext>(_ctx, getState());
1685 ✗ enterRule(_localctx, 18, modelicaParser::RuleEnum_list);
1686 ✗ size_t _la = 0;
1687
1688 #if __cplusplus > 201703L
1689 ✗ auto onExit = finally([=, this] {
1690 #else
1691 auto onExit = finally([=] {
1692 #endif
1693 ✗ exitRule();
1694 ✗ });
1695 try {
1696 ✗ enterOuterAlt(_localctx, 1);
1697 ✗ setState(283);
1698 ✗ enumeration_literal();
1699 ✗ setState(288);
1700 ✗ _errHandler->sync(this);
1701 ✗ _la = _input->LA(1);
1702 ✗ while (_la == modelicaParser::T__25) {
1703 ✗ setState(284);
1704 ✗ match(modelicaParser::T__25);
1705 ✗ setState(285);
1706 ✗ enumeration_literal();
1707 ✗ setState(290);
1708 ✗ _errHandler->sync(this);
1709 ✗ _la = _input->LA(1);
1710 }
1711
1712 ✗ } catch (RecognitionException& e) {
1713 ✗ _errHandler->reportError(this, e);
1714 ✗ _localctx->exception = std::current_exception();
1715 ✗ _errHandler->recover(this, _localctx->exception);
1716 ✗ }
1717
1718 ✗ return _localctx;
1719 ✗ }
1720
1721 //----------------- Enumeration_literalContext ------------------------------------------------------------------
1722
1723 ✗ modelicaParser::Enumeration_literalContext::Enumeration_literalContext(ParserRuleContext* parent, size_t invokingState)
1724 ✗ : ParserRuleContext(parent, invokingState) {}
1725
1726 ✗ tree::TerminalNode* modelicaParser::Enumeration_literalContext::IDENT() {
1727 ✗ return getToken(modelicaParser::IDENT, 0);
1728 }
1729
1730 ✗ modelicaParser::CommentContext* modelicaParser::Enumeration_literalContext::comment() {
1731 ✗ return getRuleContext<modelicaParser::CommentContext>(0);
1732 }
1733
1734 ✗ size_t modelicaParser::Enumeration_literalContext::getRuleIndex() const {
1735 ✗ return modelicaParser::RuleEnumeration_literal;
1736 }
1737
1738 ✗ void modelicaParser::Enumeration_literalContext::enterRule(tree::ParseTreeListener* listener) {
1739 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1740 ✗ if (parserListener != nullptr) parserListener->enterEnumeration_literal(this);
1741 ✗ }
1742
1743 ✗ void modelicaParser::Enumeration_literalContext::exitRule(tree::ParseTreeListener* listener) {
1744 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1745 ✗ if (parserListener != nullptr) parserListener->exitEnumeration_literal(this);
1746 ✗ }
1747
1748 ✗ std::any modelicaParser::Enumeration_literalContext::accept(tree::ParseTreeVisitor* visitor) {
1749 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
1750 ✗ return parserVisitor->visitEnumeration_literal(this);
1751 else
1752 ✗ return visitor->visitChildren(this);
1753 }
1754
1755 ✗ modelicaParser::Enumeration_literalContext* modelicaParser::enumeration_literal() {
1756 ✗ Enumeration_literalContext* _localctx = _tracker.createInstance<Enumeration_literalContext>(_ctx, getState());
1757 ✗ enterRule(_localctx, 20, modelicaParser::RuleEnumeration_literal);
1758
1759 #if __cplusplus > 201703L
1760 ✗ auto onExit = finally([=, this] {
1761 #else
1762 auto onExit = finally([=] {
1763 #endif
1764 ✗ exitRule();
1765 ✗ });
1766 try {
1767 ✗ enterOuterAlt(_localctx, 1);
1768 ✗ setState(291);
1769 ✗ match(modelicaParser::IDENT);
1770 ✗ setState(292);
1771 ✗ comment();
1772
1773 ✗ } catch (RecognitionException& e) {
1774 ✗ _errHandler->reportError(this, e);
1775 ✗ _localctx->exception = std::current_exception();
1776 ✗ _errHandler->recover(this, _localctx->exception);
1777 ✗ }
1778
1779 ✗ return _localctx;
1780 ✗ }
1781
1782 //----------------- CompositionContext ------------------------------------------------------------------
1783
1784 ✗ modelicaParser::CompositionContext::CompositionContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
1785
1786 ✗ std::vector<modelicaParser::Element_listContext*> modelicaParser::CompositionContext::element_list() {
1787 ✗ return getRuleContexts<modelicaParser::Element_listContext>();
1788 }
1789
1790 ✗ modelicaParser::Element_listContext* modelicaParser::CompositionContext::element_list(size_t i) {
1791 ✗ return getRuleContext<modelicaParser::Element_listContext>(i);
1792 }
1793
1794 ✗ std::vector<modelicaParser::Equation_sectionContext*> modelicaParser::CompositionContext::equation_section() {
1795 ✗ return getRuleContexts<modelicaParser::Equation_sectionContext>();
1796 }
1797
1798 ✗ modelicaParser::Equation_sectionContext* modelicaParser::CompositionContext::equation_section(size_t i) {
1799 ✗ return getRuleContext<modelicaParser::Equation_sectionContext>(i);
1800 }
1801
1802 ✗ std::vector<modelicaParser::Algorithm_sectionContext*> modelicaParser::CompositionContext::algorithm_section() {
1803 ✗ return getRuleContexts<modelicaParser::Algorithm_sectionContext>();
1804 }
1805
1806 ✗ modelicaParser::Algorithm_sectionContext* modelicaParser::CompositionContext::algorithm_section(size_t i) {
1807 ✗ return getRuleContext<modelicaParser::Algorithm_sectionContext>(i);
1808 }
1809
1810 ✗ modelicaParser::Model_annotationContext* modelicaParser::CompositionContext::model_annotation() {
1811 ✗ return getRuleContext<modelicaParser::Model_annotationContext>(0);
1812 }
1813
1814 ✗ modelicaParser::Language_specificationContext* modelicaParser::CompositionContext::language_specification() {
1815 ✗ return getRuleContext<modelicaParser::Language_specificationContext>(0);
1816 }
1817
1818 ✗ modelicaParser::External_function_callContext* modelicaParser::CompositionContext::external_function_call() {
1819 ✗ return getRuleContext<modelicaParser::External_function_callContext>(0);
1820 }
1821
1822 ✗ modelicaParser::AnnotationContext* modelicaParser::CompositionContext::annotation() {
1823 ✗ return getRuleContext<modelicaParser::AnnotationContext>(0);
1824 }
1825
1826 ✗ size_t modelicaParser::CompositionContext::getRuleIndex() const {
1827 ✗ return modelicaParser::RuleComposition;
1828 }
1829
1830 ✗ void modelicaParser::CompositionContext::enterRule(tree::ParseTreeListener* listener) {
1831 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1832 ✗ if (parserListener != nullptr) parserListener->enterComposition(this);
1833 ✗ }
1834
1835 ✗ void modelicaParser::CompositionContext::exitRule(tree::ParseTreeListener* listener) {
1836 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1837 ✗ if (parserListener != nullptr) parserListener->exitComposition(this);
1838 ✗ }
1839
1840 ✗ std::any modelicaParser::CompositionContext::accept(tree::ParseTreeVisitor* visitor) {
1841 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
1842 ✗ return parserVisitor->visitComposition(this);
1843 else
1844 ✗ return visitor->visitChildren(this);
1845 }
1846
1847 ✗ modelicaParser::CompositionContext* modelicaParser::composition() {
1848 ✗ CompositionContext* _localctx = _tracker.createInstance<CompositionContext>(_ctx, getState());
1849 ✗ enterRule(_localctx, 22, modelicaParser::RuleComposition);
1850 ✗ size_t _la = 0;
1851
1852 #if __cplusplus > 201703L
1853 ✗ auto onExit = finally([=, this] {
1854 #else
1855 auto onExit = finally([=] {
1856 #endif
1857 ✗ exitRule();
1858 ✗ });
1859 try {
1860 ✗ enterOuterAlt(_localctx, 1);
1861 ✗ setState(294);
1862 ✗ element_list();
1863 ✗ setState(303);
1864 ✗ _errHandler->sync(this);
1865 ✗ _la = _input->LA(1);
1866 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 3940650076602368) != 0)) {
1867 ✗ setState(301);
1868 ✗ _errHandler->sync(this);
1869 ✗ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx)) {
1870 ✗ case 1: {
1871 ✗ setState(295);
1872 ✗ match(modelicaParser::T__26);
1873 ✗ setState(296);
1874 ✗ element_list();
1875 ✗ break;
1876 }
1877
1878 ✗ case 2: {
1879 ✗ setState(297);
1880 ✗ match(modelicaParser::T__27);
1881 ✗ setState(298);
1882 ✗ element_list();
1883 ✗ break;
1884 }
1885
1886 ✗ case 3: {
1887 ✗ setState(299);
1888 ✗ equation_section();
1889 ✗ break;
1890 }
1891
1892 ✗ case 4: {
1893 ✗ setState(300);
1894 ✗ algorithm_section();
1895 ✗ break;
1896 }
1897
1898 ✗ default:
1899 ✗ break;
1900 }
1901 ✗ setState(305);
1902 ✗ _errHandler->sync(this);
1903 ✗ _la = _input->LA(1);
1904 }
1905 ✗ setState(317);
1906 ✗ _errHandler->sync(this);
1907
1908 ✗ _la = _input->LA(1);
1909 ✗ if (_la == modelicaParser::T__28) {
1910 ✗ setState(306);
1911 ✗ match(modelicaParser::T__28);
1912 ✗ setState(308);
1913 ✗ _errHandler->sync(this);
1914
1915 ✗ _la = _input->LA(1);
1916 ✗ if (_la == modelicaParser::STRING) {
1917 ✗ setState(307);
1918 ✗ language_specification();
1919 }
1920 ✗ setState(311);
1921 ✗ _errHandler->sync(this);
1922
1923 ✗ _la = _input->LA(1);
1924 ✗ if (_la == modelicaParser::T__86
1925
1926 ✗ || _la == modelicaParser::IDENT) {
1927 ✗ setState(310);
1928 ✗ external_function_call();
1929 }
1930 ✗ setState(314);
1931 ✗ _errHandler->sync(this);
1932
1933 ✗ _la = _input->LA(1);
1934 ✗ if (_la == modelicaParser::T__87) {
1935 ✗ setState(313);
1936 ✗ annotation();
1937 }
1938 ✗ setState(316);
1939 ✗ match(modelicaParser::T__1);
1940 }
1941 ✗ setState(322);
1942 ✗ _errHandler->sync(this);
1943
1944 ✗ _la = _input->LA(1);
1945 ✗ if (_la == modelicaParser::T__87) {
1946 ✗ setState(319);
1947 ✗ model_annotation();
1948 ✗ setState(320);
1949 ✗ match(modelicaParser::T__1);
1950 }
1951
1952 ✗ } catch (RecognitionException& e) {
1953 ✗ _errHandler->reportError(this, e);
1954 ✗ _localctx->exception = std::current_exception();
1955 ✗ _errHandler->recover(this, _localctx->exception);
1956 ✗ }
1957
1958 ✗ return _localctx;
1959 ✗ }
1960
1961 //----------------- Language_specificationContext ------------------------------------------------------------------
1962
1963 ✗ modelicaParser::Language_specificationContext::Language_specificationContext(ParserRuleContext* parent, size_t invokingState)
1964 ✗ : ParserRuleContext(parent, invokingState) {}
1965
1966 ✗ tree::TerminalNode* modelicaParser::Language_specificationContext::STRING() {
1967 ✗ return getToken(modelicaParser::STRING, 0);
1968 }
1969
1970 ✗ size_t modelicaParser::Language_specificationContext::getRuleIndex() const {
1971 ✗ return modelicaParser::RuleLanguage_specification;
1972 }
1973
1974 ✗ void modelicaParser::Language_specificationContext::enterRule(tree::ParseTreeListener* listener) {
1975 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1976 ✗ if (parserListener != nullptr) parserListener->enterLanguage_specification(this);
1977 ✗ }
1978
1979 ✗ void modelicaParser::Language_specificationContext::exitRule(tree::ParseTreeListener* listener) {
1980 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
1981 ✗ if (parserListener != nullptr) parserListener->exitLanguage_specification(this);
1982 ✗ }
1983
1984 ✗ std::any modelicaParser::Language_specificationContext::accept(tree::ParseTreeVisitor* visitor) {
1985 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
1986 ✗ return parserVisitor->visitLanguage_specification(this);
1987 else
1988 ✗ return visitor->visitChildren(this);
1989 }
1990
1991 ✗ modelicaParser::Language_specificationContext* modelicaParser::language_specification() {
1992 ✗ Language_specificationContext* _localctx = _tracker.createInstance<Language_specificationContext>(_ctx, getState());
1993 ✗ enterRule(_localctx, 24, modelicaParser::RuleLanguage_specification);
1994
1995 #if __cplusplus > 201703L
1996 ✗ auto onExit = finally([=, this] {
1997 #else
1998 auto onExit = finally([=] {
1999 #endif
2000 ✗ exitRule();
2001 ✗ });
2002 try {
2003 ✗ enterOuterAlt(_localctx, 1);
2004 ✗ setState(324);
2005 ✗ match(modelicaParser::STRING);
2006
2007 ✗ } catch (RecognitionException& e) {
2008 ✗ _errHandler->reportError(this, e);
2009 ✗ _localctx->exception = std::current_exception();
2010 ✗ _errHandler->recover(this, _localctx->exception);
2011 ✗ }
2012
2013 ✗ return _localctx;
2014 ✗ }
2015
2016 //----------------- External_function_callContext ------------------------------------------------------------------
2017
2018 ✗ modelicaParser::External_function_callContext::External_function_callContext(ParserRuleContext* parent, size_t invokingState)
2019 ✗ : ParserRuleContext(parent, invokingState) {}
2020
2021 ✗ tree::TerminalNode* modelicaParser::External_function_callContext::IDENT() {
2022 ✗ return getToken(modelicaParser::IDENT, 0);
2023 }
2024
2025 ✗ modelicaParser::Component_referenceContext* modelicaParser::External_function_callContext::component_reference() {
2026 ✗ return getRuleContext<modelicaParser::Component_referenceContext>(0);
2027 }
2028
2029 ✗ modelicaParser::Expression_listContext* modelicaParser::External_function_callContext::expression_list() {
2030 ✗ return getRuleContext<modelicaParser::Expression_listContext>(0);
2031 }
2032
2033 ✗ size_t modelicaParser::External_function_callContext::getRuleIndex() const {
2034 ✗ return modelicaParser::RuleExternal_function_call;
2035 }
2036
2037 ✗ void modelicaParser::External_function_callContext::enterRule(tree::ParseTreeListener* listener) {
2038 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2039 ✗ if (parserListener != nullptr) parserListener->enterExternal_function_call(this);
2040 ✗ }
2041
2042 ✗ void modelicaParser::External_function_callContext::exitRule(tree::ParseTreeListener* listener) {
2043 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2044 ✗ if (parserListener != nullptr) parserListener->exitExternal_function_call(this);
2045 ✗ }
2046
2047 ✗ std::any modelicaParser::External_function_callContext::accept(tree::ParseTreeVisitor* visitor) {
2048 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
2049 ✗ return parserVisitor->visitExternal_function_call(this);
2050 else
2051 ✗ return visitor->visitChildren(this);
2052 }
2053
2054 ✗ modelicaParser::External_function_callContext* modelicaParser::external_function_call() {
2055 ✗ External_function_callContext* _localctx = _tracker.createInstance<External_function_callContext>(_ctx, getState());
2056 ✗ enterRule(_localctx, 26, modelicaParser::RuleExternal_function_call);
2057 ✗ size_t _la = 0;
2058
2059 #if __cplusplus > 201703L
2060 ✗ auto onExit = finally([=, this] {
2061 #else
2062 auto onExit = finally([=] {
2063 #endif
2064 ✗ exitRule();
2065 ✗ });
2066 try {
2067 ✗ enterOuterAlt(_localctx, 1);
2068 ✗ setState(329);
2069 ✗ _errHandler->sync(this);
2070
2071 ✗ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx)) {
2072 ✗ case 1: {
2073 ✗ setState(326);
2074 ✗ component_reference();
2075 ✗ setState(327);
2076 ✗ match(modelicaParser::T__19);
2077 ✗ break;
2078 }
2079
2080 ✗ default:
2081 ✗ break;
2082 }
2083 ✗ setState(331);
2084 ✗ match(modelicaParser::IDENT);
2085 ✗ setState(332);
2086 ✗ match(modelicaParser::T__21);
2087 ✗ setState(334);
2088 ✗ _errHandler->sync(this);
2089
2090 ✗ _la = _input->LA(1);
2091 ✗ if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 633318735609856) != 0)
2092 ✗ || ((((_la - 66) & ~0x3fULL) == 0) && ((1ULL << (_la - 66)) & 62326657) != 0)) {
2093 ✗ setState(333);
2094 ✗ expression_list();
2095 }
2096 ✗ setState(336);
2097 ✗ match(modelicaParser::T__23);
2098
2099 ✗ } catch (RecognitionException& e) {
2100 ✗ _errHandler->reportError(this, e);
2101 ✗ _localctx->exception = std::current_exception();
2102 ✗ _errHandler->recover(this, _localctx->exception);
2103 ✗ }
2104
2105 ✗ return _localctx;
2106 ✗ }
2107
2108 //----------------- Element_listContext ------------------------------------------------------------------
2109
2110 ✗ modelicaParser::Element_listContext::Element_listContext(ParserRuleContext* parent, size_t invokingState)
2111 ✗ : ParserRuleContext(parent, invokingState) {}
2112
2113 ✗ std::vector<modelicaParser::ElementContext*> modelicaParser::Element_listContext::element() {
2114 ✗ return getRuleContexts<modelicaParser::ElementContext>();
2115 }
2116
2117 ✗ modelicaParser::ElementContext* modelicaParser::Element_listContext::element(size_t i) {
2118 ✗ return getRuleContext<modelicaParser::ElementContext>(i);
2119 }
2120
2121 ✗ size_t modelicaParser::Element_listContext::getRuleIndex() const {
2122 ✗ return modelicaParser::RuleElement_list;
2123 }
2124
2125 ✗ void modelicaParser::Element_listContext::enterRule(tree::ParseTreeListener* listener) {
2126 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2127 ✗ if (parserListener != nullptr) parserListener->enterElement_list(this);
2128 ✗ }
2129
2130 ✗ void modelicaParser::Element_listContext::exitRule(tree::ParseTreeListener* listener) {
2131 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2132 ✗ if (parserListener != nullptr) parserListener->exitElement_list(this);
2133 ✗ }
2134
2135 ✗ std::any modelicaParser::Element_listContext::accept(tree::ParseTreeVisitor* visitor) {
2136 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
2137 ✗ return parserVisitor->visitElement_list(this);
2138 else
2139 ✗ return visitor->visitChildren(this);
2140 }
2141
2142 ✗ modelicaParser::Element_listContext* modelicaParser::element_list() {
2143 ✗ Element_listContext* _localctx = _tracker.createInstance<Element_listContext>(_ctx, getState());
2144 ✗ enterRule(_localctx, 28, modelicaParser::RuleElement_list);
2145 ✗ size_t _la = 0;
2146
2147 #if __cplusplus > 201703L
2148 ✗ auto onExit = finally([=, this] {
2149 #else
2150 auto onExit = finally([=] {
2151 #endif
2152 ✗ exitRule();
2153 ✗ });
2154 try {
2155 ✗ enterOuterAlt(_localctx, 1);
2156 ✗ setState(341);
2157 ✗ _errHandler->sync(this);
2158 ✗ _la = _input->LA(1);
2159 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 69852275146738) != 0) || _la == modelicaParser::T__86
2160
2161 ✗ || _la == modelicaParser::IDENT) {
2162 ✗ setState(338);
2163 ✗ element();
2164 ✗ setState(343);
2165 ✗ _errHandler->sync(this);
2166 ✗ _la = _input->LA(1);
2167 }
2168
2169 ✗ } catch (RecognitionException& e) {
2170 ✗ _errHandler->reportError(this, e);
2171 ✗ _localctx->exception = std::current_exception();
2172 ✗ _errHandler->recover(this, _localctx->exception);
2173 ✗ }
2174
2175 ✗ return _localctx;
2176 ✗ }
2177
2178 //----------------- ElementContext ------------------------------------------------------------------
2179
2180 ✗ modelicaParser::ElementContext::ElementContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
2181
2182 ✗ modelicaParser::Import_clauseContext* modelicaParser::ElementContext::import_clause() {
2183 ✗ return getRuleContext<modelicaParser::Import_clauseContext>(0);
2184 }
2185
2186 ✗ modelicaParser::Extends_clauseContext* modelicaParser::ElementContext::extends_clause() {
2187 ✗ return getRuleContext<modelicaParser::Extends_clauseContext>(0);
2188 }
2189
2190 ✗ modelicaParser::Class_definitionContext* modelicaParser::ElementContext::class_definition() {
2191 ✗ return getRuleContext<modelicaParser::Class_definitionContext>(0);
2192 }
2193
2194 ✗ modelicaParser::Component_clauseContext* modelicaParser::ElementContext::component_clause() {
2195 ✗ return getRuleContext<modelicaParser::Component_clauseContext>(0);
2196 }
2197
2198 ✗ modelicaParser::Constraining_clauseContext* modelicaParser::ElementContext::constraining_clause() {
2199 ✗ return getRuleContext<modelicaParser::Constraining_clauseContext>(0);
2200 }
2201
2202 ✗ modelicaParser::CommentContext* modelicaParser::ElementContext::comment() {
2203 ✗ return getRuleContext<modelicaParser::CommentContext>(0);
2204 }
2205
2206 ✗ size_t modelicaParser::ElementContext::getRuleIndex() const {
2207 ✗ return modelicaParser::RuleElement;
2208 }
2209
2210 ✗ void modelicaParser::ElementContext::enterRule(tree::ParseTreeListener* listener) {
2211 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2212 ✗ if (parserListener != nullptr) parserListener->enterElement(this);
2213 ✗ }
2214
2215 ✗ void modelicaParser::ElementContext::exitRule(tree::ParseTreeListener* listener) {
2216 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2217 ✗ if (parserListener != nullptr) parserListener->exitElement(this);
2218 ✗ }
2219
2220 ✗ std::any modelicaParser::ElementContext::accept(tree::ParseTreeVisitor* visitor) {
2221 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
2222 ✗ return parserVisitor->visitElement(this);
2223 else
2224 ✗ return visitor->visitChildren(this);
2225 }
2226
2227 ✗ modelicaParser::ElementContext* modelicaParser::element() {
2228 ✗ ElementContext* _localctx = _tracker.createInstance<ElementContext>(_ctx, getState());
2229 ✗ enterRule(_localctx, 30, modelicaParser::RuleElement);
2230 ✗ size_t _la = 0;
2231
2232 #if __cplusplus > 201703L
2233 ✗ auto onExit = finally([=, this] {
2234 #else
2235 auto onExit = finally([=] {
2236 #endif
2237 ✗ exitRule();
2238 ✗ });
2239 try {
2240 ✗ enterOuterAlt(_localctx, 1);
2241 ✗ setState(374);
2242 ✗ _errHandler->sync(this);
2243 ✗ switch (_input->LA(1)) {
2244 ✗ case modelicaParser::T__33: {
2245 ✗ setState(344);
2246 ✗ import_clause();
2247 ✗ break;
2248 }
2249
2250 ✗ case modelicaParser::T__18: {
2251 ✗ setState(345);
2252 ✗ extends_clause();
2253 ✗ break;
2254 }
2255
2256 ✗ case modelicaParser::T__0:
2257 case modelicaParser::T__3:
2258 case modelicaParser::T__4:
2259 case modelicaParser::T__5:
2260 case modelicaParser::T__6:
2261 case modelicaParser::T__7:
2262 case modelicaParser::T__8:
2263 case modelicaParser::T__9:
2264 case modelicaParser::T__10:
2265 case modelicaParser::T__11:
2266 case modelicaParser::T__12:
2267 case modelicaParser::T__13:
2268 case modelicaParser::T__14:
2269 case modelicaParser::T__15:
2270 case modelicaParser::T__16:
2271 case modelicaParser::T__29:
2272 case modelicaParser::T__30:
2273 case modelicaParser::T__31:
2274 case modelicaParser::T__32:
2275 case modelicaParser::T__38:
2276 case modelicaParser::T__39:
2277 case modelicaParser::T__40:
2278 case modelicaParser::T__41:
2279 case modelicaParser::T__42:
2280 case modelicaParser::T__43:
2281 case modelicaParser::T__44:
2282 case modelicaParser::T__86:
2283 case modelicaParser::IDENT: {
2284 ✗ setState(347);
2285 ✗ _errHandler->sync(this);
2286
2287 ✗ _la = _input->LA(1);
2288 ✗ if (_la == modelicaParser::T__29) {
2289 ✗ setState(346);
2290 ✗ match(modelicaParser::T__29);
2291 }
2292 ✗ setState(350);
2293 ✗ _errHandler->sync(this);
2294
2295 ✗ _la = _input->LA(1);
2296 ✗ if (_la == modelicaParser::T__0) {
2297 ✗ setState(349);
2298 ✗ match(modelicaParser::T__0);
2299 }
2300 ✗ setState(353);
2301 ✗ _errHandler->sync(this);
2302
2303 ✗ _la = _input->LA(1);
2304 ✗ if (_la == modelicaParser::T__30) {
2305 ✗ setState(352);
2306 ✗ match(modelicaParser::T__30);
2307 }
2308 ✗ setState(356);
2309 ✗ _errHandler->sync(this);
2310
2311 ✗ _la = _input->LA(1);
2312 ✗ if (_la == modelicaParser::T__31) {
2313 ✗ setState(355);
2314 ✗ match(modelicaParser::T__31);
2315 }
2316 ✗ setState(372);
2317 ✗ _errHandler->sync(this);
2318 ✗ switch (_input->LA(1)) {
2319 ✗ case modelicaParser::T__3:
2320 case modelicaParser::T__4:
2321 case modelicaParser::T__5:
2322 case modelicaParser::T__6:
2323 case modelicaParser::T__7:
2324 case modelicaParser::T__8:
2325 case modelicaParser::T__9:
2326 case modelicaParser::T__10:
2327 case modelicaParser::T__11:
2328 case modelicaParser::T__12:
2329 case modelicaParser::T__13:
2330 case modelicaParser::T__14:
2331 case modelicaParser::T__15:
2332 case modelicaParser::T__16:
2333 case modelicaParser::T__38:
2334 case modelicaParser::T__39:
2335 case modelicaParser::T__40:
2336 case modelicaParser::T__41:
2337 case modelicaParser::T__42:
2338 case modelicaParser::T__43:
2339 case modelicaParser::T__44:
2340 case modelicaParser::T__86:
2341 case modelicaParser::IDENT: {
2342 ✗ setState(360);
2343 ✗ _errHandler->sync(this);
2344 ✗ switch (_input->LA(1)) {
2345 ✗ case modelicaParser::T__3:
2346 case modelicaParser::T__4:
2347 case modelicaParser::T__5:
2348 case modelicaParser::T__6:
2349 case modelicaParser::T__7:
2350 case modelicaParser::T__8:
2351 case modelicaParser::T__9:
2352 case modelicaParser::T__10:
2353 case modelicaParser::T__11:
2354 case modelicaParser::T__12:
2355 case modelicaParser::T__13:
2356 case modelicaParser::T__14:
2357 case modelicaParser::T__15:
2358 case modelicaParser::T__16: {
2359 ✗ setState(358);
2360 ✗ class_definition();
2361 ✗ break;
2362 }
2363
2364 ✗ case modelicaParser::T__38:
2365 case modelicaParser::T__39:
2366 case modelicaParser::T__40:
2367 case modelicaParser::T__41:
2368 case modelicaParser::T__42:
2369 case modelicaParser::T__43:
2370 case modelicaParser::T__44:
2371 case modelicaParser::T__86:
2372 case modelicaParser::IDENT: {
2373 ✗ setState(359);
2374 ✗ component_clause();
2375 ✗ break;
2376 }
2377
2378 ✗ default:
2379 ✗ throw NoViableAltException(this);
2380 }
2381 ✗ break;
2382 }
2383
2384 ✗ case modelicaParser::T__32: {
2385 ✗ setState(362);
2386 ✗ match(modelicaParser::T__32);
2387 ✗ setState(365);
2388 ✗ _errHandler->sync(this);
2389 ✗ switch (_input->LA(1)) {
2390 ✗ case modelicaParser::T__3:
2391 case modelicaParser::T__4:
2392 case modelicaParser::T__5:
2393 case modelicaParser::T__6:
2394 case modelicaParser::T__7:
2395 case modelicaParser::T__8:
2396 case modelicaParser::T__9:
2397 case modelicaParser::T__10:
2398 case modelicaParser::T__11:
2399 case modelicaParser::T__12:
2400 case modelicaParser::T__13:
2401 case modelicaParser::T__14:
2402 case modelicaParser::T__15:
2403 case modelicaParser::T__16: {
2404 ✗ setState(363);
2405 ✗ class_definition();
2406 ✗ break;
2407 }
2408
2409 ✗ case modelicaParser::T__38:
2410 case modelicaParser::T__39:
2411 case modelicaParser::T__40:
2412 case modelicaParser::T__41:
2413 case modelicaParser::T__42:
2414 case modelicaParser::T__43:
2415 case modelicaParser::T__44:
2416 case modelicaParser::T__86:
2417 case modelicaParser::IDENT: {
2418 ✗ setState(364);
2419 ✗ component_clause();
2420 ✗ break;
2421 }
2422
2423 ✗ default:
2424 ✗ throw NoViableAltException(this);
2425 }
2426 ✗ setState(370);
2427 ✗ _errHandler->sync(this);
2428
2429 ✗ _la = _input->LA(1);
2430 ✗ if (_la == modelicaParser::T__37) {
2431 ✗ setState(367);
2432 ✗ constraining_clause();
2433 ✗ setState(368);
2434 ✗ comment();
2435 }
2436 ✗ break;
2437 }
2438
2439 ✗ default:
2440 ✗ throw NoViableAltException(this);
2441 }
2442 ✗ break;
2443 }
2444
2445 ✗ default:
2446 ✗ throw NoViableAltException(this);
2447 }
2448 ✗ setState(376);
2449 ✗ match(modelicaParser::T__1);
2450
2451 ✗ } catch (RecognitionException& e) {
2452 ✗ _errHandler->reportError(this, e);
2453 ✗ _localctx->exception = std::current_exception();
2454 ✗ _errHandler->recover(this, _localctx->exception);
2455 ✗ }
2456
2457 ✗ return _localctx;
2458 ✗ }
2459
2460 //----------------- Import_clauseContext ------------------------------------------------------------------
2461
2462 ✗ modelicaParser::Import_clauseContext::Import_clauseContext(ParserRuleContext* parent, size_t invokingState)
2463 ✗ : ParserRuleContext(parent, invokingState) {}
2464
2465 ✗ modelicaParser::CommentContext* modelicaParser::Import_clauseContext::comment() {
2466 ✗ return getRuleContext<modelicaParser::CommentContext>(0);
2467 }
2468
2469 ✗ tree::TerminalNode* modelicaParser::Import_clauseContext::IDENT() {
2470 ✗ return getToken(modelicaParser::IDENT, 0);
2471 }
2472
2473 ✗ modelicaParser::NameContext* modelicaParser::Import_clauseContext::name() {
2474 ✗ return getRuleContext<modelicaParser::NameContext>(0);
2475 }
2476
2477 ✗ modelicaParser::Import_listContext* modelicaParser::Import_clauseContext::import_list() {
2478 ✗ return getRuleContext<modelicaParser::Import_listContext>(0);
2479 }
2480
2481 ✗ size_t modelicaParser::Import_clauseContext::getRuleIndex() const {
2482 ✗ return modelicaParser::RuleImport_clause;
2483 }
2484
2485 ✗ void modelicaParser::Import_clauseContext::enterRule(tree::ParseTreeListener* listener) {
2486 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2487 ✗ if (parserListener != nullptr) parserListener->enterImport_clause(this);
2488 ✗ }
2489
2490 ✗ void modelicaParser::Import_clauseContext::exitRule(tree::ParseTreeListener* listener) {
2491 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2492 ✗ if (parserListener != nullptr) parserListener->exitImport_clause(this);
2493 ✗ }
2494
2495 ✗ std::any modelicaParser::Import_clauseContext::accept(tree::ParseTreeVisitor* visitor) {
2496 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
2497 ✗ return parserVisitor->visitImport_clause(this);
2498 else
2499 ✗ return visitor->visitChildren(this);
2500 }
2501
2502 ✗ modelicaParser::Import_clauseContext* modelicaParser::import_clause() {
2503 ✗ Import_clauseContext* _localctx = _tracker.createInstance<Import_clauseContext>(_ctx, getState());
2504 ✗ enterRule(_localctx, 32, modelicaParser::RuleImport_clause);
2505
2506 #if __cplusplus > 201703L
2507 ✗ auto onExit = finally([=, this] {
2508 #else
2509 auto onExit = finally([=] {
2510 #endif
2511 ✗ exitRule();
2512 ✗ });
2513 try {
2514 ✗ enterOuterAlt(_localctx, 1);
2515 ✗ setState(378);
2516 ✗ match(modelicaParser::T__33);
2517 ✗ setState(391);
2518 ✗ _errHandler->sync(this);
2519 ✗ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 40, _ctx)) {
2520 ✗ case 1: {
2521 ✗ setState(379);
2522 ✗ match(modelicaParser::IDENT);
2523 ✗ setState(380);
2524 ✗ match(modelicaParser::T__19);
2525 ✗ setState(381);
2526 ✗ name();
2527 ✗ break;
2528 }
2529
2530 ✗ case 2: {
2531 ✗ setState(382);
2532 ✗ name();
2533 ✗ setState(383);
2534 ✗ match(modelicaParser::T__34);
2535 ✗ break;
2536 }
2537
2538 ✗ case 3: {
2539 ✗ setState(385);
2540 ✗ name();
2541 ✗ setState(386);
2542 ✗ match(modelicaParser::T__35);
2543 ✗ setState(387);
2544 ✗ import_list();
2545 ✗ setState(388);
2546 ✗ match(modelicaParser::T__36);
2547 ✗ break;
2548 }
2549
2550 ✗ case 4: {
2551 ✗ setState(390);
2552 ✗ name();
2553 ✗ break;
2554 }
2555
2556 ✗ default:
2557 ✗ break;
2558 }
2559 ✗ setState(393);
2560 ✗ comment();
2561
2562 ✗ } catch (RecognitionException& e) {
2563 ✗ _errHandler->reportError(this, e);
2564 ✗ _localctx->exception = std::current_exception();
2565 ✗ _errHandler->recover(this, _localctx->exception);
2566 ✗ }
2567
2568 ✗ return _localctx;
2569 ✗ }
2570
2571 //----------------- Import_listContext ------------------------------------------------------------------
2572
2573 ✗ modelicaParser::Import_listContext::Import_listContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
2574
2575 ✗ std::vector<tree::TerminalNode*> modelicaParser::Import_listContext::IDENT() {
2576 ✗ return getTokens(modelicaParser::IDENT);
2577 }
2578
2579 ✗ tree::TerminalNode* modelicaParser::Import_listContext::IDENT(size_t i) {
2580 ✗ return getToken(modelicaParser::IDENT, i);
2581 }
2582
2583 ✗ size_t modelicaParser::Import_listContext::getRuleIndex() const {
2584 ✗ return modelicaParser::RuleImport_list;
2585 }
2586
2587 ✗ void modelicaParser::Import_listContext::enterRule(tree::ParseTreeListener* listener) {
2588 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2589 ✗ if (parserListener != nullptr) parserListener->enterImport_list(this);
2590 ✗ }
2591
2592 ✗ void modelicaParser::Import_listContext::exitRule(tree::ParseTreeListener* listener) {
2593 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2594 ✗ if (parserListener != nullptr) parserListener->exitImport_list(this);
2595 ✗ }
2596
2597 ✗ std::any modelicaParser::Import_listContext::accept(tree::ParseTreeVisitor* visitor) {
2598 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
2599 ✗ return parserVisitor->visitImport_list(this);
2600 else
2601 ✗ return visitor->visitChildren(this);
2602 }
2603
2604 ✗ modelicaParser::Import_listContext* modelicaParser::import_list() {
2605 ✗ Import_listContext* _localctx = _tracker.createInstance<Import_listContext>(_ctx, getState());
2606 ✗ enterRule(_localctx, 34, modelicaParser::RuleImport_list);
2607 ✗ size_t _la = 0;
2608
2609 #if __cplusplus > 201703L
2610 ✗ auto onExit = finally([=, this] {
2611 #else
2612 auto onExit = finally([=] {
2613 #endif
2614 ✗ exitRule();
2615 ✗ });
2616 try {
2617 ✗ enterOuterAlt(_localctx, 1);
2618 ✗ setState(395);
2619 ✗ match(modelicaParser::IDENT);
2620 ✗ setState(400);
2621 ✗ _errHandler->sync(this);
2622 ✗ _la = _input->LA(1);
2623 ✗ while (_la == modelicaParser::T__25) {
2624 ✗ setState(396);
2625 ✗ match(modelicaParser::T__25);
2626 ✗ setState(397);
2627 ✗ match(modelicaParser::IDENT);
2628 ✗ setState(402);
2629 ✗ _errHandler->sync(this);
2630 ✗ _la = _input->LA(1);
2631 }
2632
2633 ✗ } catch (RecognitionException& e) {
2634 ✗ _errHandler->reportError(this, e);
2635 ✗ _localctx->exception = std::current_exception();
2636 ✗ _errHandler->recover(this, _localctx->exception);
2637 ✗ }
2638
2639 ✗ return _localctx;
2640 ✗ }
2641
2642 //----------------- Extends_clauseContext ------------------------------------------------------------------
2643
2644 ✗ modelicaParser::Extends_clauseContext::Extends_clauseContext(ParserRuleContext* parent, size_t invokingState)
2645 ✗ : ParserRuleContext(parent, invokingState) {}
2646
2647 ✗ modelicaParser::NameContext* modelicaParser::Extends_clauseContext::name() {
2648 ✗ return getRuleContext<modelicaParser::NameContext>(0);
2649 }
2650
2651 ✗ modelicaParser::Class_modificationContext* modelicaParser::Extends_clauseContext::class_modification() {
2652 ✗ return getRuleContext<modelicaParser::Class_modificationContext>(0);
2653 }
2654
2655 ✗ modelicaParser::AnnotationContext* modelicaParser::Extends_clauseContext::annotation() {
2656 ✗ return getRuleContext<modelicaParser::AnnotationContext>(0);
2657 }
2658
2659 ✗ size_t modelicaParser::Extends_clauseContext::getRuleIndex() const {
2660 ✗ return modelicaParser::RuleExtends_clause;
2661 }
2662
2663 ✗ void modelicaParser::Extends_clauseContext::enterRule(tree::ParseTreeListener* listener) {
2664 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2665 ✗ if (parserListener != nullptr) parserListener->enterExtends_clause(this);
2666 ✗ }
2667
2668 ✗ void modelicaParser::Extends_clauseContext::exitRule(tree::ParseTreeListener* listener) {
2669 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2670 ✗ if (parserListener != nullptr) parserListener->exitExtends_clause(this);
2671 ✗ }
2672
2673 ✗ std::any modelicaParser::Extends_clauseContext::accept(tree::ParseTreeVisitor* visitor) {
2674 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
2675 ✗ return parserVisitor->visitExtends_clause(this);
2676 else
2677 ✗ return visitor->visitChildren(this);
2678 }
2679
2680 ✗ modelicaParser::Extends_clauseContext* modelicaParser::extends_clause() {
2681 ✗ Extends_clauseContext* _localctx = _tracker.createInstance<Extends_clauseContext>(_ctx, getState());
2682 ✗ enterRule(_localctx, 36, modelicaParser::RuleExtends_clause);
2683 ✗ size_t _la = 0;
2684
2685 #if __cplusplus > 201703L
2686 ✗ auto onExit = finally([=, this] {
2687 #else
2688 auto onExit = finally([=] {
2689 #endif
2690 ✗ exitRule();
2691 ✗ });
2692 try {
2693 ✗ enterOuterAlt(_localctx, 1);
2694 ✗ setState(403);
2695 ✗ match(modelicaParser::T__18);
2696 ✗ setState(404);
2697 ✗ name();
2698 ✗ setState(406);
2699 ✗ _errHandler->sync(this);
2700
2701 ✗ _la = _input->LA(1);
2702 ✗ if (_la == modelicaParser::T__21) {
2703 ✗ setState(405);
2704 ✗ class_modification();
2705 }
2706 ✗ setState(409);
2707 ✗ _errHandler->sync(this);
2708
2709 ✗ _la = _input->LA(1);
2710 ✗ if (_la == modelicaParser::T__87) {
2711 ✗ setState(408);
2712 ✗ annotation();
2713 }
2714
2715 ✗ } catch (RecognitionException& e) {
2716 ✗ _errHandler->reportError(this, e);
2717 ✗ _localctx->exception = std::current_exception();
2718 ✗ _errHandler->recover(this, _localctx->exception);
2719 ✗ }
2720
2721 ✗ return _localctx;
2722 ✗ }
2723
2724 //----------------- Constraining_clauseContext ------------------------------------------------------------------
2725
2726 ✗ modelicaParser::Constraining_clauseContext::Constraining_clauseContext(ParserRuleContext* parent, size_t invokingState)
2727 ✗ : ParserRuleContext(parent, invokingState) {}
2728
2729 ✗ modelicaParser::NameContext* modelicaParser::Constraining_clauseContext::name() {
2730 ✗ return getRuleContext<modelicaParser::NameContext>(0);
2731 }
2732
2733 ✗ modelicaParser::Class_modificationContext* modelicaParser::Constraining_clauseContext::class_modification() {
2734 ✗ return getRuleContext<modelicaParser::Class_modificationContext>(0);
2735 }
2736
2737 ✗ size_t modelicaParser::Constraining_clauseContext::getRuleIndex() const {
2738 ✗ return modelicaParser::RuleConstraining_clause;
2739 }
2740
2741 ✗ void modelicaParser::Constraining_clauseContext::enterRule(tree::ParseTreeListener* listener) {
2742 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2743 ✗ if (parserListener != nullptr) parserListener->enterConstraining_clause(this);
2744 ✗ }
2745
2746 ✗ void modelicaParser::Constraining_clauseContext::exitRule(tree::ParseTreeListener* listener) {
2747 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2748 ✗ if (parserListener != nullptr) parserListener->exitConstraining_clause(this);
2749 ✗ }
2750
2751 ✗ std::any modelicaParser::Constraining_clauseContext::accept(tree::ParseTreeVisitor* visitor) {
2752 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
2753 ✗ return parserVisitor->visitConstraining_clause(this);
2754 else
2755 ✗ return visitor->visitChildren(this);
2756 }
2757
2758 ✗ modelicaParser::Constraining_clauseContext* modelicaParser::constraining_clause() {
2759 ✗ Constraining_clauseContext* _localctx = _tracker.createInstance<Constraining_clauseContext>(_ctx, getState());
2760 ✗ enterRule(_localctx, 38, modelicaParser::RuleConstraining_clause);
2761 ✗ size_t _la = 0;
2762
2763 #if __cplusplus > 201703L
2764 ✗ auto onExit = finally([=, this] {
2765 #else
2766 auto onExit = finally([=] {
2767 #endif
2768 ✗ exitRule();
2769 ✗ });
2770 try {
2771 ✗ enterOuterAlt(_localctx, 1);
2772 ✗ setState(411);
2773 ✗ match(modelicaParser::T__37);
2774 ✗ setState(412);
2775 ✗ name();
2776 ✗ setState(414);
2777 ✗ _errHandler->sync(this);
2778
2779 ✗ _la = _input->LA(1);
2780 ✗ if (_la == modelicaParser::T__21) {
2781 ✗ setState(413);
2782 ✗ class_modification();
2783 }
2784
2785 ✗ } catch (RecognitionException& e) {
2786 ✗ _errHandler->reportError(this, e);
2787 ✗ _localctx->exception = std::current_exception();
2788 ✗ _errHandler->recover(this, _localctx->exception);
2789 ✗ }
2790
2791 ✗ return _localctx;
2792 ✗ }
2793
2794 //----------------- Component_clauseContext ------------------------------------------------------------------
2795
2796 ✗ modelicaParser::Component_clauseContext::Component_clauseContext(ParserRuleContext* parent, size_t invokingState)
2797 ✗ : ParserRuleContext(parent, invokingState) {}
2798
2799 ✗ modelicaParser::Type_prefixContext* modelicaParser::Component_clauseContext::type_prefix() {
2800 ✗ return getRuleContext<modelicaParser::Type_prefixContext>(0);
2801 }
2802
2803 ✗ modelicaParser::Type_specifierContext* modelicaParser::Component_clauseContext::type_specifier() {
2804 ✗ return getRuleContext<modelicaParser::Type_specifierContext>(0);
2805 }
2806
2807 ✗ modelicaParser::Component_listContext* modelicaParser::Component_clauseContext::component_list() {
2808 ✗ return getRuleContext<modelicaParser::Component_listContext>(0);
2809 }
2810
2811 ✗ modelicaParser::Array_subscriptsContext* modelicaParser::Component_clauseContext::array_subscripts() {
2812 ✗ return getRuleContext<modelicaParser::Array_subscriptsContext>(0);
2813 }
2814
2815 ✗ size_t modelicaParser::Component_clauseContext::getRuleIndex() const {
2816 ✗ return modelicaParser::RuleComponent_clause;
2817 }
2818
2819 ✗ void modelicaParser::Component_clauseContext::enterRule(tree::ParseTreeListener* listener) {
2820 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2821 ✗ if (parserListener != nullptr) parserListener->enterComponent_clause(this);
2822 ✗ }
2823
2824 ✗ void modelicaParser::Component_clauseContext::exitRule(tree::ParseTreeListener* listener) {
2825 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2826 ✗ if (parserListener != nullptr) parserListener->exitComponent_clause(this);
2827 ✗ }
2828
2829 ✗ std::any modelicaParser::Component_clauseContext::accept(tree::ParseTreeVisitor* visitor) {
2830 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
2831 ✗ return parserVisitor->visitComponent_clause(this);
2832 else
2833 ✗ return visitor->visitChildren(this);
2834 }
2835
2836 ✗ modelicaParser::Component_clauseContext* modelicaParser::component_clause() {
2837 ✗ Component_clauseContext* _localctx = _tracker.createInstance<Component_clauseContext>(_ctx, getState());
2838 ✗ enterRule(_localctx, 40, modelicaParser::RuleComponent_clause);
2839 ✗ size_t _la = 0;
2840
2841 #if __cplusplus > 201703L
2842 ✗ auto onExit = finally([=, this] {
2843 #else
2844 auto onExit = finally([=] {
2845 #endif
2846 ✗ exitRule();
2847 ✗ });
2848 try {
2849 ✗ enterOuterAlt(_localctx, 1);
2850 ✗ setState(416);
2851 ✗ type_prefix();
2852 ✗ setState(417);
2853 ✗ type_specifier();
2854 ✗ setState(419);
2855 ✗ _errHandler->sync(this);
2856
2857 ✗ _la = _input->LA(1);
2858 ✗ if (_la == modelicaParser::T__83) {
2859 ✗ setState(418);
2860 ✗ array_subscripts();
2861 }
2862 ✗ setState(421);
2863 ✗ component_list();
2864
2865 ✗ } catch (RecognitionException& e) {
2866 ✗ _errHandler->reportError(this, e);
2867 ✗ _localctx->exception = std::current_exception();
2868 ✗ _errHandler->recover(this, _localctx->exception);
2869 ✗ }
2870
2871 ✗ return _localctx;
2872 ✗ }
2873
2874 //----------------- Type_prefixContext ------------------------------------------------------------------
2875
2876 ✗ modelicaParser::Type_prefixContext::Type_prefixContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
2877
2878 ✗ size_t modelicaParser::Type_prefixContext::getRuleIndex() const {
2879 ✗ return modelicaParser::RuleType_prefix;
2880 }
2881
2882 ✗ void modelicaParser::Type_prefixContext::enterRule(tree::ParseTreeListener* listener) {
2883 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2884 ✗ if (parserListener != nullptr) parserListener->enterType_prefix(this);
2885 ✗ }
2886
2887 ✗ void modelicaParser::Type_prefixContext::exitRule(tree::ParseTreeListener* listener) {
2888 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2889 ✗ if (parserListener != nullptr) parserListener->exitType_prefix(this);
2890 ✗ }
2891
2892 ✗ std::any modelicaParser::Type_prefixContext::accept(tree::ParseTreeVisitor* visitor) {
2893 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
2894 ✗ return parserVisitor->visitType_prefix(this);
2895 else
2896 ✗ return visitor->visitChildren(this);
2897 }
2898
2899 ✗ modelicaParser::Type_prefixContext* modelicaParser::type_prefix() {
2900 ✗ Type_prefixContext* _localctx = _tracker.createInstance<Type_prefixContext>(_ctx, getState());
2901 ✗ enterRule(_localctx, 42, modelicaParser::RuleType_prefix);
2902 ✗ size_t _la = 0;
2903
2904 #if __cplusplus > 201703L
2905 ✗ auto onExit = finally([=, this] {
2906 #else
2907 auto onExit = finally([=] {
2908 #endif
2909 ✗ exitRule();
2910 ✗ });
2911 try {
2912 ✗ enterOuterAlt(_localctx, 1);
2913 ✗ setState(424);
2914 ✗ _errHandler->sync(this);
2915
2916 ✗ _la = _input->LA(1);
2917 ✗ if (_la == modelicaParser::T__38
2918
2919 ✗ || _la == modelicaParser::T__39) {
2920 ✗ setState(423);
2921 ✗ _la = _input->LA(1);
2922 ✗ if (!(_la == modelicaParser::T__38
2923
2924 || _la == modelicaParser::T__39)) {
2925 ✗ _errHandler->recoverInline(this);
2926 } else {
2927 ✗ _errHandler->reportMatch(this);
2928 ✗ consume();
2929 }
2930 }
2931 ✗ setState(427);
2932 ✗ _errHandler->sync(this);
2933
2934 ✗ _la = _input->LA(1);
2935 ✗ if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 15393162788864) != 0)) {
2936 ✗ setState(426);
2937 ✗ _la = _input->LA(1);
2938 ✗ if (!((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 15393162788864) != 0))) {
2939 ✗ _errHandler->recoverInline(this);
2940 } else {
2941 ✗ _errHandler->reportMatch(this);
2942 ✗ consume();
2943 }
2944 }
2945 ✗ setState(430);
2946 ✗ _errHandler->sync(this);
2947
2948 ✗ _la = _input->LA(1);
2949 ✗ if (_la == modelicaParser::T__43
2950
2951 ✗ || _la == modelicaParser::T__44) {
2952 ✗ setState(429);
2953 ✗ _la = _input->LA(1);
2954 ✗ if (!(_la == modelicaParser::T__43
2955
2956 || _la == modelicaParser::T__44)) {
2957 ✗ _errHandler->recoverInline(this);
2958 } else {
2959 ✗ _errHandler->reportMatch(this);
2960 ✗ consume();
2961 }
2962 }
2963
2964 ✗ } catch (RecognitionException& e) {
2965 ✗ _errHandler->reportError(this, e);
2966 ✗ _localctx->exception = std::current_exception();
2967 ✗ _errHandler->recover(this, _localctx->exception);
2968 ✗ }
2969
2970 ✗ return _localctx;
2971 ✗ }
2972
2973 //----------------- Type_specifierContext ------------------------------------------------------------------
2974
2975 ✗ modelicaParser::Type_specifierContext::Type_specifierContext(ParserRuleContext* parent, size_t invokingState)
2976 ✗ : ParserRuleContext(parent, invokingState) {}
2977
2978 ✗ modelicaParser::NameContext* modelicaParser::Type_specifierContext::name() {
2979 ✗ return getRuleContext<modelicaParser::NameContext>(0);
2980 }
2981
2982 ✗ size_t modelicaParser::Type_specifierContext::getRuleIndex() const {
2983 ✗ return modelicaParser::RuleType_specifier;
2984 }
2985
2986 ✗ void modelicaParser::Type_specifierContext::enterRule(tree::ParseTreeListener* listener) {
2987 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2988 ✗ if (parserListener != nullptr) parserListener->enterType_specifier(this);
2989 ✗ }
2990
2991 ✗ void modelicaParser::Type_specifierContext::exitRule(tree::ParseTreeListener* listener) {
2992 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
2993 ✗ if (parserListener != nullptr) parserListener->exitType_specifier(this);
2994 ✗ }
2995
2996 ✗ std::any modelicaParser::Type_specifierContext::accept(tree::ParseTreeVisitor* visitor) {
2997 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
2998 ✗ return parserVisitor->visitType_specifier(this);
2999 else
3000 ✗ return visitor->visitChildren(this);
3001 }
3002
3003 ✗ modelicaParser::Type_specifierContext* modelicaParser::type_specifier() {
3004 ✗ Type_specifierContext* _localctx = _tracker.createInstance<Type_specifierContext>(_ctx, getState());
3005 ✗ enterRule(_localctx, 44, modelicaParser::RuleType_specifier);
3006
3007 #if __cplusplus > 201703L
3008 ✗ auto onExit = finally([=, this] {
3009 #else
3010 auto onExit = finally([=] {
3011 #endif
3012 ✗ exitRule();
3013 ✗ });
3014 try {
3015 ✗ enterOuterAlt(_localctx, 1);
3016 ✗ setState(432);
3017 ✗ name();
3018
3019 ✗ } catch (RecognitionException& e) {
3020 ✗ _errHandler->reportError(this, e);
3021 ✗ _localctx->exception = std::current_exception();
3022 ✗ _errHandler->recover(this, _localctx->exception);
3023 ✗ }
3024
3025 ✗ return _localctx;
3026 ✗ }
3027
3028 //----------------- Component_listContext ------------------------------------------------------------------
3029
3030 ✗ modelicaParser::Component_listContext::Component_listContext(ParserRuleContext* parent, size_t invokingState)
3031 ✗ : ParserRuleContext(parent, invokingState) {}
3032
3033 ✗ std::vector<modelicaParser::Component_declarationContext*> modelicaParser::Component_listContext::component_declaration() {
3034 ✗ return getRuleContexts<modelicaParser::Component_declarationContext>();
3035 }
3036
3037 ✗ modelicaParser::Component_declarationContext* modelicaParser::Component_listContext::component_declaration(size_t i) {
3038 ✗ return getRuleContext<modelicaParser::Component_declarationContext>(i);
3039 }
3040
3041 ✗ size_t modelicaParser::Component_listContext::getRuleIndex() const {
3042 ✗ return modelicaParser::RuleComponent_list;
3043 }
3044
3045 ✗ void modelicaParser::Component_listContext::enterRule(tree::ParseTreeListener* listener) {
3046 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3047 ✗ if (parserListener != nullptr) parserListener->enterComponent_list(this);
3048 ✗ }
3049
3050 ✗ void modelicaParser::Component_listContext::exitRule(tree::ParseTreeListener* listener) {
3051 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3052 ✗ if (parserListener != nullptr) parserListener->exitComponent_list(this);
3053 ✗ }
3054
3055 ✗ std::any modelicaParser::Component_listContext::accept(tree::ParseTreeVisitor* visitor) {
3056 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3057 ✗ return parserVisitor->visitComponent_list(this);
3058 else
3059 ✗ return visitor->visitChildren(this);
3060 }
3061
3062 ✗ modelicaParser::Component_listContext* modelicaParser::component_list() {
3063 ✗ Component_listContext* _localctx = _tracker.createInstance<Component_listContext>(_ctx, getState());
3064 ✗ enterRule(_localctx, 46, modelicaParser::RuleComponent_list);
3065 ✗ size_t _la = 0;
3066
3067 #if __cplusplus > 201703L
3068 ✗ auto onExit = finally([=, this] {
3069 #else
3070 auto onExit = finally([=] {
3071 #endif
3072 ✗ exitRule();
3073 ✗ });
3074 try {
3075 ✗ enterOuterAlt(_localctx, 1);
3076 ✗ setState(434);
3077 ✗ component_declaration();
3078 ✗ setState(439);
3079 ✗ _errHandler->sync(this);
3080 ✗ _la = _input->LA(1);
3081 ✗ while (_la == modelicaParser::T__25) {
3082 ✗ setState(435);
3083 ✗ match(modelicaParser::T__25);
3084 ✗ setState(436);
3085 ✗ component_declaration();
3086 ✗ setState(441);
3087 ✗ _errHandler->sync(this);
3088 ✗ _la = _input->LA(1);
3089 }
3090
3091 ✗ } catch (RecognitionException& e) {
3092 ✗ _errHandler->reportError(this, e);
3093 ✗ _localctx->exception = std::current_exception();
3094 ✗ _errHandler->recover(this, _localctx->exception);
3095 ✗ }
3096
3097 ✗ return _localctx;
3098 ✗ }
3099
3100 //----------------- Component_declarationContext ------------------------------------------------------------------
3101
3102 ✗ modelicaParser::Component_declarationContext::Component_declarationContext(ParserRuleContext* parent, size_t invokingState)
3103 ✗ : ParserRuleContext(parent, invokingState) {}
3104
3105 ✗ modelicaParser::DeclarationContext* modelicaParser::Component_declarationContext::declaration() {
3106 ✗ return getRuleContext<modelicaParser::DeclarationContext>(0);
3107 }
3108
3109 ✗ modelicaParser::CommentContext* modelicaParser::Component_declarationContext::comment() {
3110 ✗ return getRuleContext<modelicaParser::CommentContext>(0);
3111 }
3112
3113 ✗ modelicaParser::Condition_attributeContext* modelicaParser::Component_declarationContext::condition_attribute() {
3114 ✗ return getRuleContext<modelicaParser::Condition_attributeContext>(0);
3115 }
3116
3117 ✗ size_t modelicaParser::Component_declarationContext::getRuleIndex() const {
3118 ✗ return modelicaParser::RuleComponent_declaration;
3119 }
3120
3121 ✗ void modelicaParser::Component_declarationContext::enterRule(tree::ParseTreeListener* listener) {
3122 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3123 ✗ if (parserListener != nullptr) parserListener->enterComponent_declaration(this);
3124 ✗ }
3125
3126 ✗ void modelicaParser::Component_declarationContext::exitRule(tree::ParseTreeListener* listener) {
3127 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3128 ✗ if (parserListener != nullptr) parserListener->exitComponent_declaration(this);
3129 ✗ }
3130
3131 ✗ std::any modelicaParser::Component_declarationContext::accept(tree::ParseTreeVisitor* visitor) {
3132 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3133 ✗ return parserVisitor->visitComponent_declaration(this);
3134 else
3135 ✗ return visitor->visitChildren(this);
3136 }
3137
3138 ✗ modelicaParser::Component_declarationContext* modelicaParser::component_declaration() {
3139 ✗ Component_declarationContext* _localctx = _tracker.createInstance<Component_declarationContext>(_ctx, getState());
3140 ✗ enterRule(_localctx, 48, modelicaParser::RuleComponent_declaration);
3141 ✗ size_t _la = 0;
3142
3143 #if __cplusplus > 201703L
3144 ✗ auto onExit = finally([=, this] {
3145 #else
3146 auto onExit = finally([=] {
3147 #endif
3148 ✗ exitRule();
3149 ✗ });
3150 try {
3151 ✗ enterOuterAlt(_localctx, 1);
3152 ✗ setState(442);
3153 ✗ declaration();
3154 ✗ setState(444);
3155 ✗ _errHandler->sync(this);
3156
3157 ✗ _la = _input->LA(1);
3158 ✗ if (_la == modelicaParser::T__45) {
3159 ✗ setState(443);
3160 ✗ condition_attribute();
3161 }
3162 ✗ setState(446);
3163 ✗ comment();
3164
3165 ✗ } catch (RecognitionException& e) {
3166 ✗ _errHandler->reportError(this, e);
3167 ✗ _localctx->exception = std::current_exception();
3168 ✗ _errHandler->recover(this, _localctx->exception);
3169 ✗ }
3170
3171 ✗ return _localctx;
3172 ✗ }
3173
3174 //----------------- Condition_attributeContext ------------------------------------------------------------------
3175
3176 ✗ modelicaParser::Condition_attributeContext::Condition_attributeContext(ParserRuleContext* parent, size_t invokingState)
3177 ✗ : ParserRuleContext(parent, invokingState) {}
3178
3179 ✗ modelicaParser::ExpressionContext* modelicaParser::Condition_attributeContext::expression() {
3180 ✗ return getRuleContext<modelicaParser::ExpressionContext>(0);
3181 }
3182
3183 ✗ size_t modelicaParser::Condition_attributeContext::getRuleIndex() const {
3184 ✗ return modelicaParser::RuleCondition_attribute;
3185 }
3186
3187 ✗ void modelicaParser::Condition_attributeContext::enterRule(tree::ParseTreeListener* listener) {
3188 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3189 ✗ if (parserListener != nullptr) parserListener->enterCondition_attribute(this);
3190 ✗ }
3191
3192 ✗ void modelicaParser::Condition_attributeContext::exitRule(tree::ParseTreeListener* listener) {
3193 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3194 ✗ if (parserListener != nullptr) parserListener->exitCondition_attribute(this);
3195 ✗ }
3196
3197 ✗ std::any modelicaParser::Condition_attributeContext::accept(tree::ParseTreeVisitor* visitor) {
3198 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3199 ✗ return parserVisitor->visitCondition_attribute(this);
3200 else
3201 ✗ return visitor->visitChildren(this);
3202 }
3203
3204 ✗ modelicaParser::Condition_attributeContext* modelicaParser::condition_attribute() {
3205 ✗ Condition_attributeContext* _localctx = _tracker.createInstance<Condition_attributeContext>(_ctx, getState());
3206 ✗ enterRule(_localctx, 50, modelicaParser::RuleCondition_attribute);
3207
3208 #if __cplusplus > 201703L
3209 ✗ auto onExit = finally([=, this] {
3210 #else
3211 auto onExit = finally([=] {
3212 #endif
3213 ✗ exitRule();
3214 ✗ });
3215 try {
3216 ✗ enterOuterAlt(_localctx, 1);
3217 ✗ setState(448);
3218 ✗ match(modelicaParser::T__45);
3219 ✗ setState(449);
3220 ✗ expression();
3221
3222 ✗ } catch (RecognitionException& e) {
3223 ✗ _errHandler->reportError(this, e);
3224 ✗ _localctx->exception = std::current_exception();
3225 ✗ _errHandler->recover(this, _localctx->exception);
3226 ✗ }
3227
3228 ✗ return _localctx;
3229 ✗ }
3230
3231 //----------------- DeclarationContext ------------------------------------------------------------------
3232
3233 ✗ modelicaParser::DeclarationContext::DeclarationContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
3234
3235 ✗ tree::TerminalNode* modelicaParser::DeclarationContext::IDENT() {
3236 ✗ return getToken(modelicaParser::IDENT, 0);
3237 }
3238
3239 ✗ modelicaParser::Array_subscriptsContext* modelicaParser::DeclarationContext::array_subscripts() {
3240 ✗ return getRuleContext<modelicaParser::Array_subscriptsContext>(0);
3241 }
3242
3243 ✗ modelicaParser::ModificationContext* modelicaParser::DeclarationContext::modification() {
3244 ✗ return getRuleContext<modelicaParser::ModificationContext>(0);
3245 }
3246
3247 ✗ size_t modelicaParser::DeclarationContext::getRuleIndex() const {
3248 ✗ return modelicaParser::RuleDeclaration;
3249 }
3250
3251 ✗ void modelicaParser::DeclarationContext::enterRule(tree::ParseTreeListener* listener) {
3252 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3253 ✗ if (parserListener != nullptr) parserListener->enterDeclaration(this);
3254 ✗ }
3255
3256 ✗ void modelicaParser::DeclarationContext::exitRule(tree::ParseTreeListener* listener) {
3257 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3258 ✗ if (parserListener != nullptr) parserListener->exitDeclaration(this);
3259 ✗ }
3260
3261 ✗ std::any modelicaParser::DeclarationContext::accept(tree::ParseTreeVisitor* visitor) {
3262 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3263 ✗ return parserVisitor->visitDeclaration(this);
3264 else
3265 ✗ return visitor->visitChildren(this);
3266 }
3267
3268 ✗ modelicaParser::DeclarationContext* modelicaParser::declaration() {
3269 ✗ DeclarationContext* _localctx = _tracker.createInstance<DeclarationContext>(_ctx, getState());
3270 ✗ enterRule(_localctx, 52, modelicaParser::RuleDeclaration);
3271 ✗ size_t _la = 0;
3272
3273 #if __cplusplus > 201703L
3274 ✗ auto onExit = finally([=, this] {
3275 #else
3276 auto onExit = finally([=] {
3277 #endif
3278 ✗ exitRule();
3279 ✗ });
3280 try {
3281 ✗ enterOuterAlt(_localctx, 1);
3282 ✗ setState(451);
3283 ✗ match(modelicaParser::IDENT);
3284 ✗ setState(453);
3285 ✗ _errHandler->sync(this);
3286
3287 ✗ _la = _input->LA(1);
3288 ✗ if (_la == modelicaParser::T__83) {
3289 ✗ setState(452);
3290 ✗ array_subscripts();
3291 }
3292 ✗ setState(456);
3293 ✗ _errHandler->sync(this);
3294
3295 ✗ _la = _input->LA(1);
3296 ✗ if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 140737493598208) != 0)) {
3297 ✗ setState(455);
3298 ✗ modification();
3299 }
3300
3301 ✗ } catch (RecognitionException& e) {
3302 ✗ _errHandler->reportError(this, e);
3303 ✗ _localctx->exception = std::current_exception();
3304 ✗ _errHandler->recover(this, _localctx->exception);
3305 ✗ }
3306
3307 ✗ return _localctx;
3308 ✗ }
3309
3310 //----------------- ModificationContext ------------------------------------------------------------------
3311
3312 ✗ modelicaParser::ModificationContext::ModificationContext(ParserRuleContext* parent, size_t invokingState)
3313 ✗ : ParserRuleContext(parent, invokingState) {}
3314
3315 ✗ modelicaParser::Class_modificationContext* modelicaParser::ModificationContext::class_modification() {
3316 ✗ return getRuleContext<modelicaParser::Class_modificationContext>(0);
3317 }
3318
3319 ✗ modelicaParser::ExpressionContext* modelicaParser::ModificationContext::expression() {
3320 ✗ return getRuleContext<modelicaParser::ExpressionContext>(0);
3321 }
3322
3323 ✗ size_t modelicaParser::ModificationContext::getRuleIndex() const {
3324 ✗ return modelicaParser::RuleModification;
3325 }
3326
3327 ✗ void modelicaParser::ModificationContext::enterRule(tree::ParseTreeListener* listener) {
3328 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3329 ✗ if (parserListener != nullptr) parserListener->enterModification(this);
3330 ✗ }
3331
3332 ✗ void modelicaParser::ModificationContext::exitRule(tree::ParseTreeListener* listener) {
3333 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3334 ✗ if (parserListener != nullptr) parserListener->exitModification(this);
3335 ✗ }
3336
3337 ✗ std::any modelicaParser::ModificationContext::accept(tree::ParseTreeVisitor* visitor) {
3338 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3339 ✗ return parserVisitor->visitModification(this);
3340 else
3341 ✗ return visitor->visitChildren(this);
3342 }
3343
3344 ✗ modelicaParser::ModificationContext* modelicaParser::modification() {
3345 ✗ ModificationContext* _localctx = _tracker.createInstance<ModificationContext>(_ctx, getState());
3346 ✗ enterRule(_localctx, 54, modelicaParser::RuleModification);
3347 ✗ size_t _la = 0;
3348
3349 #if __cplusplus > 201703L
3350 ✗ auto onExit = finally([=, this] {
3351 #else
3352 auto onExit = finally([=] {
3353 #endif
3354 ✗ exitRule();
3355 ✗ });
3356 try {
3357 ✗ setState(467);
3358 ✗ _errHandler->sync(this);
3359 ✗ switch (_input->LA(1)) {
3360 ✗ case modelicaParser::T__21: {
3361 ✗ enterOuterAlt(_localctx, 1);
3362 ✗ setState(458);
3363 ✗ class_modification();
3364 ✗ setState(461);
3365 ✗ _errHandler->sync(this);
3366
3367 ✗ _la = _input->LA(1);
3368 ✗ if (_la == modelicaParser::T__19) {
3369 ✗ setState(459);
3370 ✗ match(modelicaParser::T__19);
3371 ✗ setState(460);
3372 ✗ expression();
3373 }
3374 ✗ break;
3375 }
3376
3377 ✗ case modelicaParser::T__19: {
3378 ✗ enterOuterAlt(_localctx, 2);
3379 ✗ setState(463);
3380 ✗ match(modelicaParser::T__19);
3381 ✗ setState(464);
3382 ✗ expression();
3383 ✗ break;
3384 }
3385
3386 ✗ case modelicaParser::T__46: {
3387 ✗ enterOuterAlt(_localctx, 3);
3388 ✗ setState(465);
3389 ✗ match(modelicaParser::T__46);
3390 ✗ setState(466);
3391 ✗ expression();
3392 ✗ break;
3393 }
3394
3395 ✗ default:
3396 ✗ throw NoViableAltException(this);
3397 }
3398
3399 ✗ } catch (RecognitionException& e) {
3400 ✗ _errHandler->reportError(this, e);
3401 ✗ _localctx->exception = std::current_exception();
3402 ✗ _errHandler->recover(this, _localctx->exception);
3403 ✗ }
3404
3405 ✗ return _localctx;
3406 ✗ }
3407
3408 //----------------- Class_modificationContext ------------------------------------------------------------------
3409
3410 ✗ modelicaParser::Class_modificationContext::Class_modificationContext(ParserRuleContext* parent, size_t invokingState)
3411 ✗ : ParserRuleContext(parent, invokingState) {}
3412
3413 ✗ modelicaParser::Argument_listContext* modelicaParser::Class_modificationContext::argument_list() {
3414 ✗ return getRuleContext<modelicaParser::Argument_listContext>(0);
3415 }
3416
3417 ✗ size_t modelicaParser::Class_modificationContext::getRuleIndex() const {
3418 ✗ return modelicaParser::RuleClass_modification;
3419 }
3420
3421 ✗ void modelicaParser::Class_modificationContext::enterRule(tree::ParseTreeListener* listener) {
3422 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3423 ✗ if (parserListener != nullptr) parserListener->enterClass_modification(this);
3424 ✗ }
3425
3426 ✗ void modelicaParser::Class_modificationContext::exitRule(tree::ParseTreeListener* listener) {
3427 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3428 ✗ if (parserListener != nullptr) parserListener->exitClass_modification(this);
3429 ✗ }
3430
3431 ✗ std::any modelicaParser::Class_modificationContext::accept(tree::ParseTreeVisitor* visitor) {
3432 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3433 ✗ return parserVisitor->visitClass_modification(this);
3434 else
3435 ✗ return visitor->visitChildren(this);
3436 }
3437
3438 ✗ modelicaParser::Class_modificationContext* modelicaParser::class_modification() {
3439 ✗ Class_modificationContext* _localctx = _tracker.createInstance<Class_modificationContext>(_ctx, getState());
3440 ✗ enterRule(_localctx, 56, modelicaParser::RuleClass_modification);
3441 ✗ size_t _la = 0;
3442
3443 #if __cplusplus > 201703L
3444 ✗ auto onExit = finally([=, this] {
3445 #else
3446 auto onExit = finally([=] {
3447 #endif
3448 ✗ exitRule();
3449 ✗ });
3450 try {
3451 ✗ enterOuterAlt(_localctx, 1);
3452 ✗ setState(469);
3453 ✗ match(modelicaParser::T__21);
3454 ✗ setState(471);
3455 ✗ _errHandler->sync(this);
3456
3457 ✗ _la = _input->LA(1);
3458 ✗ if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 281484640387074) != 0) || _la == modelicaParser::T__86
3459
3460 ✗ || _la == modelicaParser::IDENT) {
3461 ✗ setState(470);
3462 ✗ argument_list();
3463 }
3464 ✗ setState(473);
3465 ✗ match(modelicaParser::T__23);
3466
3467 ✗ } catch (RecognitionException& e) {
3468 ✗ _errHandler->reportError(this, e);
3469 ✗ _localctx->exception = std::current_exception();
3470 ✗ _errHandler->recover(this, _localctx->exception);
3471 ✗ }
3472
3473 ✗ return _localctx;
3474 ✗ }
3475
3476 //----------------- Argument_listContext ------------------------------------------------------------------
3477
3478 ✗ modelicaParser::Argument_listContext::Argument_listContext(ParserRuleContext* parent, size_t invokingState)
3479 ✗ : ParserRuleContext(parent, invokingState) {}
3480
3481 ✗ std::vector<modelicaParser::ArgumentContext*> modelicaParser::Argument_listContext::argument() {
3482 ✗ return getRuleContexts<modelicaParser::ArgumentContext>();
3483 }
3484
3485 ✗ modelicaParser::ArgumentContext* modelicaParser::Argument_listContext::argument(size_t i) {
3486 ✗ return getRuleContext<modelicaParser::ArgumentContext>(i);
3487 }
3488
3489 ✗ size_t modelicaParser::Argument_listContext::getRuleIndex() const {
3490 ✗ return modelicaParser::RuleArgument_list;
3491 }
3492
3493 ✗ void modelicaParser::Argument_listContext::enterRule(tree::ParseTreeListener* listener) {
3494 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3495 ✗ if (parserListener != nullptr) parserListener->enterArgument_list(this);
3496 ✗ }
3497
3498 ✗ void modelicaParser::Argument_listContext::exitRule(tree::ParseTreeListener* listener) {
3499 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3500 ✗ if (parserListener != nullptr) parserListener->exitArgument_list(this);
3501 ✗ }
3502
3503 ✗ std::any modelicaParser::Argument_listContext::accept(tree::ParseTreeVisitor* visitor) {
3504 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3505 ✗ return parserVisitor->visitArgument_list(this);
3506 else
3507 ✗ return visitor->visitChildren(this);
3508 }
3509
3510 ✗ modelicaParser::Argument_listContext* modelicaParser::argument_list() {
3511 ✗ Argument_listContext* _localctx = _tracker.createInstance<Argument_listContext>(_ctx, getState());
3512 ✗ enterRule(_localctx, 58, modelicaParser::RuleArgument_list);
3513 ✗ size_t _la = 0;
3514
3515 #if __cplusplus > 201703L
3516 ✗ auto onExit = finally([=, this] {
3517 #else
3518 auto onExit = finally([=] {
3519 #endif
3520 ✗ exitRule();
3521 ✗ });
3522 try {
3523 ✗ enterOuterAlt(_localctx, 1);
3524 ✗ setState(475);
3525 ✗ argument();
3526 ✗ setState(480);
3527 ✗ _errHandler->sync(this);
3528 ✗ _la = _input->LA(1);
3529 ✗ while (_la == modelicaParser::T__25) {
3530 ✗ setState(476);
3531 ✗ match(modelicaParser::T__25);
3532 ✗ setState(477);
3533 ✗ argument();
3534 ✗ setState(482);
3535 ✗ _errHandler->sync(this);
3536 ✗ _la = _input->LA(1);
3537 }
3538
3539 ✗ } catch (RecognitionException& e) {
3540 ✗ _errHandler->reportError(this, e);
3541 ✗ _localctx->exception = std::current_exception();
3542 ✗ _errHandler->recover(this, _localctx->exception);
3543 ✗ }
3544
3545 ✗ return _localctx;
3546 ✗ }
3547
3548 //----------------- ArgumentContext ------------------------------------------------------------------
3549
3550 ✗ modelicaParser::ArgumentContext::ArgumentContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
3551
3552 ✗ modelicaParser::Element_modification_or_replaceableContext* modelicaParser::ArgumentContext::element_modification_or_replaceable() {
3553 ✗ return getRuleContext<modelicaParser::Element_modification_or_replaceableContext>(0);
3554 }
3555
3556 ✗ modelicaParser::Element_redeclarationContext* modelicaParser::ArgumentContext::element_redeclaration() {
3557 ✗ return getRuleContext<modelicaParser::Element_redeclarationContext>(0);
3558 }
3559
3560 ✗ size_t modelicaParser::ArgumentContext::getRuleIndex() const {
3561 ✗ return modelicaParser::RuleArgument;
3562 }
3563
3564 ✗ void modelicaParser::ArgumentContext::enterRule(tree::ParseTreeListener* listener) {
3565 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3566 ✗ if (parserListener != nullptr) parserListener->enterArgument(this);
3567 ✗ }
3568
3569 ✗ void modelicaParser::ArgumentContext::exitRule(tree::ParseTreeListener* listener) {
3570 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3571 ✗ if (parserListener != nullptr) parserListener->exitArgument(this);
3572 ✗ }
3573
3574 ✗ std::any modelicaParser::ArgumentContext::accept(tree::ParseTreeVisitor* visitor) {
3575 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3576 ✗ return parserVisitor->visitArgument(this);
3577 else
3578 ✗ return visitor->visitChildren(this);
3579 }
3580
3581 ✗ modelicaParser::ArgumentContext* modelicaParser::argument() {
3582 ✗ ArgumentContext* _localctx = _tracker.createInstance<ArgumentContext>(_ctx, getState());
3583 ✗ enterRule(_localctx, 60, modelicaParser::RuleArgument);
3584
3585 #if __cplusplus > 201703L
3586 ✗ auto onExit = finally([=, this] {
3587 #else
3588 auto onExit = finally([=] {
3589 #endif
3590 ✗ exitRule();
3591 ✗ });
3592 try {
3593 ✗ setState(485);
3594 ✗ _errHandler->sync(this);
3595 ✗ switch (_input->LA(1)) {
3596 ✗ case modelicaParser::T__0:
3597 case modelicaParser::T__32:
3598 case modelicaParser::T__47:
3599 case modelicaParser::T__86:
3600 case modelicaParser::IDENT: {
3601 ✗ enterOuterAlt(_localctx, 1);
3602 ✗ setState(483);
3603 ✗ element_modification_or_replaceable();
3604 ✗ break;
3605 }
3606
3607 ✗ case modelicaParser::T__29: {
3608 ✗ enterOuterAlt(_localctx, 2);
3609 ✗ setState(484);
3610 ✗ element_redeclaration();
3611 ✗ break;
3612 }
3613
3614 ✗ default:
3615 ✗ throw NoViableAltException(this);
3616 }
3617
3618 ✗ } catch (RecognitionException& e) {
3619 ✗ _errHandler->reportError(this, e);
3620 ✗ _localctx->exception = std::current_exception();
3621 ✗ _errHandler->recover(this, _localctx->exception);
3622 ✗ }
3623
3624 ✗ return _localctx;
3625 ✗ }
3626
3627 //----------------- Element_modification_or_replaceableContext ------------------------------------------------------------------
3628
3629 ✗ modelicaParser::Element_modification_or_replaceableContext::Element_modification_or_replaceableContext(ParserRuleContext* parent,
3630 ✗ size_t invokingState)
3631 ✗ : ParserRuleContext(parent, invokingState) {}
3632
3633 ✗ modelicaParser::Element_modificationContext* modelicaParser::Element_modification_or_replaceableContext::element_modification() {
3634 ✗ return getRuleContext<modelicaParser::Element_modificationContext>(0);
3635 }
3636
3637 ✗ modelicaParser::Element_replaceableContext* modelicaParser::Element_modification_or_replaceableContext::element_replaceable() {
3638 ✗ return getRuleContext<modelicaParser::Element_replaceableContext>(0);
3639 }
3640
3641 ✗ size_t modelicaParser::Element_modification_or_replaceableContext::getRuleIndex() const {
3642 ✗ return modelicaParser::RuleElement_modification_or_replaceable;
3643 }
3644
3645 ✗ void modelicaParser::Element_modification_or_replaceableContext::enterRule(tree::ParseTreeListener* listener) {
3646 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3647 ✗ if (parserListener != nullptr) parserListener->enterElement_modification_or_replaceable(this);
3648 ✗ }
3649
3650 ✗ void modelicaParser::Element_modification_or_replaceableContext::exitRule(tree::ParseTreeListener* listener) {
3651 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3652 ✗ if (parserListener != nullptr) parserListener->exitElement_modification_or_replaceable(this);
3653 ✗ }
3654
3655 ✗ std::any modelicaParser::Element_modification_or_replaceableContext::accept(tree::ParseTreeVisitor* visitor) {
3656 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3657 ✗ return parserVisitor->visitElement_modification_or_replaceable(this);
3658 else
3659 ✗ return visitor->visitChildren(this);
3660 }
3661
3662 ✗ modelicaParser::Element_modification_or_replaceableContext* modelicaParser::element_modification_or_replaceable() {
3663 ✗ Element_modification_or_replaceableContext* _localctx = _tracker.createInstance<Element_modification_or_replaceableContext>(_ctx, getState());
3664 ✗ enterRule(_localctx, 62, modelicaParser::RuleElement_modification_or_replaceable);
3665 ✗ size_t _la = 0;
3666
3667 #if __cplusplus > 201703L
3668 ✗ auto onExit = finally([=, this] {
3669 #else
3670 auto onExit = finally([=] {
3671 #endif
3672 ✗ exitRule();
3673 ✗ });
3674 try {
3675 ✗ enterOuterAlt(_localctx, 1);
3676 ✗ setState(488);
3677 ✗ _errHandler->sync(this);
3678
3679 ✗ _la = _input->LA(1);
3680 ✗ if (_la == modelicaParser::T__47) {
3681 ✗ setState(487);
3682 ✗ match(modelicaParser::T__47);
3683 }
3684 ✗ setState(491);
3685 ✗ _errHandler->sync(this);
3686
3687 ✗ _la = _input->LA(1);
3688 ✗ if (_la == modelicaParser::T__0) {
3689 ✗ setState(490);
3690 ✗ match(modelicaParser::T__0);
3691 }
3692 ✗ setState(495);
3693 ✗ _errHandler->sync(this);
3694 ✗ switch (_input->LA(1)) {
3695 ✗ case modelicaParser::T__86:
3696 case modelicaParser::IDENT: {
3697 ✗ setState(493);
3698 ✗ element_modification();
3699 ✗ break;
3700 }
3701
3702 ✗ case modelicaParser::T__32: {
3703 ✗ setState(494);
3704 ✗ element_replaceable();
3705 ✗ break;
3706 }
3707
3708 ✗ default:
3709 ✗ throw NoViableAltException(this);
3710 }
3711
3712 ✗ } catch (RecognitionException& e) {
3713 ✗ _errHandler->reportError(this, e);
3714 ✗ _localctx->exception = std::current_exception();
3715 ✗ _errHandler->recover(this, _localctx->exception);
3716 ✗ }
3717
3718 ✗ return _localctx;
3719 ✗ }
3720
3721 //----------------- Element_modificationContext ------------------------------------------------------------------
3722
3723 ✗ modelicaParser::Element_modificationContext::Element_modificationContext(ParserRuleContext* parent, size_t invokingState)
3724 ✗ : ParserRuleContext(parent, invokingState) {}
3725
3726 ✗ modelicaParser::NameContext* modelicaParser::Element_modificationContext::name() {
3727 ✗ return getRuleContext<modelicaParser::NameContext>(0);
3728 }
3729
3730 ✗ modelicaParser::String_commentContext* modelicaParser::Element_modificationContext::string_comment() {
3731 ✗ return getRuleContext<modelicaParser::String_commentContext>(0);
3732 }
3733
3734 ✗ modelicaParser::ModificationContext* modelicaParser::Element_modificationContext::modification() {
3735 ✗ return getRuleContext<modelicaParser::ModificationContext>(0);
3736 }
3737
3738 ✗ size_t modelicaParser::Element_modificationContext::getRuleIndex() const {
3739 ✗ return modelicaParser::RuleElement_modification;
3740 }
3741
3742 ✗ void modelicaParser::Element_modificationContext::enterRule(tree::ParseTreeListener* listener) {
3743 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3744 ✗ if (parserListener != nullptr) parserListener->enterElement_modification(this);
3745 ✗ }
3746
3747 ✗ void modelicaParser::Element_modificationContext::exitRule(tree::ParseTreeListener* listener) {
3748 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3749 ✗ if (parserListener != nullptr) parserListener->exitElement_modification(this);
3750 ✗ }
3751
3752 ✗ std::any modelicaParser::Element_modificationContext::accept(tree::ParseTreeVisitor* visitor) {
3753 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3754 ✗ return parserVisitor->visitElement_modification(this);
3755 else
3756 ✗ return visitor->visitChildren(this);
3757 }
3758
3759 ✗ modelicaParser::Element_modificationContext* modelicaParser::element_modification() {
3760 ✗ Element_modificationContext* _localctx = _tracker.createInstance<Element_modificationContext>(_ctx, getState());
3761 ✗ enterRule(_localctx, 64, modelicaParser::RuleElement_modification);
3762 ✗ size_t _la = 0;
3763
3764 #if __cplusplus > 201703L
3765 ✗ auto onExit = finally([=, this] {
3766 #else
3767 auto onExit = finally([=] {
3768 #endif
3769 ✗ exitRule();
3770 ✗ });
3771 try {
3772 ✗ enterOuterAlt(_localctx, 1);
3773 ✗ setState(497);
3774 ✗ name();
3775 ✗ setState(499);
3776 ✗ _errHandler->sync(this);
3777
3778 ✗ _la = _input->LA(1);
3779 ✗ if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 140737493598208) != 0)) {
3780 ✗ setState(498);
3781 ✗ modification();
3782 }
3783 ✗ setState(501);
3784 ✗ string_comment();
3785
3786 ✗ } catch (RecognitionException& e) {
3787 ✗ _errHandler->reportError(this, e);
3788 ✗ _localctx->exception = std::current_exception();
3789 ✗ _errHandler->recover(this, _localctx->exception);
3790 ✗ }
3791
3792 ✗ return _localctx;
3793 ✗ }
3794
3795 //----------------- Element_redeclarationContext ------------------------------------------------------------------
3796
3797 ✗ modelicaParser::Element_redeclarationContext::Element_redeclarationContext(ParserRuleContext* parent, size_t invokingState)
3798 ✗ : ParserRuleContext(parent, invokingState) {}
3799
3800 ✗ modelicaParser::Element_replaceableContext* modelicaParser::Element_redeclarationContext::element_replaceable() {
3801 ✗ return getRuleContext<modelicaParser::Element_replaceableContext>(0);
3802 }
3803
3804 ✗ modelicaParser::Short_class_definitionContext* modelicaParser::Element_redeclarationContext::short_class_definition() {
3805 ✗ return getRuleContext<modelicaParser::Short_class_definitionContext>(0);
3806 }
3807
3808 ✗ modelicaParser::Component_clause1Context* modelicaParser::Element_redeclarationContext::component_clause1() {
3809 ✗ return getRuleContext<modelicaParser::Component_clause1Context>(0);
3810 }
3811
3812 ✗ size_t modelicaParser::Element_redeclarationContext::getRuleIndex() const {
3813 ✗ return modelicaParser::RuleElement_redeclaration;
3814 }
3815
3816 ✗ void modelicaParser::Element_redeclarationContext::enterRule(tree::ParseTreeListener* listener) {
3817 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3818 ✗ if (parserListener != nullptr) parserListener->enterElement_redeclaration(this);
3819 ✗ }
3820
3821 ✗ void modelicaParser::Element_redeclarationContext::exitRule(tree::ParseTreeListener* listener) {
3822 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3823 ✗ if (parserListener != nullptr) parserListener->exitElement_redeclaration(this);
3824 ✗ }
3825
3826 ✗ std::any modelicaParser::Element_redeclarationContext::accept(tree::ParseTreeVisitor* visitor) {
3827 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3828 ✗ return parserVisitor->visitElement_redeclaration(this);
3829 else
3830 ✗ return visitor->visitChildren(this);
3831 }
3832
3833 ✗ modelicaParser::Element_redeclarationContext* modelicaParser::element_redeclaration() {
3834 ✗ Element_redeclarationContext* _localctx = _tracker.createInstance<Element_redeclarationContext>(_ctx, getState());
3835 ✗ enterRule(_localctx, 66, modelicaParser::RuleElement_redeclaration);
3836 ✗ size_t _la = 0;
3837
3838 #if __cplusplus > 201703L
3839 ✗ auto onExit = finally([=, this] {
3840 #else
3841 auto onExit = finally([=] {
3842 #endif
3843 ✗ exitRule();
3844 ✗ });
3845 try {
3846 ✗ enterOuterAlt(_localctx, 1);
3847 ✗ setState(503);
3848 ✗ match(modelicaParser::T__29);
3849 ✗ setState(505);
3850 ✗ _errHandler->sync(this);
3851
3852 ✗ _la = _input->LA(1);
3853 ✗ if (_la == modelicaParser::T__47) {
3854 ✗ setState(504);
3855 ✗ match(modelicaParser::T__47);
3856 }
3857 ✗ setState(508);
3858 ✗ _errHandler->sync(this);
3859
3860 ✗ _la = _input->LA(1);
3861 ✗ if (_la == modelicaParser::T__0) {
3862 ✗ setState(507);
3863 ✗ match(modelicaParser::T__0);
3864 }
3865 ✗ setState(515);
3866 ✗ _errHandler->sync(this);
3867 ✗ switch (_input->LA(1)) {
3868 ✗ case modelicaParser::T__4:
3869 case modelicaParser::T__5:
3870 case modelicaParser::T__6:
3871 case modelicaParser::T__7:
3872 case modelicaParser::T__8:
3873 case modelicaParser::T__9:
3874 case modelicaParser::T__10:
3875 case modelicaParser::T__11:
3876 case modelicaParser::T__12:
3877 case modelicaParser::T__13:
3878 case modelicaParser::T__14:
3879 case modelicaParser::T__15:
3880 case modelicaParser::T__16:
3881 case modelicaParser::T__38:
3882 case modelicaParser::T__39:
3883 case modelicaParser::T__40:
3884 case modelicaParser::T__41:
3885 case modelicaParser::T__42:
3886 case modelicaParser::T__43:
3887 case modelicaParser::T__44:
3888 case modelicaParser::T__86:
3889 case modelicaParser::IDENT: {
3890 ✗ setState(512);
3891 ✗ _errHandler->sync(this);
3892 ✗ switch (_input->LA(1)) {
3893 ✗ case modelicaParser::T__4:
3894 case modelicaParser::T__5:
3895 case modelicaParser::T__6:
3896 case modelicaParser::T__7:
3897 case modelicaParser::T__8:
3898 case modelicaParser::T__9:
3899 case modelicaParser::T__10:
3900 case modelicaParser::T__11:
3901 case modelicaParser::T__12:
3902 case modelicaParser::T__13:
3903 case modelicaParser::T__14:
3904 case modelicaParser::T__15:
3905 case modelicaParser::T__16: {
3906 ✗ setState(510);
3907 ✗ short_class_definition();
3908 ✗ break;
3909 }
3910
3911 ✗ case modelicaParser::T__38:
3912 case modelicaParser::T__39:
3913 case modelicaParser::T__40:
3914 case modelicaParser::T__41:
3915 case modelicaParser::T__42:
3916 case modelicaParser::T__43:
3917 case modelicaParser::T__44:
3918 case modelicaParser::T__86:
3919 case modelicaParser::IDENT: {
3920 ✗ setState(511);
3921 ✗ component_clause1();
3922 ✗ break;
3923 }
3924
3925 ✗ default:
3926 ✗ throw NoViableAltException(this);
3927 }
3928 ✗ break;
3929 }
3930
3931 ✗ case modelicaParser::T__32: {
3932 ✗ setState(514);
3933 ✗ element_replaceable();
3934 ✗ break;
3935 }
3936
3937 ✗ default:
3938 ✗ throw NoViableAltException(this);
3939 }
3940
3941 ✗ } catch (RecognitionException& e) {
3942 ✗ _errHandler->reportError(this, e);
3943 ✗ _localctx->exception = std::current_exception();
3944 ✗ _errHandler->recover(this, _localctx->exception);
3945 ✗ }
3946
3947 ✗ return _localctx;
3948 ✗ }
3949
3950 //----------------- Element_replaceableContext ------------------------------------------------------------------
3951
3952 ✗ modelicaParser::Element_replaceableContext::Element_replaceableContext(ParserRuleContext* parent, size_t invokingState)
3953 ✗ : ParserRuleContext(parent, invokingState) {}
3954
3955 ✗ modelicaParser::Short_class_definitionContext* modelicaParser::Element_replaceableContext::short_class_definition() {
3956 ✗ return getRuleContext<modelicaParser::Short_class_definitionContext>(0);
3957 }
3958
3959 ✗ modelicaParser::Component_clause1Context* modelicaParser::Element_replaceableContext::component_clause1() {
3960 ✗ return getRuleContext<modelicaParser::Component_clause1Context>(0);
3961 }
3962
3963 ✗ modelicaParser::Constraining_clauseContext* modelicaParser::Element_replaceableContext::constraining_clause() {
3964 ✗ return getRuleContext<modelicaParser::Constraining_clauseContext>(0);
3965 }
3966
3967 ✗ size_t modelicaParser::Element_replaceableContext::getRuleIndex() const {
3968 ✗ return modelicaParser::RuleElement_replaceable;
3969 }
3970
3971 ✗ void modelicaParser::Element_replaceableContext::enterRule(tree::ParseTreeListener* listener) {
3972 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3973 ✗ if (parserListener != nullptr) parserListener->enterElement_replaceable(this);
3974 ✗ }
3975
3976 ✗ void modelicaParser::Element_replaceableContext::exitRule(tree::ParseTreeListener* listener) {
3977 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
3978 ✗ if (parserListener != nullptr) parserListener->exitElement_replaceable(this);
3979 ✗ }
3980
3981 ✗ std::any modelicaParser::Element_replaceableContext::accept(tree::ParseTreeVisitor* visitor) {
3982 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
3983 ✗ return parserVisitor->visitElement_replaceable(this);
3984 else
3985 ✗ return visitor->visitChildren(this);
3986 }
3987
3988 ✗ modelicaParser::Element_replaceableContext* modelicaParser::element_replaceable() {
3989 ✗ Element_replaceableContext* _localctx = _tracker.createInstance<Element_replaceableContext>(_ctx, getState());
3990 ✗ enterRule(_localctx, 68, modelicaParser::RuleElement_replaceable);
3991 ✗ size_t _la = 0;
3992
3993 #if __cplusplus > 201703L
3994 ✗ auto onExit = finally([=, this] {
3995 #else
3996 auto onExit = finally([=] {
3997 #endif
3998 ✗ exitRule();
3999 ✗ });
4000 try {
4001 ✗ enterOuterAlt(_localctx, 1);
4002 ✗ setState(517);
4003 ✗ match(modelicaParser::T__32);
4004 ✗ setState(520);
4005 ✗ _errHandler->sync(this);
4006 ✗ switch (_input->LA(1)) {
4007 ✗ case modelicaParser::T__4:
4008 case modelicaParser::T__5:
4009 case modelicaParser::T__6:
4010 case modelicaParser::T__7:
4011 case modelicaParser::T__8:
4012 case modelicaParser::T__9:
4013 case modelicaParser::T__10:
4014 case modelicaParser::T__11:
4015 case modelicaParser::T__12:
4016 case modelicaParser::T__13:
4017 case modelicaParser::T__14:
4018 case modelicaParser::T__15:
4019 case modelicaParser::T__16: {
4020 ✗ setState(518);
4021 ✗ short_class_definition();
4022 ✗ break;
4023 }
4024
4025 ✗ case modelicaParser::T__38:
4026 case modelicaParser::T__39:
4027 case modelicaParser::T__40:
4028 case modelicaParser::T__41:
4029 case modelicaParser::T__42:
4030 case modelicaParser::T__43:
4031 case modelicaParser::T__44:
4032 case modelicaParser::T__86:
4033 case modelicaParser::IDENT: {
4034 ✗ setState(519);
4035 ✗ component_clause1();
4036 ✗ break;
4037 }
4038
4039 ✗ default:
4040 ✗ throw NoViableAltException(this);
4041 }
4042 ✗ setState(523);
4043 ✗ _errHandler->sync(this);
4044
4045 ✗ _la = _input->LA(1);
4046 ✗ if (_la == modelicaParser::T__37) {
4047 ✗ setState(522);
4048 ✗ constraining_clause();
4049 }
4050
4051 ✗ } catch (RecognitionException& e) {
4052 ✗ _errHandler->reportError(this, e);
4053 ✗ _localctx->exception = std::current_exception();
4054 ✗ _errHandler->recover(this, _localctx->exception);
4055 ✗ }
4056
4057 ✗ return _localctx;
4058 ✗ }
4059
4060 //----------------- Component_clause1Context ------------------------------------------------------------------
4061
4062 ✗ modelicaParser::Component_clause1Context::Component_clause1Context(ParserRuleContext* parent, size_t invokingState)
4063 ✗ : ParserRuleContext(parent, invokingState) {}
4064
4065 ✗ modelicaParser::Type_prefixContext* modelicaParser::Component_clause1Context::type_prefix() {
4066 ✗ return getRuleContext<modelicaParser::Type_prefixContext>(0);
4067 }
4068
4069 ✗ modelicaParser::Type_specifierContext* modelicaParser::Component_clause1Context::type_specifier() {
4070 ✗ return getRuleContext<modelicaParser::Type_specifierContext>(0);
4071 }
4072
4073 ✗ modelicaParser::Component_declaration1Context* modelicaParser::Component_clause1Context::component_declaration1() {
4074 ✗ return getRuleContext<modelicaParser::Component_declaration1Context>(0);
4075 }
4076
4077 ✗ size_t modelicaParser::Component_clause1Context::getRuleIndex() const {
4078 ✗ return modelicaParser::RuleComponent_clause1;
4079 }
4080
4081 ✗ void modelicaParser::Component_clause1Context::enterRule(tree::ParseTreeListener* listener) {
4082 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4083 ✗ if (parserListener != nullptr) parserListener->enterComponent_clause1(this);
4084 ✗ }
4085
4086 ✗ void modelicaParser::Component_clause1Context::exitRule(tree::ParseTreeListener* listener) {
4087 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4088 ✗ if (parserListener != nullptr) parserListener->exitComponent_clause1(this);
4089 ✗ }
4090
4091 ✗ std::any modelicaParser::Component_clause1Context::accept(tree::ParseTreeVisitor* visitor) {
4092 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
4093 ✗ return parserVisitor->visitComponent_clause1(this);
4094 else
4095 ✗ return visitor->visitChildren(this);
4096 }
4097
4098 ✗ modelicaParser::Component_clause1Context* modelicaParser::component_clause1() {
4099 ✗ Component_clause1Context* _localctx = _tracker.createInstance<Component_clause1Context>(_ctx, getState());
4100 ✗ enterRule(_localctx, 70, modelicaParser::RuleComponent_clause1);
4101
4102 #if __cplusplus > 201703L
4103 ✗ auto onExit = finally([=, this] {
4104 #else
4105 auto onExit = finally([=] {
4106 #endif
4107 ✗ exitRule();
4108 ✗ });
4109 try {
4110 ✗ enterOuterAlt(_localctx, 1);
4111 ✗ setState(525);
4112 ✗ type_prefix();
4113 ✗ setState(526);
4114 ✗ type_specifier();
4115 ✗ setState(527);
4116 ✗ component_declaration1();
4117
4118 ✗ } catch (RecognitionException& e) {
4119 ✗ _errHandler->reportError(this, e);
4120 ✗ _localctx->exception = std::current_exception();
4121 ✗ _errHandler->recover(this, _localctx->exception);
4122 ✗ }
4123
4124 ✗ return _localctx;
4125 ✗ }
4126
4127 //----------------- Component_declaration1Context ------------------------------------------------------------------
4128
4129 ✗ modelicaParser::Component_declaration1Context::Component_declaration1Context(ParserRuleContext* parent, size_t invokingState)
4130 ✗ : ParserRuleContext(parent, invokingState) {}
4131
4132 ✗ modelicaParser::DeclarationContext* modelicaParser::Component_declaration1Context::declaration() {
4133 ✗ return getRuleContext<modelicaParser::DeclarationContext>(0);
4134 }
4135
4136 ✗ modelicaParser::CommentContext* modelicaParser::Component_declaration1Context::comment() {
4137 ✗ return getRuleContext<modelicaParser::CommentContext>(0);
4138 }
4139
4140 ✗ size_t modelicaParser::Component_declaration1Context::getRuleIndex() const {
4141 ✗ return modelicaParser::RuleComponent_declaration1;
4142 }
4143
4144 ✗ void modelicaParser::Component_declaration1Context::enterRule(tree::ParseTreeListener* listener) {
4145 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4146 ✗ if (parserListener != nullptr) parserListener->enterComponent_declaration1(this);
4147 ✗ }
4148
4149 ✗ void modelicaParser::Component_declaration1Context::exitRule(tree::ParseTreeListener* listener) {
4150 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4151 ✗ if (parserListener != nullptr) parserListener->exitComponent_declaration1(this);
4152 ✗ }
4153
4154 ✗ std::any modelicaParser::Component_declaration1Context::accept(tree::ParseTreeVisitor* visitor) {
4155 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
4156 ✗ return parserVisitor->visitComponent_declaration1(this);
4157 else
4158 ✗ return visitor->visitChildren(this);
4159 }
4160
4161 ✗ modelicaParser::Component_declaration1Context* modelicaParser::component_declaration1() {
4162 ✗ Component_declaration1Context* _localctx = _tracker.createInstance<Component_declaration1Context>(_ctx, getState());
4163 ✗ enterRule(_localctx, 72, modelicaParser::RuleComponent_declaration1);
4164
4165 #if __cplusplus > 201703L
4166 ✗ auto onExit = finally([=, this] {
4167 #else
4168 auto onExit = finally([=] {
4169 #endif
4170 ✗ exitRule();
4171 ✗ });
4172 try {
4173 ✗ enterOuterAlt(_localctx, 1);
4174 ✗ setState(529);
4175 ✗ declaration();
4176 ✗ setState(530);
4177 ✗ comment();
4178
4179 ✗ } catch (RecognitionException& e) {
4180 ✗ _errHandler->reportError(this, e);
4181 ✗ _localctx->exception = std::current_exception();
4182 ✗ _errHandler->recover(this, _localctx->exception);
4183 ✗ }
4184
4185 ✗ return _localctx;
4186 ✗ }
4187
4188 //----------------- Short_class_definitionContext ------------------------------------------------------------------
4189
4190 ✗ modelicaParser::Short_class_definitionContext::Short_class_definitionContext(ParserRuleContext* parent, size_t invokingState)
4191 ✗ : ParserRuleContext(parent, invokingState) {}
4192
4193 ✗ modelicaParser::Class_prefixesContext* modelicaParser::Short_class_definitionContext::class_prefixes() {
4194 ✗ return getRuleContext<modelicaParser::Class_prefixesContext>(0);
4195 }
4196
4197 ✗ modelicaParser::Short_class_specifierContext* modelicaParser::Short_class_definitionContext::short_class_specifier() {
4198 ✗ return getRuleContext<modelicaParser::Short_class_specifierContext>(0);
4199 }
4200
4201 ✗ size_t modelicaParser::Short_class_definitionContext::getRuleIndex() const {
4202 ✗ return modelicaParser::RuleShort_class_definition;
4203 }
4204
4205 ✗ void modelicaParser::Short_class_definitionContext::enterRule(tree::ParseTreeListener* listener) {
4206 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4207 ✗ if (parserListener != nullptr) parserListener->enterShort_class_definition(this);
4208 ✗ }
4209
4210 ✗ void modelicaParser::Short_class_definitionContext::exitRule(tree::ParseTreeListener* listener) {
4211 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4212 ✗ if (parserListener != nullptr) parserListener->exitShort_class_definition(this);
4213 ✗ }
4214
4215 ✗ std::any modelicaParser::Short_class_definitionContext::accept(tree::ParseTreeVisitor* visitor) {
4216 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
4217 ✗ return parserVisitor->visitShort_class_definition(this);
4218 else
4219 ✗ return visitor->visitChildren(this);
4220 }
4221
4222 ✗ modelicaParser::Short_class_definitionContext* modelicaParser::short_class_definition() {
4223 ✗ Short_class_definitionContext* _localctx = _tracker.createInstance<Short_class_definitionContext>(_ctx, getState());
4224 ✗ enterRule(_localctx, 74, modelicaParser::RuleShort_class_definition);
4225
4226 #if __cplusplus > 201703L
4227 ✗ auto onExit = finally([=, this] {
4228 #else
4229 auto onExit = finally([=] {
4230 #endif
4231 ✗ exitRule();
4232 ✗ });
4233 try {
4234 ✗ enterOuterAlt(_localctx, 1);
4235 ✗ setState(532);
4236 ✗ class_prefixes();
4237 ✗ setState(533);
4238 ✗ short_class_specifier();
4239
4240 ✗ } catch (RecognitionException& e) {
4241 ✗ _errHandler->reportError(this, e);
4242 ✗ _localctx->exception = std::current_exception();
4243 ✗ _errHandler->recover(this, _localctx->exception);
4244 ✗ }
4245
4246 ✗ return _localctx;
4247 ✗ }
4248
4249 //----------------- Equation_sectionContext ------------------------------------------------------------------
4250
4251 ✗ modelicaParser::Equation_sectionContext::Equation_sectionContext(ParserRuleContext* parent, size_t invokingState)
4252 ✗ : ParserRuleContext(parent, invokingState) {}
4253
4254 ✗ std::vector<modelicaParser::EquationContext*> modelicaParser::Equation_sectionContext::equation() {
4255 ✗ return getRuleContexts<modelicaParser::EquationContext>();
4256 }
4257
4258 ✗ modelicaParser::EquationContext* modelicaParser::Equation_sectionContext::equation(size_t i) {
4259 ✗ return getRuleContext<modelicaParser::EquationContext>(i);
4260 }
4261
4262 ✗ size_t modelicaParser::Equation_sectionContext::getRuleIndex() const {
4263 ✗ return modelicaParser::RuleEquation_section;
4264 }
4265
4266 ✗ void modelicaParser::Equation_sectionContext::enterRule(tree::ParseTreeListener* listener) {
4267 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4268 ✗ if (parserListener != nullptr) parserListener->enterEquation_section(this);
4269 ✗ }
4270
4271 ✗ void modelicaParser::Equation_sectionContext::exitRule(tree::ParseTreeListener* listener) {
4272 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4273 ✗ if (parserListener != nullptr) parserListener->exitEquation_section(this);
4274 ✗ }
4275
4276 ✗ std::any modelicaParser::Equation_sectionContext::accept(tree::ParseTreeVisitor* visitor) {
4277 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
4278 ✗ return parserVisitor->visitEquation_section(this);
4279 else
4280 ✗ return visitor->visitChildren(this);
4281 }
4282
4283 ✗ modelicaParser::Equation_sectionContext* modelicaParser::equation_section() {
4284 ✗ Equation_sectionContext* _localctx = _tracker.createInstance<Equation_sectionContext>(_ctx, getState());
4285 ✗ enterRule(_localctx, 76, modelicaParser::RuleEquation_section);
4286 ✗ size_t _la = 0;
4287
4288 #if __cplusplus > 201703L
4289 ✗ auto onExit = finally([=, this] {
4290 #else
4291 auto onExit = finally([=] {
4292 #endif
4293 ✗ exitRule();
4294 ✗ });
4295 try {
4296 size_t alt;
4297 ✗ enterOuterAlt(_localctx, 1);
4298 ✗ setState(536);
4299 ✗ _errHandler->sync(this);
4300
4301 ✗ _la = _input->LA(1);
4302 ✗ if (_la == modelicaParser::T__48) {
4303 ✗ setState(535);
4304 ✗ match(modelicaParser::T__48);
4305 }
4306 ✗ setState(538);
4307 ✗ match(modelicaParser::T__49);
4308 ✗ setState(542);
4309 ✗ _errHandler->sync(this);
4310 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx);
4311 ✗ while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
4312 ✗ if (alt == 1) {
4313 ✗ setState(539);
4314 ✗ equation();
4315 }
4316 ✗ setState(544);
4317 ✗ _errHandler->sync(this);
4318 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx);
4319 }
4320
4321 ✗ } catch (RecognitionException& e) {
4322 ✗ _errHandler->reportError(this, e);
4323 ✗ _localctx->exception = std::current_exception();
4324 ✗ _errHandler->recover(this, _localctx->exception);
4325 ✗ }
4326
4327 ✗ return _localctx;
4328 ✗ }
4329
4330 //----------------- Algorithm_sectionContext ------------------------------------------------------------------
4331
4332 ✗ modelicaParser::Algorithm_sectionContext::Algorithm_sectionContext(ParserRuleContext* parent, size_t invokingState)
4333 ✗ : ParserRuleContext(parent, invokingState) {}
4334
4335 ✗ std::vector<modelicaParser::StatementContext*> modelicaParser::Algorithm_sectionContext::statement() {
4336 ✗ return getRuleContexts<modelicaParser::StatementContext>();
4337 }
4338
4339 ✗ modelicaParser::StatementContext* modelicaParser::Algorithm_sectionContext::statement(size_t i) {
4340 ✗ return getRuleContext<modelicaParser::StatementContext>(i);
4341 }
4342
4343 ✗ size_t modelicaParser::Algorithm_sectionContext::getRuleIndex() const {
4344 ✗ return modelicaParser::RuleAlgorithm_section;
4345 }
4346
4347 ✗ void modelicaParser::Algorithm_sectionContext::enterRule(tree::ParseTreeListener* listener) {
4348 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4349 ✗ if (parserListener != nullptr) parserListener->enterAlgorithm_section(this);
4350 ✗ }
4351
4352 ✗ void modelicaParser::Algorithm_sectionContext::exitRule(tree::ParseTreeListener* listener) {
4353 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4354 ✗ if (parserListener != nullptr) parserListener->exitAlgorithm_section(this);
4355 ✗ }
4356
4357 ✗ std::any modelicaParser::Algorithm_sectionContext::accept(tree::ParseTreeVisitor* visitor) {
4358 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
4359 ✗ return parserVisitor->visitAlgorithm_section(this);
4360 else
4361 ✗ return visitor->visitChildren(this);
4362 }
4363
4364 ✗ modelicaParser::Algorithm_sectionContext* modelicaParser::algorithm_section() {
4365 ✗ Algorithm_sectionContext* _localctx = _tracker.createInstance<Algorithm_sectionContext>(_ctx, getState());
4366 ✗ enterRule(_localctx, 78, modelicaParser::RuleAlgorithm_section);
4367 ✗ size_t _la = 0;
4368
4369 #if __cplusplus > 201703L
4370 ✗ auto onExit = finally([=, this] {
4371 #else
4372 auto onExit = finally([=] {
4373 #endif
4374 ✗ exitRule();
4375 ✗ });
4376 try {
4377 ✗ enterOuterAlt(_localctx, 1);
4378 ✗ setState(546);
4379 ✗ _errHandler->sync(this);
4380
4381 ✗ _la = _input->LA(1);
4382 ✗ if (_la == modelicaParser::T__48) {
4383 ✗ setState(545);
4384 ✗ match(modelicaParser::T__48);
4385 }
4386 ✗ setState(548);
4387 ✗ match(modelicaParser::T__50);
4388 ✗ setState(554);
4389 ✗ _errHandler->sync(this);
4390 ✗ _la = _input->LA(1);
4391 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 3616460869526880256) != 0) || _la == modelicaParser::T__86
4392
4393 ✗ || _la == modelicaParser::IDENT) {
4394 ✗ setState(549);
4395 ✗ statement();
4396 ✗ setState(550);
4397 ✗ match(modelicaParser::T__1);
4398 ✗ setState(556);
4399 ✗ _errHandler->sync(this);
4400 ✗ _la = _input->LA(1);
4401 }
4402
4403 ✗ } catch (RecognitionException& e) {
4404 ✗ _errHandler->reportError(this, e);
4405 ✗ _localctx->exception = std::current_exception();
4406 ✗ _errHandler->recover(this, _localctx->exception);
4407 ✗ }
4408
4409 ✗ return _localctx;
4410 ✗ }
4411
4412 //----------------- EquationContext ------------------------------------------------------------------
4413
4414 ✗ modelicaParser::EquationContext::EquationContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
4415
4416 ✗ modelicaParser::CommentContext* modelicaParser::EquationContext::comment() {
4417 ✗ return getRuleContext<modelicaParser::CommentContext>(0);
4418 }
4419
4420 ✗ modelicaParser::Simple_expressionContext* modelicaParser::EquationContext::simple_expression() {
4421 ✗ return getRuleContext<modelicaParser::Simple_expressionContext>(0);
4422 }
4423
4424 ✗ modelicaParser::ExpressionContext* modelicaParser::EquationContext::expression() {
4425 ✗ return getRuleContext<modelicaParser::ExpressionContext>(0);
4426 }
4427
4428 ✗ modelicaParser::If_equationContext* modelicaParser::EquationContext::if_equation() {
4429 ✗ return getRuleContext<modelicaParser::If_equationContext>(0);
4430 }
4431
4432 ✗ modelicaParser::For_equationContext* modelicaParser::EquationContext::for_equation() {
4433 ✗ return getRuleContext<modelicaParser::For_equationContext>(0);
4434 }
4435
4436 ✗ modelicaParser::Connect_clauseContext* modelicaParser::EquationContext::connect_clause() {
4437 ✗ return getRuleContext<modelicaParser::Connect_clauseContext>(0);
4438 }
4439
4440 ✗ modelicaParser::When_equationContext* modelicaParser::EquationContext::when_equation() {
4441 ✗ return getRuleContext<modelicaParser::When_equationContext>(0);
4442 }
4443
4444 ✗ modelicaParser::NameContext* modelicaParser::EquationContext::name() {
4445 ✗ return getRuleContext<modelicaParser::NameContext>(0);
4446 }
4447
4448 ✗ modelicaParser::Function_call_argsContext* modelicaParser::EquationContext::function_call_args() {
4449 ✗ return getRuleContext<modelicaParser::Function_call_argsContext>(0);
4450 }
4451
4452 ✗ size_t modelicaParser::EquationContext::getRuleIndex() const {
4453 ✗ return modelicaParser::RuleEquation;
4454 }
4455
4456 ✗ void modelicaParser::EquationContext::enterRule(tree::ParseTreeListener* listener) {
4457 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4458 ✗ if (parserListener != nullptr) parserListener->enterEquation(this);
4459 ✗ }
4460
4461 ✗ void modelicaParser::EquationContext::exitRule(tree::ParseTreeListener* listener) {
4462 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4463 ✗ if (parserListener != nullptr) parserListener->exitEquation(this);
4464 ✗ }
4465
4466 ✗ std::any modelicaParser::EquationContext::accept(tree::ParseTreeVisitor* visitor) {
4467 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
4468 ✗ return parserVisitor->visitEquation(this);
4469 else
4470 ✗ return visitor->visitChildren(this);
4471 }
4472
4473 ✗ modelicaParser::EquationContext* modelicaParser::equation() {
4474 ✗ EquationContext* _localctx = _tracker.createInstance<EquationContext>(_ctx, getState());
4475 ✗ enterRule(_localctx, 80, modelicaParser::RuleEquation);
4476
4477 #if __cplusplus > 201703L
4478 ✗ auto onExit = finally([=, this] {
4479 #else
4480 auto onExit = finally([=] {
4481 #endif
4482 ✗ exitRule();
4483 ✗ });
4484 try {
4485 ✗ enterOuterAlt(_localctx, 1);
4486 ✗ setState(568);
4487 ✗ _errHandler->sync(this);
4488 ✗ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 72, _ctx)) {
4489 ✗ case 1: {
4490 ✗ setState(557);
4491 ✗ simple_expression();
4492 ✗ setState(558);
4493 ✗ match(modelicaParser::T__19);
4494 ✗ setState(559);
4495 ✗ expression();
4496 ✗ break;
4497 }
4498
4499 ✗ case 2: {
4500 ✗ setState(561);
4501 ✗ if_equation();
4502 ✗ break;
4503 }
4504
4505 ✗ case 3: {
4506 ✗ setState(562);
4507 ✗ for_equation();
4508 ✗ break;
4509 }
4510
4511 ✗ case 4: {
4512 ✗ setState(563);
4513 ✗ connect_clause();
4514 ✗ break;
4515 }
4516
4517 ✗ case 5: {
4518 ✗ setState(564);
4519 ✗ when_equation();
4520 ✗ break;
4521 }
4522
4523 ✗ case 6: {
4524 ✗ setState(565);
4525 ✗ name();
4526 ✗ setState(566);
4527 ✗ function_call_args();
4528 ✗ break;
4529 }
4530
4531 ✗ default:
4532 ✗ break;
4533 }
4534 ✗ setState(570);
4535 ✗ comment();
4536 ✗ setState(571);
4537 ✗ match(modelicaParser::T__1);
4538
4539 ✗ } catch (RecognitionException& e) {
4540 ✗ _errHandler->reportError(this, e);
4541 ✗ _localctx->exception = std::current_exception();
4542 ✗ _errHandler->recover(this, _localctx->exception);
4543 ✗ }
4544
4545 ✗ return _localctx;
4546 ✗ }
4547
4548 //----------------- StatementContext ------------------------------------------------------------------
4549
4550 ✗ modelicaParser::StatementContext::StatementContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
4551
4552 ✗ modelicaParser::CommentContext* modelicaParser::StatementContext::comment() {
4553 ✗ return getRuleContext<modelicaParser::CommentContext>(0);
4554 }
4555
4556 ✗ modelicaParser::Component_referenceContext* modelicaParser::StatementContext::component_reference() {
4557 ✗ return getRuleContext<modelicaParser::Component_referenceContext>(0);
4558 }
4559
4560 ✗ modelicaParser::Output_expression_listContext* modelicaParser::StatementContext::output_expression_list() {
4561 ✗ return getRuleContext<modelicaParser::Output_expression_listContext>(0);
4562 }
4563
4564 ✗ modelicaParser::Function_call_argsContext* modelicaParser::StatementContext::function_call_args() {
4565 ✗ return getRuleContext<modelicaParser::Function_call_argsContext>(0);
4566 }
4567
4568 ✗ modelicaParser::If_statementContext* modelicaParser::StatementContext::if_statement() {
4569 ✗ return getRuleContext<modelicaParser::If_statementContext>(0);
4570 }
4571
4572 ✗ modelicaParser::For_statementContext* modelicaParser::StatementContext::for_statement() {
4573 ✗ return getRuleContext<modelicaParser::For_statementContext>(0);
4574 }
4575
4576 ✗ modelicaParser::While_statementContext* modelicaParser::StatementContext::while_statement() {
4577 ✗ return getRuleContext<modelicaParser::While_statementContext>(0);
4578 }
4579
4580 ✗ modelicaParser::When_statementContext* modelicaParser::StatementContext::when_statement() {
4581 ✗ return getRuleContext<modelicaParser::When_statementContext>(0);
4582 }
4583
4584 ✗ modelicaParser::ExpressionContext* modelicaParser::StatementContext::expression() {
4585 ✗ return getRuleContext<modelicaParser::ExpressionContext>(0);
4586 }
4587
4588 ✗ size_t modelicaParser::StatementContext::getRuleIndex() const {
4589 ✗ return modelicaParser::RuleStatement;
4590 }
4591
4592 ✗ void modelicaParser::StatementContext::enterRule(tree::ParseTreeListener* listener) {
4593 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4594 ✗ if (parserListener != nullptr) parserListener->enterStatement(this);
4595 ✗ }
4596
4597 ✗ void modelicaParser::StatementContext::exitRule(tree::ParseTreeListener* listener) {
4598 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4599 ✗ if (parserListener != nullptr) parserListener->exitStatement(this);
4600 ✗ }
4601
4602 ✗ std::any modelicaParser::StatementContext::accept(tree::ParseTreeVisitor* visitor) {
4603 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
4604 ✗ return parserVisitor->visitStatement(this);
4605 else
4606 ✗ return visitor->visitChildren(this);
4607 }
4608
4609 ✗ modelicaParser::StatementContext* modelicaParser::statement() {
4610 ✗ StatementContext* _localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
4611 ✗ enterRule(_localctx, 82, modelicaParser::RuleStatement);
4612
4613 #if __cplusplus > 201703L
4614 ✗ auto onExit = finally([=, this] {
4615 #else
4616 auto onExit = finally([=] {
4617 #endif
4618 ✗ exitRule();
4619 ✗ });
4620 try {
4621 ✗ enterOuterAlt(_localctx, 1);
4622 ✗ setState(592);
4623 ✗ _errHandler->sync(this);
4624 ✗ switch (_input->LA(1)) {
4625 ✗ case modelicaParser::T__86:
4626 case modelicaParser::IDENT: {
4627 ✗ setState(573);
4628 ✗ component_reference();
4629 ✗ setState(577);
4630 ✗ _errHandler->sync(this);
4631 ✗ switch (_input->LA(1)) {
4632 ✗ case modelicaParser::T__46: {
4633 ✗ setState(574);
4634 ✗ match(modelicaParser::T__46);
4635 ✗ setState(575);
4636 ✗ expression();
4637 ✗ break;
4638 }
4639
4640 ✗ case modelicaParser::T__21: {
4641 ✗ setState(576);
4642 ✗ function_call_args();
4643 ✗ break;
4644 }
4645
4646 ✗ default:
4647 ✗ throw NoViableAltException(this);
4648 }
4649 ✗ break;
4650 }
4651
4652 ✗ case modelicaParser::T__21: {
4653 ✗ setState(579);
4654 ✗ match(modelicaParser::T__21);
4655 ✗ setState(580);
4656 ✗ output_expression_list();
4657 ✗ setState(581);
4658 ✗ match(modelicaParser::T__23);
4659 ✗ setState(582);
4660 ✗ match(modelicaParser::T__46);
4661 ✗ setState(583);
4662 ✗ component_reference();
4663 ✗ setState(584);
4664 ✗ function_call_args();
4665 ✗ break;
4666 }
4667
4668 ✗ case modelicaParser::T__51: {
4669 ✗ setState(586);
4670 ✗ match(modelicaParser::T__51);
4671 ✗ break;
4672 }
4673
4674 ✗ case modelicaParser::T__52: {
4675 ✗ setState(587);
4676 ✗ match(modelicaParser::T__52);
4677 ✗ break;
4678 }
4679
4680 ✗ case modelicaParser::T__45: {
4681 ✗ setState(588);
4682 ✗ if_statement();
4683 ✗ break;
4684 }
4685
4686 ✗ case modelicaParser::T__56: {
4687 ✗ setState(589);
4688 ✗ for_statement();
4689 ✗ break;
4690 }
4691
4692 ✗ case modelicaParser::T__59: {
4693 ✗ setState(590);
4694 ✗ while_statement();
4695 ✗ break;
4696 }
4697
4698 ✗ case modelicaParser::T__60: {
4699 ✗ setState(591);
4700 ✗ when_statement();
4701 ✗ break;
4702 }
4703
4704 ✗ default:
4705 ✗ throw NoViableAltException(this);
4706 }
4707 ✗ setState(594);
4708 ✗ comment();
4709
4710 ✗ } catch (RecognitionException& e) {
4711 ✗ _errHandler->reportError(this, e);
4712 ✗ _localctx->exception = std::current_exception();
4713 ✗ _errHandler->recover(this, _localctx->exception);
4714 ✗ }
4715
4716 ✗ return _localctx;
4717 ✗ }
4718
4719 //----------------- If_equationContext ------------------------------------------------------------------
4720
4721 ✗ modelicaParser::If_equationContext::If_equationContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
4722
4723 ✗ std::vector<modelicaParser::ExpressionContext*> modelicaParser::If_equationContext::expression() {
4724 ✗ return getRuleContexts<modelicaParser::ExpressionContext>();
4725 }
4726
4727 ✗ modelicaParser::ExpressionContext* modelicaParser::If_equationContext::expression(size_t i) {
4728 ✗ return getRuleContext<modelicaParser::ExpressionContext>(i);
4729 }
4730
4731 ✗ std::vector<modelicaParser::EquationContext*> modelicaParser::If_equationContext::equation() {
4732 ✗ return getRuleContexts<modelicaParser::EquationContext>();
4733 }
4734
4735 ✗ modelicaParser::EquationContext* modelicaParser::If_equationContext::equation(size_t i) {
4736 ✗ return getRuleContext<modelicaParser::EquationContext>(i);
4737 }
4738
4739 ✗ size_t modelicaParser::If_equationContext::getRuleIndex() const {
4740 ✗ return modelicaParser::RuleIf_equation;
4741 }
4742
4743 ✗ void modelicaParser::If_equationContext::enterRule(tree::ParseTreeListener* listener) {
4744 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4745 ✗ if (parserListener != nullptr) parserListener->enterIf_equation(this);
4746 ✗ }
4747
4748 ✗ void modelicaParser::If_equationContext::exitRule(tree::ParseTreeListener* listener) {
4749 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4750 ✗ if (parserListener != nullptr) parserListener->exitIf_equation(this);
4751 ✗ }
4752
4753 ✗ std::any modelicaParser::If_equationContext::accept(tree::ParseTreeVisitor* visitor) {
4754 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
4755 ✗ return parserVisitor->visitIf_equation(this);
4756 else
4757 ✗ return visitor->visitChildren(this);
4758 }
4759
4760 ✗ modelicaParser::If_equationContext* modelicaParser::if_equation() {
4761 ✗ If_equationContext* _localctx = _tracker.createInstance<If_equationContext>(_ctx, getState());
4762 ✗ enterRule(_localctx, 84, modelicaParser::RuleIf_equation);
4763 ✗ size_t _la = 0;
4764
4765 #if __cplusplus > 201703L
4766 ✗ auto onExit = finally([=, this] {
4767 #else
4768 auto onExit = finally([=] {
4769 #endif
4770 ✗ exitRule();
4771 ✗ });
4772 try {
4773 size_t alt;
4774 ✗ enterOuterAlt(_localctx, 1);
4775 ✗ setState(596);
4776 ✗ match(modelicaParser::T__45);
4777 ✗ setState(597);
4778 ✗ expression();
4779 ✗ setState(598);
4780 ✗ match(modelicaParser::T__53);
4781 ✗ setState(602);
4782 ✗ _errHandler->sync(this);
4783 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 75, _ctx);
4784 ✗ while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
4785 ✗ if (alt == 1) {
4786 ✗ setState(599);
4787 ✗ equation();
4788 }
4789 ✗ setState(604);
4790 ✗ _errHandler->sync(this);
4791 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 75, _ctx);
4792 }
4793 ✗ setState(616);
4794 ✗ _errHandler->sync(this);
4795 ✗ _la = _input->LA(1);
4796 ✗ while (_la == modelicaParser::T__54) {
4797 ✗ setState(605);
4798 ✗ match(modelicaParser::T__54);
4799 ✗ setState(606);
4800 ✗ expression();
4801 ✗ setState(607);
4802 ✗ match(modelicaParser::T__53);
4803 ✗ setState(611);
4804 ✗ _errHandler->sync(this);
4805 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 76, _ctx);
4806 ✗ while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
4807 ✗ if (alt == 1) {
4808 ✗ setState(608);
4809 ✗ equation();
4810 }
4811 ✗ setState(613);
4812 ✗ _errHandler->sync(this);
4813 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 76, _ctx);
4814 }
4815 ✗ setState(618);
4816 ✗ _errHandler->sync(this);
4817 ✗ _la = _input->LA(1);
4818 }
4819 ✗ setState(626);
4820 ✗ _errHandler->sync(this);
4821
4822 ✗ _la = _input->LA(1);
4823 ✗ if (_la == modelicaParser::T__55) {
4824 ✗ setState(619);
4825 ✗ match(modelicaParser::T__55);
4826 ✗ setState(623);
4827 ✗ _errHandler->sync(this);
4828 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 78, _ctx);
4829 ✗ while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
4830 ✗ if (alt == 1) {
4831 ✗ setState(620);
4832 ✗ equation();
4833 }
4834 ✗ setState(625);
4835 ✗ _errHandler->sync(this);
4836 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 78, _ctx);
4837 }
4838 }
4839 ✗ setState(628);
4840 ✗ match(modelicaParser::T__17);
4841 ✗ setState(629);
4842 ✗ match(modelicaParser::T__45);
4843
4844 ✗ } catch (RecognitionException& e) {
4845 ✗ _errHandler->reportError(this, e);
4846 ✗ _localctx->exception = std::current_exception();
4847 ✗ _errHandler->recover(this, _localctx->exception);
4848 ✗ }
4849
4850 ✗ return _localctx;
4851 ✗ }
4852
4853 //----------------- If_statementContext ------------------------------------------------------------------
4854
4855 ✗ modelicaParser::If_statementContext::If_statementContext(ParserRuleContext* parent, size_t invokingState)
4856 ✗ : ParserRuleContext(parent, invokingState) {}
4857
4858 ✗ std::vector<modelicaParser::ExpressionContext*> modelicaParser::If_statementContext::expression() {
4859 ✗ return getRuleContexts<modelicaParser::ExpressionContext>();
4860 }
4861
4862 ✗ modelicaParser::ExpressionContext* modelicaParser::If_statementContext::expression(size_t i) {
4863 ✗ return getRuleContext<modelicaParser::ExpressionContext>(i);
4864 }
4865
4866 ✗ std::vector<modelicaParser::StatementContext*> modelicaParser::If_statementContext::statement() {
4867 ✗ return getRuleContexts<modelicaParser::StatementContext>();
4868 }
4869
4870 ✗ modelicaParser::StatementContext* modelicaParser::If_statementContext::statement(size_t i) {
4871 ✗ return getRuleContext<modelicaParser::StatementContext>(i);
4872 }
4873
4874 ✗ size_t modelicaParser::If_statementContext::getRuleIndex() const {
4875 ✗ return modelicaParser::RuleIf_statement;
4876 }
4877
4878 ✗ void modelicaParser::If_statementContext::enterRule(tree::ParseTreeListener* listener) {
4879 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4880 ✗ if (parserListener != nullptr) parserListener->enterIf_statement(this);
4881 ✗ }
4882
4883 ✗ void modelicaParser::If_statementContext::exitRule(tree::ParseTreeListener* listener) {
4884 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
4885 ✗ if (parserListener != nullptr) parserListener->exitIf_statement(this);
4886 ✗ }
4887
4888 ✗ std::any modelicaParser::If_statementContext::accept(tree::ParseTreeVisitor* visitor) {
4889 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
4890 ✗ return parserVisitor->visitIf_statement(this);
4891 else
4892 ✗ return visitor->visitChildren(this);
4893 }
4894
4895 ✗ modelicaParser::If_statementContext* modelicaParser::if_statement() {
4896 ✗ If_statementContext* _localctx = _tracker.createInstance<If_statementContext>(_ctx, getState());
4897 ✗ enterRule(_localctx, 86, modelicaParser::RuleIf_statement);
4898 ✗ size_t _la = 0;
4899
4900 #if __cplusplus > 201703L
4901 ✗ auto onExit = finally([=, this] {
4902 #else
4903 auto onExit = finally([=] {
4904 #endif
4905 ✗ exitRule();
4906 ✗ });
4907 try {
4908 ✗ enterOuterAlt(_localctx, 1);
4909 ✗ setState(631);
4910 ✗ match(modelicaParser::T__45);
4911 ✗ setState(632);
4912 ✗ expression();
4913 ✗ setState(633);
4914 ✗ match(modelicaParser::T__53);
4915 ✗ setState(639);
4916 ✗ _errHandler->sync(this);
4917 ✗ _la = _input->LA(1);
4918 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 3616460869526880256) != 0) || _la == modelicaParser::T__86
4919
4920 ✗ || _la == modelicaParser::IDENT) {
4921 ✗ setState(634);
4922 ✗ statement();
4923 ✗ setState(635);
4924 ✗ match(modelicaParser::T__1);
4925 ✗ setState(641);
4926 ✗ _errHandler->sync(this);
4927 ✗ _la = _input->LA(1);
4928 }
4929 ✗ setState(655);
4930 ✗ _errHandler->sync(this);
4931 ✗ _la = _input->LA(1);
4932 ✗ while (_la == modelicaParser::T__54) {
4933 ✗ setState(642);
4934 ✗ match(modelicaParser::T__54);
4935 ✗ setState(643);
4936 ✗ expression();
4937 ✗ setState(644);
4938 ✗ match(modelicaParser::T__53);
4939 ✗ setState(650);
4940 ✗ _errHandler->sync(this);
4941 ✗ _la = _input->LA(1);
4942 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 3616460869526880256) != 0) || _la == modelicaParser::T__86
4943
4944 ✗ || _la == modelicaParser::IDENT) {
4945 ✗ setState(645);
4946 ✗ statement();
4947 ✗ setState(646);
4948 ✗ match(modelicaParser::T__1);
4949 ✗ setState(652);
4950 ✗ _errHandler->sync(this);
4951 ✗ _la = _input->LA(1);
4952 }
4953 ✗ setState(657);
4954 ✗ _errHandler->sync(this);
4955 ✗ _la = _input->LA(1);
4956 }
4957 ✗ setState(667);
4958 ✗ _errHandler->sync(this);
4959
4960 ✗ _la = _input->LA(1);
4961 ✗ if (_la == modelicaParser::T__55) {
4962 ✗ setState(658);
4963 ✗ match(modelicaParser::T__55);
4964 ✗ setState(664);
4965 ✗ _errHandler->sync(this);
4966 ✗ _la = _input->LA(1);
4967 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 3616460869526880256) != 0) || _la == modelicaParser::T__86
4968
4969 ✗ || _la == modelicaParser::IDENT) {
4970 ✗ setState(659);
4971 ✗ statement();
4972 ✗ setState(660);
4973 ✗ match(modelicaParser::T__1);
4974 ✗ setState(666);
4975 ✗ _errHandler->sync(this);
4976 ✗ _la = _input->LA(1);
4977 }
4978 }
4979 ✗ setState(669);
4980 ✗ match(modelicaParser::T__17);
4981 ✗ setState(670);
4982 ✗ match(modelicaParser::T__45);
4983
4984 ✗ } catch (RecognitionException& e) {
4985 ✗ _errHandler->reportError(this, e);
4986 ✗ _localctx->exception = std::current_exception();
4987 ✗ _errHandler->recover(this, _localctx->exception);
4988 ✗ }
4989
4990 ✗ return _localctx;
4991 ✗ }
4992
4993 //----------------- For_equationContext ------------------------------------------------------------------
4994
4995 ✗ modelicaParser::For_equationContext::For_equationContext(ParserRuleContext* parent, size_t invokingState)
4996 ✗ : ParserRuleContext(parent, invokingState) {}
4997
4998 ✗ modelicaParser::For_indicesContext* modelicaParser::For_equationContext::for_indices() {
4999 ✗ return getRuleContext<modelicaParser::For_indicesContext>(0);
5000 }
5001
5002 ✗ std::vector<modelicaParser::EquationContext*> modelicaParser::For_equationContext::equation() {
5003 ✗ return getRuleContexts<modelicaParser::EquationContext>();
5004 }
5005
5006 ✗ modelicaParser::EquationContext* modelicaParser::For_equationContext::equation(size_t i) {
5007 ✗ return getRuleContext<modelicaParser::EquationContext>(i);
5008 }
5009
5010 ✗ size_t modelicaParser::For_equationContext::getRuleIndex() const {
5011 ✗ return modelicaParser::RuleFor_equation;
5012 }
5013
5014 ✗ void modelicaParser::For_equationContext::enterRule(tree::ParseTreeListener* listener) {
5015 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5016 ✗ if (parserListener != nullptr) parserListener->enterFor_equation(this);
5017 ✗ }
5018
5019 ✗ void modelicaParser::For_equationContext::exitRule(tree::ParseTreeListener* listener) {
5020 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5021 ✗ if (parserListener != nullptr) parserListener->exitFor_equation(this);
5022 ✗ }
5023
5024 ✗ std::any modelicaParser::For_equationContext::accept(tree::ParseTreeVisitor* visitor) {
5025 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5026 ✗ return parserVisitor->visitFor_equation(this);
5027 else
5028 ✗ return visitor->visitChildren(this);
5029 }
5030
5031 ✗ modelicaParser::For_equationContext* modelicaParser::for_equation() {
5032 ✗ For_equationContext* _localctx = _tracker.createInstance<For_equationContext>(_ctx, getState());
5033 ✗ enterRule(_localctx, 88, modelicaParser::RuleFor_equation);
5034
5035 #if __cplusplus > 201703L
5036 ✗ auto onExit = finally([=, this] {
5037 #else
5038 auto onExit = finally([=] {
5039 #endif
5040 ✗ exitRule();
5041 ✗ });
5042 try {
5043 size_t alt;
5044 ✗ enterOuterAlt(_localctx, 1);
5045 ✗ setState(672);
5046 ✗ match(modelicaParser::T__56);
5047 ✗ setState(673);
5048 ✗ for_indices();
5049 ✗ setState(674);
5050 ✗ match(modelicaParser::T__57);
5051 ✗ setState(678);
5052 ✗ _errHandler->sync(this);
5053 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx);
5054 ✗ while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
5055 ✗ if (alt == 1) {
5056 ✗ setState(675);
5057 ✗ equation();
5058 }
5059 ✗ setState(680);
5060 ✗ _errHandler->sync(this);
5061 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx);
5062 }
5063 ✗ setState(681);
5064 ✗ match(modelicaParser::T__17);
5065 ✗ setState(682);
5066 ✗ match(modelicaParser::T__56);
5067
5068 ✗ } catch (RecognitionException& e) {
5069 ✗ _errHandler->reportError(this, e);
5070 ✗ _localctx->exception = std::current_exception();
5071 ✗ _errHandler->recover(this, _localctx->exception);
5072 ✗ }
5073
5074 ✗ return _localctx;
5075 ✗ }
5076
5077 //----------------- For_statementContext ------------------------------------------------------------------
5078
5079 ✗ modelicaParser::For_statementContext::For_statementContext(ParserRuleContext* parent, size_t invokingState)
5080 ✗ : ParserRuleContext(parent, invokingState) {}
5081
5082 ✗ modelicaParser::For_indicesContext* modelicaParser::For_statementContext::for_indices() {
5083 ✗ return getRuleContext<modelicaParser::For_indicesContext>(0);
5084 }
5085
5086 ✗ std::vector<modelicaParser::StatementContext*> modelicaParser::For_statementContext::statement() {
5087 ✗ return getRuleContexts<modelicaParser::StatementContext>();
5088 }
5089
5090 ✗ modelicaParser::StatementContext* modelicaParser::For_statementContext::statement(size_t i) {
5091 ✗ return getRuleContext<modelicaParser::StatementContext>(i);
5092 }
5093
5094 ✗ size_t modelicaParser::For_statementContext::getRuleIndex() const {
5095 ✗ return modelicaParser::RuleFor_statement;
5096 }
5097
5098 ✗ void modelicaParser::For_statementContext::enterRule(tree::ParseTreeListener* listener) {
5099 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5100 ✗ if (parserListener != nullptr) parserListener->enterFor_statement(this);
5101 ✗ }
5102
5103 ✗ void modelicaParser::For_statementContext::exitRule(tree::ParseTreeListener* listener) {
5104 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5105 ✗ if (parserListener != nullptr) parserListener->exitFor_statement(this);
5106 ✗ }
5107
5108 ✗ std::any modelicaParser::For_statementContext::accept(tree::ParseTreeVisitor* visitor) {
5109 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5110 ✗ return parserVisitor->visitFor_statement(this);
5111 else
5112 ✗ return visitor->visitChildren(this);
5113 }
5114
5115 ✗ modelicaParser::For_statementContext* modelicaParser::for_statement() {
5116 ✗ For_statementContext* _localctx = _tracker.createInstance<For_statementContext>(_ctx, getState());
5117 ✗ enterRule(_localctx, 90, modelicaParser::RuleFor_statement);
5118 ✗ size_t _la = 0;
5119
5120 #if __cplusplus > 201703L
5121 ✗ auto onExit = finally([=, this] {
5122 #else
5123 auto onExit = finally([=] {
5124 #endif
5125 ✗ exitRule();
5126 ✗ });
5127 try {
5128 ✗ enterOuterAlt(_localctx, 1);
5129 ✗ setState(684);
5130 ✗ match(modelicaParser::T__56);
5131 ✗ setState(685);
5132 ✗ for_indices();
5133 ✗ setState(686);
5134 ✗ match(modelicaParser::T__57);
5135 ✗ setState(692);
5136 ✗ _errHandler->sync(this);
5137 ✗ _la = _input->LA(1);
5138 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 3616460869526880256) != 0) || _la == modelicaParser::T__86
5139
5140 ✗ || _la == modelicaParser::IDENT) {
5141 ✗ setState(687);
5142 ✗ statement();
5143 ✗ setState(688);
5144 ✗ match(modelicaParser::T__1);
5145 ✗ setState(694);
5146 ✗ _errHandler->sync(this);
5147 ✗ _la = _input->LA(1);
5148 }
5149 ✗ setState(695);
5150 ✗ match(modelicaParser::T__17);
5151 ✗ setState(696);
5152 ✗ match(modelicaParser::T__56);
5153
5154 ✗ } catch (RecognitionException& e) {
5155 ✗ _errHandler->reportError(this, e);
5156 ✗ _localctx->exception = std::current_exception();
5157 ✗ _errHandler->recover(this, _localctx->exception);
5158 ✗ }
5159
5160 ✗ return _localctx;
5161 ✗ }
5162
5163 //----------------- For_indicesContext ------------------------------------------------------------------
5164
5165 ✗ modelicaParser::For_indicesContext::For_indicesContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
5166
5167 ✗ std::vector<modelicaParser::For_indexContext*> modelicaParser::For_indicesContext::for_index() {
5168 ✗ return getRuleContexts<modelicaParser::For_indexContext>();
5169 }
5170
5171 ✗ modelicaParser::For_indexContext* modelicaParser::For_indicesContext::for_index(size_t i) {
5172 ✗ return getRuleContext<modelicaParser::For_indexContext>(i);
5173 }
5174
5175 ✗ size_t modelicaParser::For_indicesContext::getRuleIndex() const {
5176 ✗ return modelicaParser::RuleFor_indices;
5177 }
5178
5179 ✗ void modelicaParser::For_indicesContext::enterRule(tree::ParseTreeListener* listener) {
5180 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5181 ✗ if (parserListener != nullptr) parserListener->enterFor_indices(this);
5182 ✗ }
5183
5184 ✗ void modelicaParser::For_indicesContext::exitRule(tree::ParseTreeListener* listener) {
5185 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5186 ✗ if (parserListener != nullptr) parserListener->exitFor_indices(this);
5187 ✗ }
5188
5189 ✗ std::any modelicaParser::For_indicesContext::accept(tree::ParseTreeVisitor* visitor) {
5190 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5191 ✗ return parserVisitor->visitFor_indices(this);
5192 else
5193 ✗ return visitor->visitChildren(this);
5194 }
5195
5196 ✗ modelicaParser::For_indicesContext* modelicaParser::for_indices() {
5197 ✗ For_indicesContext* _localctx = _tracker.createInstance<For_indicesContext>(_ctx, getState());
5198 ✗ enterRule(_localctx, 92, modelicaParser::RuleFor_indices);
5199 ✗ size_t _la = 0;
5200
5201 #if __cplusplus > 201703L
5202 ✗ auto onExit = finally([=, this] {
5203 #else
5204 auto onExit = finally([=] {
5205 #endif
5206 ✗ exitRule();
5207 ✗ });
5208 try {
5209 ✗ enterOuterAlt(_localctx, 1);
5210 ✗ setState(698);
5211 ✗ for_index();
5212 ✗ setState(703);
5213 ✗ _errHandler->sync(this);
5214 ✗ _la = _input->LA(1);
5215 ✗ while (_la == modelicaParser::T__25) {
5216 ✗ setState(699);
5217 ✗ match(modelicaParser::T__25);
5218 ✗ setState(700);
5219 ✗ for_index();
5220 ✗ setState(705);
5221 ✗ _errHandler->sync(this);
5222 ✗ _la = _input->LA(1);
5223 }
5224
5225 ✗ } catch (RecognitionException& e) {
5226 ✗ _errHandler->reportError(this, e);
5227 ✗ _localctx->exception = std::current_exception();
5228 ✗ _errHandler->recover(this, _localctx->exception);
5229 ✗ }
5230
5231 ✗ return _localctx;
5232 ✗ }
5233
5234 //----------------- For_indexContext ------------------------------------------------------------------
5235
5236 ✗ modelicaParser::For_indexContext::For_indexContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
5237
5238 ✗ tree::TerminalNode* modelicaParser::For_indexContext::IDENT() {
5239 ✗ return getToken(modelicaParser::IDENT, 0);
5240 }
5241
5242 ✗ modelicaParser::ExpressionContext* modelicaParser::For_indexContext::expression() {
5243 ✗ return getRuleContext<modelicaParser::ExpressionContext>(0);
5244 }
5245
5246 ✗ size_t modelicaParser::For_indexContext::getRuleIndex() const {
5247 ✗ return modelicaParser::RuleFor_index;
5248 }
5249
5250 ✗ void modelicaParser::For_indexContext::enterRule(tree::ParseTreeListener* listener) {
5251 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5252 ✗ if (parserListener != nullptr) parserListener->enterFor_index(this);
5253 ✗ }
5254
5255 ✗ void modelicaParser::For_indexContext::exitRule(tree::ParseTreeListener* listener) {
5256 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5257 ✗ if (parserListener != nullptr) parserListener->exitFor_index(this);
5258 ✗ }
5259
5260 ✗ std::any modelicaParser::For_indexContext::accept(tree::ParseTreeVisitor* visitor) {
5261 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5262 ✗ return parserVisitor->visitFor_index(this);
5263 else
5264 ✗ return visitor->visitChildren(this);
5265 }
5266
5267 ✗ modelicaParser::For_indexContext* modelicaParser::for_index() {
5268 ✗ For_indexContext* _localctx = _tracker.createInstance<For_indexContext>(_ctx, getState());
5269 ✗ enterRule(_localctx, 94, modelicaParser::RuleFor_index);
5270 ✗ size_t _la = 0;
5271
5272 #if __cplusplus > 201703L
5273 ✗ auto onExit = finally([=, this] {
5274 #else
5275 auto onExit = finally([=] {
5276 #endif
5277 ✗ exitRule();
5278 ✗ });
5279 try {
5280 ✗ enterOuterAlt(_localctx, 1);
5281 ✗ setState(706);
5282 ✗ match(modelicaParser::IDENT);
5283 ✗ setState(709);
5284 ✗ _errHandler->sync(this);
5285
5286 ✗ _la = _input->LA(1);
5287 ✗ if (_la == modelicaParser::T__58) {
5288 ✗ setState(707);
5289 ✗ match(modelicaParser::T__58);
5290 ✗ setState(708);
5291 ✗ expression();
5292 }
5293
5294 ✗ } catch (RecognitionException& e) {
5295 ✗ _errHandler->reportError(this, e);
5296 ✗ _localctx->exception = std::current_exception();
5297 ✗ _errHandler->recover(this, _localctx->exception);
5298 ✗ }
5299
5300 ✗ return _localctx;
5301 ✗ }
5302
5303 //----------------- While_statementContext ------------------------------------------------------------------
5304
5305 ✗ modelicaParser::While_statementContext::While_statementContext(ParserRuleContext* parent, size_t invokingState)
5306 ✗ : ParserRuleContext(parent, invokingState) {}
5307
5308 ✗ modelicaParser::ExpressionContext* modelicaParser::While_statementContext::expression() {
5309 ✗ return getRuleContext<modelicaParser::ExpressionContext>(0);
5310 }
5311
5312 ✗ std::vector<modelicaParser::StatementContext*> modelicaParser::While_statementContext::statement() {
5313 ✗ return getRuleContexts<modelicaParser::StatementContext>();
5314 }
5315
5316 ✗ modelicaParser::StatementContext* modelicaParser::While_statementContext::statement(size_t i) {
5317 ✗ return getRuleContext<modelicaParser::StatementContext>(i);
5318 }
5319
5320 ✗ size_t modelicaParser::While_statementContext::getRuleIndex() const {
5321 ✗ return modelicaParser::RuleWhile_statement;
5322 }
5323
5324 ✗ void modelicaParser::While_statementContext::enterRule(tree::ParseTreeListener* listener) {
5325 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5326 ✗ if (parserListener != nullptr) parserListener->enterWhile_statement(this);
5327 ✗ }
5328
5329 ✗ void modelicaParser::While_statementContext::exitRule(tree::ParseTreeListener* listener) {
5330 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5331 ✗ if (parserListener != nullptr) parserListener->exitWhile_statement(this);
5332 ✗ }
5333
5334 ✗ std::any modelicaParser::While_statementContext::accept(tree::ParseTreeVisitor* visitor) {
5335 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5336 ✗ return parserVisitor->visitWhile_statement(this);
5337 else
5338 ✗ return visitor->visitChildren(this);
5339 }
5340
5341 ✗ modelicaParser::While_statementContext* modelicaParser::while_statement() {
5342 ✗ While_statementContext* _localctx = _tracker.createInstance<While_statementContext>(_ctx, getState());
5343 ✗ enterRule(_localctx, 96, modelicaParser::RuleWhile_statement);
5344 ✗ size_t _la = 0;
5345
5346 #if __cplusplus > 201703L
5347 ✗ auto onExit = finally([=, this] {
5348 #else
5349 auto onExit = finally([=] {
5350 #endif
5351 ✗ exitRule();
5352 ✗ });
5353 try {
5354 ✗ enterOuterAlt(_localctx, 1);
5355 ✗ setState(711);
5356 ✗ match(modelicaParser::T__59);
5357 ✗ setState(712);
5358 ✗ expression();
5359 ✗ setState(713);
5360 ✗ match(modelicaParser::T__57);
5361 ✗ setState(719);
5362 ✗ _errHandler->sync(this);
5363 ✗ _la = _input->LA(1);
5364 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 3616460869526880256) != 0) || _la == modelicaParser::T__86
5365
5366 ✗ || _la == modelicaParser::IDENT) {
5367 ✗ setState(714);
5368 ✗ statement();
5369 ✗ setState(715);
5370 ✗ match(modelicaParser::T__1);
5371 ✗ setState(721);
5372 ✗ _errHandler->sync(this);
5373 ✗ _la = _input->LA(1);
5374 }
5375 ✗ setState(722);
5376 ✗ match(modelicaParser::T__17);
5377 ✗ setState(723);
5378 ✗ match(modelicaParser::T__59);
5379
5380 ✗ } catch (RecognitionException& e) {
5381 ✗ _errHandler->reportError(this, e);
5382 ✗ _localctx->exception = std::current_exception();
5383 ✗ _errHandler->recover(this, _localctx->exception);
5384 ✗ }
5385
5386 ✗ return _localctx;
5387 ✗ }
5388
5389 //----------------- When_equationContext ------------------------------------------------------------------
5390
5391 ✗ modelicaParser::When_equationContext::When_equationContext(ParserRuleContext* parent, size_t invokingState)
5392 ✗ : ParserRuleContext(parent, invokingState) {}
5393
5394 ✗ std::vector<modelicaParser::ExpressionContext*> modelicaParser::When_equationContext::expression() {
5395 ✗ return getRuleContexts<modelicaParser::ExpressionContext>();
5396 }
5397
5398 ✗ modelicaParser::ExpressionContext* modelicaParser::When_equationContext::expression(size_t i) {
5399 ✗ return getRuleContext<modelicaParser::ExpressionContext>(i);
5400 }
5401
5402 ✗ std::vector<modelicaParser::EquationContext*> modelicaParser::When_equationContext::equation() {
5403 ✗ return getRuleContexts<modelicaParser::EquationContext>();
5404 }
5405
5406 ✗ modelicaParser::EquationContext* modelicaParser::When_equationContext::equation(size_t i) {
5407 ✗ return getRuleContext<modelicaParser::EquationContext>(i);
5408 }
5409
5410 ✗ size_t modelicaParser::When_equationContext::getRuleIndex() const {
5411 ✗ return modelicaParser::RuleWhen_equation;
5412 }
5413
5414 ✗ void modelicaParser::When_equationContext::enterRule(tree::ParseTreeListener* listener) {
5415 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5416 ✗ if (parserListener != nullptr) parserListener->enterWhen_equation(this);
5417 ✗ }
5418
5419 ✗ void modelicaParser::When_equationContext::exitRule(tree::ParseTreeListener* listener) {
5420 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5421 ✗ if (parserListener != nullptr) parserListener->exitWhen_equation(this);
5422 ✗ }
5423
5424 ✗ std::any modelicaParser::When_equationContext::accept(tree::ParseTreeVisitor* visitor) {
5425 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5426 ✗ return parserVisitor->visitWhen_equation(this);
5427 else
5428 ✗ return visitor->visitChildren(this);
5429 }
5430
5431 ✗ modelicaParser::When_equationContext* modelicaParser::when_equation() {
5432 ✗ When_equationContext* _localctx = _tracker.createInstance<When_equationContext>(_ctx, getState());
5433 ✗ enterRule(_localctx, 98, modelicaParser::RuleWhen_equation);
5434 ✗ size_t _la = 0;
5435
5436 #if __cplusplus > 201703L
5437 ✗ auto onExit = finally([=, this] {
5438 #else
5439 auto onExit = finally([=] {
5440 #endif
5441 ✗ exitRule();
5442 ✗ });
5443 try {
5444 size_t alt;
5445 ✗ enterOuterAlt(_localctx, 1);
5446 ✗ setState(725);
5447 ✗ match(modelicaParser::T__60);
5448 ✗ setState(726);
5449 ✗ expression();
5450 ✗ setState(727);
5451 ✗ match(modelicaParser::T__53);
5452 ✗ setState(731);
5453 ✗ _errHandler->sync(this);
5454 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx);
5455 ✗ while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
5456 ✗ if (alt == 1) {
5457 ✗ setState(728);
5458 ✗ equation();
5459 }
5460 ✗ setState(733);
5461 ✗ _errHandler->sync(this);
5462 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx);
5463 }
5464 ✗ setState(745);
5465 ✗ _errHandler->sync(this);
5466 ✗ _la = _input->LA(1);
5467 ✗ while (_la == modelicaParser::T__61) {
5468 ✗ setState(734);
5469 ✗ match(modelicaParser::T__61);
5470 ✗ setState(735);
5471 ✗ expression();
5472 ✗ setState(736);
5473 ✗ match(modelicaParser::T__53);
5474 ✗ setState(740);
5475 ✗ _errHandler->sync(this);
5476 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx);
5477 ✗ while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
5478 ✗ if (alt == 1) {
5479 ✗ setState(737);
5480 ✗ equation();
5481 }
5482 ✗ setState(742);
5483 ✗ _errHandler->sync(this);
5484 ✗ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx);
5485 }
5486 ✗ setState(747);
5487 ✗ _errHandler->sync(this);
5488 ✗ _la = _input->LA(1);
5489 }
5490 ✗ setState(748);
5491 ✗ match(modelicaParser::T__17);
5492 ✗ setState(749);
5493 ✗ match(modelicaParser::T__60);
5494
5495 ✗ } catch (RecognitionException& e) {
5496 ✗ _errHandler->reportError(this, e);
5497 ✗ _localctx->exception = std::current_exception();
5498 ✗ _errHandler->recover(this, _localctx->exception);
5499 ✗ }
5500
5501 ✗ return _localctx;
5502 ✗ }
5503
5504 //----------------- When_statementContext ------------------------------------------------------------------
5505
5506 ✗ modelicaParser::When_statementContext::When_statementContext(ParserRuleContext* parent, size_t invokingState)
5507 ✗ : ParserRuleContext(parent, invokingState) {}
5508
5509 ✗ std::vector<modelicaParser::ExpressionContext*> modelicaParser::When_statementContext::expression() {
5510 ✗ return getRuleContexts<modelicaParser::ExpressionContext>();
5511 }
5512
5513 ✗ modelicaParser::ExpressionContext* modelicaParser::When_statementContext::expression(size_t i) {
5514 ✗ return getRuleContext<modelicaParser::ExpressionContext>(i);
5515 }
5516
5517 ✗ std::vector<modelicaParser::StatementContext*> modelicaParser::When_statementContext::statement() {
5518 ✗ return getRuleContexts<modelicaParser::StatementContext>();
5519 }
5520
5521 ✗ modelicaParser::StatementContext* modelicaParser::When_statementContext::statement(size_t i) {
5522 ✗ return getRuleContext<modelicaParser::StatementContext>(i);
5523 }
5524
5525 ✗ size_t modelicaParser::When_statementContext::getRuleIndex() const {
5526 ✗ return modelicaParser::RuleWhen_statement;
5527 }
5528
5529 ✗ void modelicaParser::When_statementContext::enterRule(tree::ParseTreeListener* listener) {
5530 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5531 ✗ if (parserListener != nullptr) parserListener->enterWhen_statement(this);
5532 ✗ }
5533
5534 ✗ void modelicaParser::When_statementContext::exitRule(tree::ParseTreeListener* listener) {
5535 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5536 ✗ if (parserListener != nullptr) parserListener->exitWhen_statement(this);
5537 ✗ }
5538
5539 ✗ std::any modelicaParser::When_statementContext::accept(tree::ParseTreeVisitor* visitor) {
5540 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5541 ✗ return parserVisitor->visitWhen_statement(this);
5542 else
5543 ✗ return visitor->visitChildren(this);
5544 }
5545
5546 ✗ modelicaParser::When_statementContext* modelicaParser::when_statement() {
5547 ✗ When_statementContext* _localctx = _tracker.createInstance<When_statementContext>(_ctx, getState());
5548 ✗ enterRule(_localctx, 100, modelicaParser::RuleWhen_statement);
5549 ✗ size_t _la = 0;
5550
5551 #if __cplusplus > 201703L
5552 ✗ auto onExit = finally([=, this] {
5553 #else
5554 auto onExit = finally([=] {
5555 #endif
5556 ✗ exitRule();
5557 ✗ });
5558 try {
5559 ✗ enterOuterAlt(_localctx, 1);
5560 ✗ setState(751);
5561 ✗ match(modelicaParser::T__60);
5562 ✗ setState(752);
5563 ✗ expression();
5564 ✗ setState(753);
5565 ✗ match(modelicaParser::T__53);
5566 ✗ setState(759);
5567 ✗ _errHandler->sync(this);
5568 ✗ _la = _input->LA(1);
5569 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 3616460869526880256) != 0) || _la == modelicaParser::T__86
5570
5571 ✗ || _la == modelicaParser::IDENT) {
5572 ✗ setState(754);
5573 ✗ statement();
5574 ✗ setState(755);
5575 ✗ match(modelicaParser::T__1);
5576 ✗ setState(761);
5577 ✗ _errHandler->sync(this);
5578 ✗ _la = _input->LA(1);
5579 }
5580 ✗ setState(775);
5581 ✗ _errHandler->sync(this);
5582 ✗ _la = _input->LA(1);
5583 ✗ while (_la == modelicaParser::T__61) {
5584 ✗ setState(762);
5585 ✗ match(modelicaParser::T__61);
5586 ✗ setState(763);
5587 ✗ expression();
5588 ✗ setState(764);
5589 ✗ match(modelicaParser::T__53);
5590 ✗ setState(770);
5591 ✗ _errHandler->sync(this);
5592 ✗ _la = _input->LA(1);
5593 ✗ while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 3616460869526880256) != 0) || _la == modelicaParser::T__86
5594
5595 ✗ || _la == modelicaParser::IDENT) {
5596 ✗ setState(765);
5597 ✗ statement();
5598 ✗ setState(766);
5599 ✗ match(modelicaParser::T__1);
5600 ✗ setState(772);
5601 ✗ _errHandler->sync(this);
5602 ✗ _la = _input->LA(1);
5603 }
5604 ✗ setState(777);
5605 ✗ _errHandler->sync(this);
5606 ✗ _la = _input->LA(1);
5607 }
5608 ✗ setState(778);
5609 ✗ match(modelicaParser::T__17);
5610 ✗ setState(779);
5611 ✗ match(modelicaParser::T__60);
5612
5613 ✗ } catch (RecognitionException& e) {
5614 ✗ _errHandler->reportError(this, e);
5615 ✗ _localctx->exception = std::current_exception();
5616 ✗ _errHandler->recover(this, _localctx->exception);
5617 ✗ }
5618
5619 ✗ return _localctx;
5620 ✗ }
5621
5622 //----------------- Connect_clauseContext ------------------------------------------------------------------
5623
5624 ✗ modelicaParser::Connect_clauseContext::Connect_clauseContext(ParserRuleContext* parent, size_t invokingState)
5625 ✗ : ParserRuleContext(parent, invokingState) {}
5626
5627 ✗ std::vector<modelicaParser::Component_referenceContext*> modelicaParser::Connect_clauseContext::component_reference() {
5628 ✗ return getRuleContexts<modelicaParser::Component_referenceContext>();
5629 }
5630
5631 ✗ modelicaParser::Component_referenceContext* modelicaParser::Connect_clauseContext::component_reference(size_t i) {
5632 ✗ return getRuleContext<modelicaParser::Component_referenceContext>(i);
5633 }
5634
5635 ✗ size_t modelicaParser::Connect_clauseContext::getRuleIndex() const {
5636 ✗ return modelicaParser::RuleConnect_clause;
5637 }
5638
5639 ✗ void modelicaParser::Connect_clauseContext::enterRule(tree::ParseTreeListener* listener) {
5640 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5641 ✗ if (parserListener != nullptr) parserListener->enterConnect_clause(this);
5642 ✗ }
5643
5644 ✗ void modelicaParser::Connect_clauseContext::exitRule(tree::ParseTreeListener* listener) {
5645 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5646 ✗ if (parserListener != nullptr) parserListener->exitConnect_clause(this);
5647 ✗ }
5648
5649 ✗ std::any modelicaParser::Connect_clauseContext::accept(tree::ParseTreeVisitor* visitor) {
5650 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5651 ✗ return parserVisitor->visitConnect_clause(this);
5652 else
5653 ✗ return visitor->visitChildren(this);
5654 }
5655
5656 ✗ modelicaParser::Connect_clauseContext* modelicaParser::connect_clause() {
5657 ✗ Connect_clauseContext* _localctx = _tracker.createInstance<Connect_clauseContext>(_ctx, getState());
5658 ✗ enterRule(_localctx, 102, modelicaParser::RuleConnect_clause);
5659
5660 #if __cplusplus > 201703L
5661 ✗ auto onExit = finally([=, this] {
5662 #else
5663 auto onExit = finally([=] {
5664 #endif
5665 ✗ exitRule();
5666 ✗ });
5667 try {
5668 ✗ enterOuterAlt(_localctx, 1);
5669 ✗ setState(781);
5670 ✗ match(modelicaParser::T__62);
5671 ✗ setState(782);
5672 ✗ match(modelicaParser::T__21);
5673 ✗ setState(783);
5674 ✗ component_reference();
5675 ✗ setState(784);
5676 ✗ match(modelicaParser::T__25);
5677 ✗ setState(785);
5678 ✗ component_reference();
5679 ✗ setState(786);
5680 ✗ match(modelicaParser::T__23);
5681
5682 ✗ } catch (RecognitionException& e) {
5683 ✗ _errHandler->reportError(this, e);
5684 ✗ _localctx->exception = std::current_exception();
5685 ✗ _errHandler->recover(this, _localctx->exception);
5686 ✗ }
5687
5688 ✗ return _localctx;
5689 ✗ }
5690
5691 //----------------- ExpressionContext ------------------------------------------------------------------
5692
5693 ✗ modelicaParser::ExpressionContext::ExpressionContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
5694
5695 ✗ modelicaParser::Simple_expressionContext* modelicaParser::ExpressionContext::simple_expression() {
5696 ✗ return getRuleContext<modelicaParser::Simple_expressionContext>(0);
5697 }
5698
5699 ✗ std::vector<modelicaParser::ExpressionContext*> modelicaParser::ExpressionContext::expression() {
5700 ✗ return getRuleContexts<modelicaParser::ExpressionContext>();
5701 }
5702
5703 ✗ modelicaParser::ExpressionContext* modelicaParser::ExpressionContext::expression(size_t i) {
5704 ✗ return getRuleContext<modelicaParser::ExpressionContext>(i);
5705 }
5706
5707 ✗ size_t modelicaParser::ExpressionContext::getRuleIndex() const {
5708 ✗ return modelicaParser::RuleExpression;
5709 }
5710
5711 ✗ void modelicaParser::ExpressionContext::enterRule(tree::ParseTreeListener* listener) {
5712 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5713 ✗ if (parserListener != nullptr) parserListener->enterExpression(this);
5714 ✗ }
5715
5716 ✗ void modelicaParser::ExpressionContext::exitRule(tree::ParseTreeListener* listener) {
5717 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5718 ✗ if (parserListener != nullptr) parserListener->exitExpression(this);
5719 ✗ }
5720
5721 ✗ std::any modelicaParser::ExpressionContext::accept(tree::ParseTreeVisitor* visitor) {
5722 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5723 ✗ return parserVisitor->visitExpression(this);
5724 else
5725 ✗ return visitor->visitChildren(this);
5726 }
5727
5728 ✗ modelicaParser::ExpressionContext* modelicaParser::expression() {
5729 ✗ ExpressionContext* _localctx = _tracker.createInstance<ExpressionContext>(_ctx, getState());
5730 ✗ enterRule(_localctx, 104, modelicaParser::RuleExpression);
5731 ✗ size_t _la = 0;
5732
5733 #if __cplusplus > 201703L
5734 ✗ auto onExit = finally([=, this] {
5735 #else
5736 auto onExit = finally([=] {
5737 #endif
5738 ✗ exitRule();
5739 ✗ });
5740 try {
5741 ✗ setState(806);
5742 ✗ _errHandler->sync(this);
5743 ✗ switch (_input->LA(1)) {
5744 ✗ case modelicaParser::T__17:
5745 case modelicaParser::T__21:
5746 case modelicaParser::T__24:
5747 case modelicaParser::T__48:
5748 case modelicaParser::T__65:
5749 case modelicaParser::T__72:
5750 case modelicaParser::T__73:
5751 case modelicaParser::T__74:
5752 case modelicaParser::T__75:
5753 case modelicaParser::T__81:
5754 case modelicaParser::T__82:
5755 case modelicaParser::T__83:
5756 case modelicaParser::T__85:
5757 case modelicaParser::T__86:
5758 case modelicaParser::IDENT:
5759 case modelicaParser::STRING:
5760 case modelicaParser::UNSIGNED_NUMBER: {
5761 ✗ enterOuterAlt(_localctx, 1);
5762 ✗ setState(788);
5763 ✗ simple_expression();
5764 ✗ break;
5765 }
5766
5767 ✗ case modelicaParser::T__45: {
5768 ✗ enterOuterAlt(_localctx, 2);
5769 ✗ setState(789);
5770 ✗ match(modelicaParser::T__45);
5771 ✗ setState(790);
5772 ✗ expression();
5773 ✗ setState(791);
5774 ✗ match(modelicaParser::T__53);
5775 ✗ setState(792);
5776 ✗ expression();
5777 ✗ setState(800);
5778 ✗ _errHandler->sync(this);
5779 ✗ _la = _input->LA(1);
5780 ✗ while (_la == modelicaParser::T__54) {
5781 ✗ setState(793);
5782 ✗ match(modelicaParser::T__54);
5783 ✗ setState(794);
5784 ✗ expression();
5785 ✗ setState(795);
5786 ✗ match(modelicaParser::T__53);
5787 ✗ setState(796);
5788 ✗ expression();
5789 ✗ setState(802);
5790 ✗ _errHandler->sync(this);
5791 ✗ _la = _input->LA(1);
5792 }
5793 ✗ setState(803);
5794 ✗ match(modelicaParser::T__55);
5795 ✗ setState(804);
5796 ✗ expression();
5797 ✗ break;
5798 }
5799
5800 ✗ default:
5801 ✗ throw NoViableAltException(this);
5802 }
5803
5804 ✗ } catch (RecognitionException& e) {
5805 ✗ _errHandler->reportError(this, e);
5806 ✗ _localctx->exception = std::current_exception();
5807 ✗ _errHandler->recover(this, _localctx->exception);
5808 ✗ }
5809
5810 ✗ return _localctx;
5811 ✗ }
5812
5813 //----------------- Simple_expressionContext ------------------------------------------------------------------
5814
5815 ✗ modelicaParser::Simple_expressionContext::Simple_expressionContext(ParserRuleContext* parent, size_t invokingState)
5816 ✗ : ParserRuleContext(parent, invokingState) {}
5817
5818 ✗ std::vector<modelicaParser::Logical_expressionContext*> modelicaParser::Simple_expressionContext::logical_expression() {
5819 ✗ return getRuleContexts<modelicaParser::Logical_expressionContext>();
5820 }
5821
5822 ✗ modelicaParser::Logical_expressionContext* modelicaParser::Simple_expressionContext::logical_expression(size_t i) {
5823 ✗ return getRuleContext<modelicaParser::Logical_expressionContext>(i);
5824 }
5825
5826 ✗ size_t modelicaParser::Simple_expressionContext::getRuleIndex() const {
5827 ✗ return modelicaParser::RuleSimple_expression;
5828 }
5829
5830 ✗ void modelicaParser::Simple_expressionContext::enterRule(tree::ParseTreeListener* listener) {
5831 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5832 ✗ if (parserListener != nullptr) parserListener->enterSimple_expression(this);
5833 ✗ }
5834
5835 ✗ void modelicaParser::Simple_expressionContext::exitRule(tree::ParseTreeListener* listener) {
5836 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5837 ✗ if (parserListener != nullptr) parserListener->exitSimple_expression(this);
5838 ✗ }
5839
5840 ✗ std::any modelicaParser::Simple_expressionContext::accept(tree::ParseTreeVisitor* visitor) {
5841 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5842 ✗ return parserVisitor->visitSimple_expression(this);
5843 else
5844 ✗ return visitor->visitChildren(this);
5845 }
5846
5847 ✗ modelicaParser::Simple_expressionContext* modelicaParser::simple_expression() {
5848 ✗ Simple_expressionContext* _localctx = _tracker.createInstance<Simple_expressionContext>(_ctx, getState());
5849 ✗ enterRule(_localctx, 106, modelicaParser::RuleSimple_expression);
5850 ✗ size_t _la = 0;
5851
5852 #if __cplusplus > 201703L
5853 ✗ auto onExit = finally([=, this] {
5854 #else
5855 auto onExit = finally([=] {
5856 #endif
5857 ✗ exitRule();
5858 ✗ });
5859 try {
5860 ✗ enterOuterAlt(_localctx, 1);
5861 ✗ setState(808);
5862 ✗ logical_expression();
5863 ✗ setState(815);
5864 ✗ _errHandler->sync(this);
5865
5866 ✗ _la = _input->LA(1);
5867 ✗ if (_la == modelicaParser::T__22) {
5868 ✗ setState(809);
5869 ✗ match(modelicaParser::T__22);
5870 ✗ setState(810);
5871 ✗ logical_expression();
5872 ✗ setState(813);
5873 ✗ _errHandler->sync(this);
5874
5875 ✗ _la = _input->LA(1);
5876 ✗ if (_la == modelicaParser::T__22) {
5877 ✗ setState(811);
5878 ✗ match(modelicaParser::T__22);
5879 ✗ setState(812);
5880 ✗ logical_expression();
5881 }
5882 }
5883
5884 ✗ } catch (RecognitionException& e) {
5885 ✗ _errHandler->reportError(this, e);
5886 ✗ _localctx->exception = std::current_exception();
5887 ✗ _errHandler->recover(this, _localctx->exception);
5888 ✗ }
5889
5890 ✗ return _localctx;
5891 ✗ }
5892
5893 //----------------- Logical_expressionContext ------------------------------------------------------------------
5894
5895 ✗ modelicaParser::Logical_expressionContext::Logical_expressionContext(ParserRuleContext* parent, size_t invokingState)
5896 ✗ : ParserRuleContext(parent, invokingState) {}
5897
5898 ✗ std::vector<modelicaParser::Logical_termContext*> modelicaParser::Logical_expressionContext::logical_term() {
5899 ✗ return getRuleContexts<modelicaParser::Logical_termContext>();
5900 }
5901
5902 ✗ modelicaParser::Logical_termContext* modelicaParser::Logical_expressionContext::logical_term(size_t i) {
5903 ✗ return getRuleContext<modelicaParser::Logical_termContext>(i);
5904 }
5905
5906 ✗ size_t modelicaParser::Logical_expressionContext::getRuleIndex() const {
5907 ✗ return modelicaParser::RuleLogical_expression;
5908 }
5909
5910 ✗ void modelicaParser::Logical_expressionContext::enterRule(tree::ParseTreeListener* listener) {
5911 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5912 ✗ if (parserListener != nullptr) parserListener->enterLogical_expression(this);
5913 ✗ }
5914
5915 ✗ void modelicaParser::Logical_expressionContext::exitRule(tree::ParseTreeListener* listener) {
5916 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5917 ✗ if (parserListener != nullptr) parserListener->exitLogical_expression(this);
5918 ✗ }
5919
5920 ✗ std::any modelicaParser::Logical_expressionContext::accept(tree::ParseTreeVisitor* visitor) {
5921 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5922 ✗ return parserVisitor->visitLogical_expression(this);
5923 else
5924 ✗ return visitor->visitChildren(this);
5925 }
5926
5927 ✗ modelicaParser::Logical_expressionContext* modelicaParser::logical_expression() {
5928 ✗ Logical_expressionContext* _localctx = _tracker.createInstance<Logical_expressionContext>(_ctx, getState());
5929 ✗ enterRule(_localctx, 108, modelicaParser::RuleLogical_expression);
5930 ✗ size_t _la = 0;
5931
5932 #if __cplusplus > 201703L
5933 ✗ auto onExit = finally([=, this] {
5934 #else
5935 auto onExit = finally([=] {
5936 #endif
5937 ✗ exitRule();
5938 ✗ });
5939 try {
5940 ✗ enterOuterAlt(_localctx, 1);
5941 ✗ setState(817);
5942 ✗ logical_term();
5943 ✗ setState(822);
5944 ✗ _errHandler->sync(this);
5945 ✗ _la = _input->LA(1);
5946 ✗ while (_la == modelicaParser::T__63) {
5947 ✗ setState(818);
5948 ✗ match(modelicaParser::T__63);
5949 ✗ setState(819);
5950 ✗ logical_term();
5951 ✗ setState(824);
5952 ✗ _errHandler->sync(this);
5953 ✗ _la = _input->LA(1);
5954 }
5955
5956 ✗ } catch (RecognitionException& e) {
5957 ✗ _errHandler->reportError(this, e);
5958 ✗ _localctx->exception = std::current_exception();
5959 ✗ _errHandler->recover(this, _localctx->exception);
5960 ✗ }
5961
5962 ✗ return _localctx;
5963 ✗ }
5964
5965 //----------------- Logical_termContext ------------------------------------------------------------------
5966
5967 ✗ modelicaParser::Logical_termContext::Logical_termContext(ParserRuleContext* parent, size_t invokingState)
5968 ✗ : ParserRuleContext(parent, invokingState) {}
5969
5970 ✗ std::vector<modelicaParser::Logical_factorContext*> modelicaParser::Logical_termContext::logical_factor() {
5971 ✗ return getRuleContexts<modelicaParser::Logical_factorContext>();
5972 }
5973
5974 ✗ modelicaParser::Logical_factorContext* modelicaParser::Logical_termContext::logical_factor(size_t i) {
5975 ✗ return getRuleContext<modelicaParser::Logical_factorContext>(i);
5976 }
5977
5978 ✗ size_t modelicaParser::Logical_termContext::getRuleIndex() const {
5979 ✗ return modelicaParser::RuleLogical_term;
5980 }
5981
5982 ✗ void modelicaParser::Logical_termContext::enterRule(tree::ParseTreeListener* listener) {
5983 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5984 ✗ if (parserListener != nullptr) parserListener->enterLogical_term(this);
5985 ✗ }
5986
5987 ✗ void modelicaParser::Logical_termContext::exitRule(tree::ParseTreeListener* listener) {
5988 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
5989 ✗ if (parserListener != nullptr) parserListener->exitLogical_term(this);
5990 ✗ }
5991
5992 ✗ std::any modelicaParser::Logical_termContext::accept(tree::ParseTreeVisitor* visitor) {
5993 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
5994 ✗ return parserVisitor->visitLogical_term(this);
5995 else
5996 ✗ return visitor->visitChildren(this);
5997 }
5998
5999 ✗ modelicaParser::Logical_termContext* modelicaParser::logical_term() {
6000 ✗ Logical_termContext* _localctx = _tracker.createInstance<Logical_termContext>(_ctx, getState());
6001 ✗ enterRule(_localctx, 110, modelicaParser::RuleLogical_term);
6002 ✗ size_t _la = 0;
6003
6004 #if __cplusplus > 201703L
6005 ✗ auto onExit = finally([=, this] {
6006 #else
6007 auto onExit = finally([=] {
6008 #endif
6009 ✗ exitRule();
6010 ✗ });
6011 try {
6012 ✗ enterOuterAlt(_localctx, 1);
6013 ✗ setState(825);
6014 ✗ logical_factor();
6015 ✗ setState(830);
6016 ✗ _errHandler->sync(this);
6017 ✗ _la = _input->LA(1);
6018 ✗ while (_la == modelicaParser::T__64) {
6019 ✗ setState(826);
6020 ✗ match(modelicaParser::T__64);
6021 ✗ setState(827);
6022 ✗ logical_factor();
6023 ✗ setState(832);
6024 ✗ _errHandler->sync(this);
6025 ✗ _la = _input->LA(1);
6026 }
6027
6028 ✗ } catch (RecognitionException& e) {
6029 ✗ _errHandler->reportError(this, e);
6030 ✗ _localctx->exception = std::current_exception();
6031 ✗ _errHandler->recover(this, _localctx->exception);
6032 ✗ }
6033
6034 ✗ return _localctx;
6035 ✗ }
6036
6037 //----------------- Logical_factorContext ------------------------------------------------------------------
6038
6039 ✗ modelicaParser::Logical_factorContext::Logical_factorContext(ParserRuleContext* parent, size_t invokingState)
6040 ✗ : ParserRuleContext(parent, invokingState) {}
6041
6042 ✗ modelicaParser::RelationContext* modelicaParser::Logical_factorContext::relation() {
6043 ✗ return getRuleContext<modelicaParser::RelationContext>(0);
6044 }
6045
6046 ✗ size_t modelicaParser::Logical_factorContext::getRuleIndex() const {
6047 ✗ return modelicaParser::RuleLogical_factor;
6048 }
6049
6050 ✗ void modelicaParser::Logical_factorContext::enterRule(tree::ParseTreeListener* listener) {
6051 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6052 ✗ if (parserListener != nullptr) parserListener->enterLogical_factor(this);
6053 ✗ }
6054
6055 ✗ void modelicaParser::Logical_factorContext::exitRule(tree::ParseTreeListener* listener) {
6056 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6057 ✗ if (parserListener != nullptr) parserListener->exitLogical_factor(this);
6058 ✗ }
6059
6060 ✗ std::any modelicaParser::Logical_factorContext::accept(tree::ParseTreeVisitor* visitor) {
6061 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6062 ✗ return parserVisitor->visitLogical_factor(this);
6063 else
6064 ✗ return visitor->visitChildren(this);
6065 }
6066
6067 ✗ modelicaParser::Logical_factorContext* modelicaParser::logical_factor() {
6068 ✗ Logical_factorContext* _localctx = _tracker.createInstance<Logical_factorContext>(_ctx, getState());
6069 ✗ enterRule(_localctx, 112, modelicaParser::RuleLogical_factor);
6070 ✗ size_t _la = 0;
6071
6072 #if __cplusplus > 201703L
6073 ✗ auto onExit = finally([=, this] {
6074 #else
6075 auto onExit = finally([=] {
6076 #endif
6077 ✗ exitRule();
6078 ✗ });
6079 try {
6080 ✗ enterOuterAlt(_localctx, 1);
6081 ✗ setState(834);
6082 ✗ _errHandler->sync(this);
6083
6084 ✗ _la = _input->LA(1);
6085 ✗ if (_la == modelicaParser::T__65) {
6086 ✗ setState(833);
6087 ✗ match(modelicaParser::T__65);
6088 }
6089 ✗ setState(836);
6090 ✗ relation();
6091
6092 ✗ } catch (RecognitionException& e) {
6093 ✗ _errHandler->reportError(this, e);
6094 ✗ _localctx->exception = std::current_exception();
6095 ✗ _errHandler->recover(this, _localctx->exception);
6096 ✗ }
6097
6098 ✗ return _localctx;
6099 ✗ }
6100
6101 //----------------- RelationContext ------------------------------------------------------------------
6102
6103 ✗ modelicaParser::RelationContext::RelationContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
6104
6105 ✗ std::vector<modelicaParser::Arithmetic_expressionContext*> modelicaParser::RelationContext::arithmetic_expression() {
6106 ✗ return getRuleContexts<modelicaParser::Arithmetic_expressionContext>();
6107 }
6108
6109 ✗ modelicaParser::Arithmetic_expressionContext* modelicaParser::RelationContext::arithmetic_expression(size_t i) {
6110 ✗ return getRuleContext<modelicaParser::Arithmetic_expressionContext>(i);
6111 }
6112
6113 ✗ modelicaParser::Rel_opContext* modelicaParser::RelationContext::rel_op() {
6114 ✗ return getRuleContext<modelicaParser::Rel_opContext>(0);
6115 }
6116
6117 ✗ size_t modelicaParser::RelationContext::getRuleIndex() const {
6118 ✗ return modelicaParser::RuleRelation;
6119 }
6120
6121 ✗ void modelicaParser::RelationContext::enterRule(tree::ParseTreeListener* listener) {
6122 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6123 ✗ if (parserListener != nullptr) parserListener->enterRelation(this);
6124 ✗ }
6125
6126 ✗ void modelicaParser::RelationContext::exitRule(tree::ParseTreeListener* listener) {
6127 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6128 ✗ if (parserListener != nullptr) parserListener->exitRelation(this);
6129 ✗ }
6130
6131 ✗ std::any modelicaParser::RelationContext::accept(tree::ParseTreeVisitor* visitor) {
6132 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6133 ✗ return parserVisitor->visitRelation(this);
6134 else
6135 ✗ return visitor->visitChildren(this);
6136 }
6137
6138 ✗ modelicaParser::RelationContext* modelicaParser::relation() {
6139 ✗ RelationContext* _localctx = _tracker.createInstance<RelationContext>(_ctx, getState());
6140 ✗ enterRule(_localctx, 114, modelicaParser::RuleRelation);
6141 ✗ size_t _la = 0;
6142
6143 #if __cplusplus > 201703L
6144 ✗ auto onExit = finally([=, this] {
6145 #else
6146 auto onExit = finally([=] {
6147 #endif
6148 ✗ exitRule();
6149 ✗ });
6150 try {
6151 ✗ enterOuterAlt(_localctx, 1);
6152 ✗ setState(838);
6153 ✗ arithmetic_expression();
6154 ✗ setState(842);
6155 ✗ _errHandler->sync(this);
6156
6157 ✗ _la = _input->LA(1);
6158 ✗ if (((((_la - 67) & ~0x3fULL) == 0) && ((1ULL << (_la - 67)) & 63) != 0)) {
6159 ✗ setState(839);
6160 ✗ rel_op();
6161 ✗ setState(840);
6162 ✗ arithmetic_expression();
6163 }
6164
6165 ✗ } catch (RecognitionException& e) {
6166 ✗ _errHandler->reportError(this, e);
6167 ✗ _localctx->exception = std::current_exception();
6168 ✗ _errHandler->recover(this, _localctx->exception);
6169 ✗ }
6170
6171 ✗ return _localctx;
6172 ✗ }
6173
6174 //----------------- Rel_opContext ------------------------------------------------------------------
6175
6176 ✗ modelicaParser::Rel_opContext::Rel_opContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
6177
6178 ✗ size_t modelicaParser::Rel_opContext::getRuleIndex() const {
6179 ✗ return modelicaParser::RuleRel_op;
6180 }
6181
6182 ✗ void modelicaParser::Rel_opContext::enterRule(tree::ParseTreeListener* listener) {
6183 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6184 ✗ if (parserListener != nullptr) parserListener->enterRel_op(this);
6185 ✗ }
6186
6187 ✗ void modelicaParser::Rel_opContext::exitRule(tree::ParseTreeListener* listener) {
6188 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6189 ✗ if (parserListener != nullptr) parserListener->exitRel_op(this);
6190 ✗ }
6191
6192 ✗ std::any modelicaParser::Rel_opContext::accept(tree::ParseTreeVisitor* visitor) {
6193 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6194 ✗ return parserVisitor->visitRel_op(this);
6195 else
6196 ✗ return visitor->visitChildren(this);
6197 }
6198
6199 ✗ modelicaParser::Rel_opContext* modelicaParser::rel_op() {
6200 ✗ Rel_opContext* _localctx = _tracker.createInstance<Rel_opContext>(_ctx, getState());
6201 ✗ enterRule(_localctx, 116, modelicaParser::RuleRel_op);
6202 ✗ size_t _la = 0;
6203
6204 #if __cplusplus > 201703L
6205 ✗ auto onExit = finally([=, this] {
6206 #else
6207 auto onExit = finally([=] {
6208 #endif
6209 ✗ exitRule();
6210 ✗ });
6211 try {
6212 ✗ enterOuterAlt(_localctx, 1);
6213 ✗ setState(844);
6214 ✗ _la = _input->LA(1);
6215 ✗ if (!(((((_la - 67) & ~0x3fULL) == 0) && ((1ULL << (_la - 67)) & 63) != 0))) {
6216 ✗ _errHandler->recoverInline(this);
6217 } else {
6218 ✗ _errHandler->reportMatch(this);
6219 ✗ consume();
6220 }
6221
6222 ✗ } catch (RecognitionException& e) {
6223 ✗ _errHandler->reportError(this, e);
6224 ✗ _localctx->exception = std::current_exception();
6225 ✗ _errHandler->recover(this, _localctx->exception);
6226 ✗ }
6227
6228 ✗ return _localctx;
6229 ✗ }
6230
6231 //----------------- Arithmetic_expressionContext ------------------------------------------------------------------
6232
6233 ✗ modelicaParser::Arithmetic_expressionContext::Arithmetic_expressionContext(ParserRuleContext* parent, size_t invokingState)
6234 ✗ : ParserRuleContext(parent, invokingState) {}
6235
6236 ✗ std::vector<modelicaParser::TermContext*> modelicaParser::Arithmetic_expressionContext::term() {
6237 ✗ return getRuleContexts<modelicaParser::TermContext>();
6238 }
6239
6240 ✗ modelicaParser::TermContext* modelicaParser::Arithmetic_expressionContext::term(size_t i) {
6241 ✗ return getRuleContext<modelicaParser::TermContext>(i);
6242 }
6243
6244 ✗ std::vector<modelicaParser::Add_opContext*> modelicaParser::Arithmetic_expressionContext::add_op() {
6245 ✗ return getRuleContexts<modelicaParser::Add_opContext>();
6246 }
6247
6248 ✗ modelicaParser::Add_opContext* modelicaParser::Arithmetic_expressionContext::add_op(size_t i) {
6249 ✗ return getRuleContext<modelicaParser::Add_opContext>(i);
6250 }
6251
6252 ✗ size_t modelicaParser::Arithmetic_expressionContext::getRuleIndex() const {
6253 ✗ return modelicaParser::RuleArithmetic_expression;
6254 }
6255
6256 ✗ void modelicaParser::Arithmetic_expressionContext::enterRule(tree::ParseTreeListener* listener) {
6257 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6258 ✗ if (parserListener != nullptr) parserListener->enterArithmetic_expression(this);
6259 ✗ }
6260
6261 ✗ void modelicaParser::Arithmetic_expressionContext::exitRule(tree::ParseTreeListener* listener) {
6262 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6263 ✗ if (parserListener != nullptr) parserListener->exitArithmetic_expression(this);
6264 ✗ }
6265
6266 ✗ std::any modelicaParser::Arithmetic_expressionContext::accept(tree::ParseTreeVisitor* visitor) {
6267 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6268 ✗ return parserVisitor->visitArithmetic_expression(this);
6269 else
6270 ✗ return visitor->visitChildren(this);
6271 }
6272
6273 ✗ modelicaParser::Arithmetic_expressionContext* modelicaParser::arithmetic_expression() {
6274 ✗ Arithmetic_expressionContext* _localctx = _tracker.createInstance<Arithmetic_expressionContext>(_ctx, getState());
6275 ✗ enterRule(_localctx, 118, modelicaParser::RuleArithmetic_expression);
6276 ✗ size_t _la = 0;
6277
6278 #if __cplusplus > 201703L
6279 ✗ auto onExit = finally([=, this] {
6280 #else
6281 auto onExit = finally([=] {
6282 #endif
6283 ✗ exitRule();
6284 ✗ });
6285 try {
6286 ✗ enterOuterAlt(_localctx, 1);
6287 ✗ setState(847);
6288 ✗ _errHandler->sync(this);
6289
6290 ✗ _la = _input->LA(1);
6291 ✗ if (((((_la - 73) & ~0x3fULL) == 0) && ((1ULL << (_la - 73)) & 15) != 0)) {
6292 ✗ setState(846);
6293 ✗ add_op();
6294 }
6295 ✗ setState(849);
6296 ✗ term();
6297 ✗ setState(855);
6298 ✗ _errHandler->sync(this);
6299 ✗ _la = _input->LA(1);
6300 ✗ while (((((_la - 73) & ~0x3fULL) == 0) && ((1ULL << (_la - 73)) & 15) != 0)) {
6301 ✗ setState(850);
6302 ✗ add_op();
6303 ✗ setState(851);
6304 ✗ term();
6305 ✗ setState(857);
6306 ✗ _errHandler->sync(this);
6307 ✗ _la = _input->LA(1);
6308 }
6309
6310 ✗ } catch (RecognitionException& e) {
6311 ✗ _errHandler->reportError(this, e);
6312 ✗ _localctx->exception = std::current_exception();
6313 ✗ _errHandler->recover(this, _localctx->exception);
6314 ✗ }
6315
6316 ✗ return _localctx;
6317 ✗ }
6318
6319 //----------------- Add_opContext ------------------------------------------------------------------
6320
6321 ✗ modelicaParser::Add_opContext::Add_opContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
6322
6323 ✗ size_t modelicaParser::Add_opContext::getRuleIndex() const {
6324 ✗ return modelicaParser::RuleAdd_op;
6325 }
6326
6327 ✗ void modelicaParser::Add_opContext::enterRule(tree::ParseTreeListener* listener) {
6328 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6329 ✗ if (parserListener != nullptr) parserListener->enterAdd_op(this);
6330 ✗ }
6331
6332 ✗ void modelicaParser::Add_opContext::exitRule(tree::ParseTreeListener* listener) {
6333 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6334 ✗ if (parserListener != nullptr) parserListener->exitAdd_op(this);
6335 ✗ }
6336
6337 ✗ std::any modelicaParser::Add_opContext::accept(tree::ParseTreeVisitor* visitor) {
6338 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6339 ✗ return parserVisitor->visitAdd_op(this);
6340 else
6341 ✗ return visitor->visitChildren(this);
6342 }
6343
6344 ✗ modelicaParser::Add_opContext* modelicaParser::add_op() {
6345 ✗ Add_opContext* _localctx = _tracker.createInstance<Add_opContext>(_ctx, getState());
6346 ✗ enterRule(_localctx, 120, modelicaParser::RuleAdd_op);
6347 ✗ size_t _la = 0;
6348
6349 #if __cplusplus > 201703L
6350 ✗ auto onExit = finally([=, this] {
6351 #else
6352 auto onExit = finally([=] {
6353 #endif
6354 ✗ exitRule();
6355 ✗ });
6356 try {
6357 ✗ enterOuterAlt(_localctx, 1);
6358 ✗ setState(858);
6359 ✗ _la = _input->LA(1);
6360 ✗ if (!(((((_la - 73) & ~0x3fULL) == 0) && ((1ULL << (_la - 73)) & 15) != 0))) {
6361 ✗ _errHandler->recoverInline(this);
6362 } else {
6363 ✗ _errHandler->reportMatch(this);
6364 ✗ consume();
6365 }
6366
6367 ✗ } catch (RecognitionException& e) {
6368 ✗ _errHandler->reportError(this, e);
6369 ✗ _localctx->exception = std::current_exception();
6370 ✗ _errHandler->recover(this, _localctx->exception);
6371 ✗ }
6372
6373 ✗ return _localctx;
6374 ✗ }
6375
6376 //----------------- TermContext ------------------------------------------------------------------
6377
6378 ✗ modelicaParser::TermContext::TermContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
6379
6380 ✗ std::vector<modelicaParser::FactorContext*> modelicaParser::TermContext::factor() {
6381 ✗ return getRuleContexts<modelicaParser::FactorContext>();
6382 }
6383
6384 ✗ modelicaParser::FactorContext* modelicaParser::TermContext::factor(size_t i) {
6385 ✗ return getRuleContext<modelicaParser::FactorContext>(i);
6386 }
6387
6388 ✗ std::vector<modelicaParser::Mul_opContext*> modelicaParser::TermContext::mul_op() {
6389 ✗ return getRuleContexts<modelicaParser::Mul_opContext>();
6390 }
6391
6392 ✗ modelicaParser::Mul_opContext* modelicaParser::TermContext::mul_op(size_t i) {
6393 ✗ return getRuleContext<modelicaParser::Mul_opContext>(i);
6394 }
6395
6396 ✗ size_t modelicaParser::TermContext::getRuleIndex() const {
6397 ✗ return modelicaParser::RuleTerm;
6398 }
6399
6400 ✗ void modelicaParser::TermContext::enterRule(tree::ParseTreeListener* listener) {
6401 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6402 ✗ if (parserListener != nullptr) parserListener->enterTerm(this);
6403 ✗ }
6404
6405 ✗ void modelicaParser::TermContext::exitRule(tree::ParseTreeListener* listener) {
6406 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6407 ✗ if (parserListener != nullptr) parserListener->exitTerm(this);
6408 ✗ }
6409
6410 ✗ std::any modelicaParser::TermContext::accept(tree::ParseTreeVisitor* visitor) {
6411 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6412 ✗ return parserVisitor->visitTerm(this);
6413 else
6414 ✗ return visitor->visitChildren(this);
6415 }
6416
6417 ✗ modelicaParser::TermContext* modelicaParser::term() {
6418 ✗ TermContext* _localctx = _tracker.createInstance<TermContext>(_ctx, getState());
6419 ✗ enterRule(_localctx, 122, modelicaParser::RuleTerm);
6420 ✗ size_t _la = 0;
6421
6422 #if __cplusplus > 201703L
6423 ✗ auto onExit = finally([=, this] {
6424 #else
6425 auto onExit = finally([=] {
6426 #endif
6427 ✗ exitRule();
6428 ✗ });
6429 try {
6430 ✗ enterOuterAlt(_localctx, 1);
6431 ✗ setState(860);
6432 ✗ factor();
6433 ✗ setState(866);
6434 ✗ _errHandler->sync(this);
6435 ✗ _la = _input->LA(1);
6436 ✗ while (((((_la - 35) & ~0x3fULL) == 0) && ((1ULL << (_la - 35)) & 30786325577729) != 0)) {
6437 ✗ setState(861);
6438 ✗ mul_op();
6439 ✗ setState(862);
6440 ✗ factor();
6441 ✗ setState(868);
6442 ✗ _errHandler->sync(this);
6443 ✗ _la = _input->LA(1);
6444 }
6445
6446 ✗ } catch (RecognitionException& e) {
6447 ✗ _errHandler->reportError(this, e);
6448 ✗ _localctx->exception = std::current_exception();
6449 ✗ _errHandler->recover(this, _localctx->exception);
6450 ✗ }
6451
6452 ✗ return _localctx;
6453 ✗ }
6454
6455 //----------------- Mul_opContext ------------------------------------------------------------------
6456
6457 ✗ modelicaParser::Mul_opContext::Mul_opContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
6458
6459 ✗ size_t modelicaParser::Mul_opContext::getRuleIndex() const {
6460 ✗ return modelicaParser::RuleMul_op;
6461 }
6462
6463 ✗ void modelicaParser::Mul_opContext::enterRule(tree::ParseTreeListener* listener) {
6464 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6465 ✗ if (parserListener != nullptr) parserListener->enterMul_op(this);
6466 ✗ }
6467
6468 ✗ void modelicaParser::Mul_opContext::exitRule(tree::ParseTreeListener* listener) {
6469 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6470 ✗ if (parserListener != nullptr) parserListener->exitMul_op(this);
6471 ✗ }
6472
6473 ✗ std::any modelicaParser::Mul_opContext::accept(tree::ParseTreeVisitor* visitor) {
6474 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6475 ✗ return parserVisitor->visitMul_op(this);
6476 else
6477 ✗ return visitor->visitChildren(this);
6478 }
6479
6480 ✗ modelicaParser::Mul_opContext* modelicaParser::mul_op() {
6481 ✗ Mul_opContext* _localctx = _tracker.createInstance<Mul_opContext>(_ctx, getState());
6482 ✗ enterRule(_localctx, 124, modelicaParser::RuleMul_op);
6483 ✗ size_t _la = 0;
6484
6485 #if __cplusplus > 201703L
6486 ✗ auto onExit = finally([=, this] {
6487 #else
6488 auto onExit = finally([=] {
6489 #endif
6490 ✗ exitRule();
6491 ✗ });
6492 try {
6493 ✗ enterOuterAlt(_localctx, 1);
6494 ✗ setState(869);
6495 ✗ _la = _input->LA(1);
6496 ✗ if (!(((((_la - 35) & ~0x3fULL) == 0) && ((1ULL << (_la - 35)) & 30786325577729) != 0))) {
6497 ✗ _errHandler->recoverInline(this);
6498 } else {
6499 ✗ _errHandler->reportMatch(this);
6500 ✗ consume();
6501 }
6502
6503 ✗ } catch (RecognitionException& e) {
6504 ✗ _errHandler->reportError(this, e);
6505 ✗ _localctx->exception = std::current_exception();
6506 ✗ _errHandler->recover(this, _localctx->exception);
6507 ✗ }
6508
6509 ✗ return _localctx;
6510 ✗ }
6511
6512 //----------------- FactorContext ------------------------------------------------------------------
6513
6514 ✗ modelicaParser::FactorContext::FactorContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
6515
6516 ✗ std::vector<modelicaParser::PrimaryContext*> modelicaParser::FactorContext::primary() {
6517 ✗ return getRuleContexts<modelicaParser::PrimaryContext>();
6518 }
6519
6520 ✗ modelicaParser::PrimaryContext* modelicaParser::FactorContext::primary(size_t i) {
6521 ✗ return getRuleContext<modelicaParser::PrimaryContext>(i);
6522 }
6523
6524 ✗ size_t modelicaParser::FactorContext::getRuleIndex() const {
6525 ✗ return modelicaParser::RuleFactor;
6526 }
6527
6528 ✗ void modelicaParser::FactorContext::enterRule(tree::ParseTreeListener* listener) {
6529 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6530 ✗ if (parserListener != nullptr) parserListener->enterFactor(this);
6531 ✗ }
6532
6533 ✗ void modelicaParser::FactorContext::exitRule(tree::ParseTreeListener* listener) {
6534 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6535 ✗ if (parserListener != nullptr) parserListener->exitFactor(this);
6536 ✗ }
6537
6538 ✗ std::any modelicaParser::FactorContext::accept(tree::ParseTreeVisitor* visitor) {
6539 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6540 ✗ return parserVisitor->visitFactor(this);
6541 else
6542 ✗ return visitor->visitChildren(this);
6543 }
6544
6545 ✗ modelicaParser::FactorContext* modelicaParser::factor() {
6546 ✗ FactorContext* _localctx = _tracker.createInstance<FactorContext>(_ctx, getState());
6547 ✗ enterRule(_localctx, 126, modelicaParser::RuleFactor);
6548 ✗ size_t _la = 0;
6549
6550 #if __cplusplus > 201703L
6551 ✗ auto onExit = finally([=, this] {
6552 #else
6553 auto onExit = finally([=] {
6554 #endif
6555 ✗ exitRule();
6556 ✗ });
6557 try {
6558 ✗ enterOuterAlt(_localctx, 1);
6559 ✗ setState(871);
6560 ✗ primary();
6561 ✗ setState(874);
6562 ✗ _errHandler->sync(this);
6563
6564 ✗ _la = _input->LA(1);
6565 ✗ if (_la == modelicaParser::T__79
6566
6567 ✗ || _la == modelicaParser::T__80) {
6568 ✗ setState(872);
6569 ✗ _la = _input->LA(1);
6570 ✗ if (!(_la == modelicaParser::T__79
6571
6572 || _la == modelicaParser::T__80)) {
6573 ✗ _errHandler->recoverInline(this);
6574 } else {
6575 ✗ _errHandler->reportMatch(this);
6576 ✗ consume();
6577 }
6578 ✗ setState(873);
6579 ✗ primary();
6580 }
6581
6582 ✗ } catch (RecognitionException& e) {
6583 ✗ _errHandler->reportError(this, e);
6584 ✗ _localctx->exception = std::current_exception();
6585 ✗ _errHandler->recover(this, _localctx->exception);
6586 ✗ }
6587
6588 ✗ return _localctx;
6589 ✗ }
6590
6591 //----------------- PrimaryContext ------------------------------------------------------------------
6592
6593 ✗ modelicaParser::PrimaryContext::PrimaryContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
6594
6595 ✗ tree::TerminalNode* modelicaParser::PrimaryContext::UNSIGNED_NUMBER() {
6596 ✗ return getToken(modelicaParser::UNSIGNED_NUMBER, 0);
6597 }
6598
6599 ✗ tree::TerminalNode* modelicaParser::PrimaryContext::STRING() {
6600 ✗ return getToken(modelicaParser::STRING, 0);
6601 }
6602
6603 ✗ modelicaParser::Function_call_argsContext* modelicaParser::PrimaryContext::function_call_args() {
6604 ✗ return getRuleContext<modelicaParser::Function_call_argsContext>(0);
6605 }
6606
6607 ✗ modelicaParser::NameContext* modelicaParser::PrimaryContext::name() {
6608 ✗ return getRuleContext<modelicaParser::NameContext>(0);
6609 }
6610
6611 ✗ modelicaParser::Component_referenceContext* modelicaParser::PrimaryContext::component_reference() {
6612 ✗ return getRuleContext<modelicaParser::Component_referenceContext>(0);
6613 }
6614
6615 ✗ modelicaParser::Output_expression_listContext* modelicaParser::PrimaryContext::output_expression_list() {
6616 ✗ return getRuleContext<modelicaParser::Output_expression_listContext>(0);
6617 }
6618
6619 ✗ std::vector<modelicaParser::Expression_listContext*> modelicaParser::PrimaryContext::expression_list() {
6620 ✗ return getRuleContexts<modelicaParser::Expression_listContext>();
6621 }
6622
6623 ✗ modelicaParser::Expression_listContext* modelicaParser::PrimaryContext::expression_list(size_t i) {
6624 ✗ return getRuleContext<modelicaParser::Expression_listContext>(i);
6625 }
6626
6627 ✗ modelicaParser::Function_argumentsContext* modelicaParser::PrimaryContext::function_arguments() {
6628 ✗ return getRuleContext<modelicaParser::Function_argumentsContext>(0);
6629 }
6630
6631 ✗ size_t modelicaParser::PrimaryContext::getRuleIndex() const {
6632 ✗ return modelicaParser::RulePrimary;
6633 }
6634
6635 ✗ void modelicaParser::PrimaryContext::enterRule(tree::ParseTreeListener* listener) {
6636 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6637 ✗ if (parserListener != nullptr) parserListener->enterPrimary(this);
6638 ✗ }
6639
6640 ✗ void modelicaParser::PrimaryContext::exitRule(tree::ParseTreeListener* listener) {
6641 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6642 ✗ if (parserListener != nullptr) parserListener->exitPrimary(this);
6643 ✗ }
6644
6645 ✗ std::any modelicaParser::PrimaryContext::accept(tree::ParseTreeVisitor* visitor) {
6646 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6647 ✗ return parserVisitor->visitPrimary(this);
6648 else
6649 ✗ return visitor->visitChildren(this);
6650 }
6651
6652 ✗ modelicaParser::PrimaryContext* modelicaParser::primary() {
6653 ✗ PrimaryContext* _localctx = _tracker.createInstance<PrimaryContext>(_ctx, getState());
6654 ✗ enterRule(_localctx, 128, modelicaParser::RulePrimary);
6655 ✗ size_t _la = 0;
6656
6657 #if __cplusplus > 201703L
6658 ✗ auto onExit = finally([=, this] {
6659 #else
6660 auto onExit = finally([=] {
6661 #endif
6662 ✗ exitRule();
6663 ✗ });
6664 try {
6665 ✗ setState(907);
6666 ✗ _errHandler->sync(this);
6667 ✗ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx)) {
6668 ✗ case 1: {
6669 ✗ enterOuterAlt(_localctx, 1);
6670 ✗ setState(876);
6671 ✗ match(modelicaParser::UNSIGNED_NUMBER);
6672 ✗ break;
6673 }
6674
6675 ✗ case 2: {
6676 ✗ enterOuterAlt(_localctx, 2);
6677 ✗ setState(877);
6678 ✗ match(modelicaParser::STRING);
6679 ✗ break;
6680 }
6681
6682 ✗ case 3: {
6683 ✗ enterOuterAlt(_localctx, 3);
6684 ✗ setState(878);
6685 ✗ match(modelicaParser::T__81);
6686 ✗ break;
6687 }
6688
6689 ✗ case 4: {
6690 ✗ enterOuterAlt(_localctx, 4);
6691 ✗ setState(879);
6692 ✗ match(modelicaParser::T__82);
6693 ✗ break;
6694 }
6695
6696 ✗ case 5: {
6697 ✗ enterOuterAlt(_localctx, 5);
6698 ✗ setState(883);
6699 ✗ _errHandler->sync(this);
6700 ✗ switch (_input->LA(1)) {
6701 ✗ case modelicaParser::T__86:
6702 case modelicaParser::IDENT: {
6703 ✗ setState(880);
6704 ✗ name();
6705 ✗ break;
6706 }
6707
6708 ✗ case modelicaParser::T__24: {
6709 ✗ setState(881);
6710 ✗ match(modelicaParser::T__24);
6711 ✗ break;
6712 }
6713
6714 ✗ case modelicaParser::T__48: {
6715 ✗ setState(882);
6716 ✗ match(modelicaParser::T__48);
6717 ✗ break;
6718 }
6719
6720 ✗ default:
6721 ✗ throw NoViableAltException(this);
6722 }
6723 ✗ setState(885);
6724 ✗ function_call_args();
6725 ✗ break;
6726 }
6727
6728 ✗ case 6: {
6729 ✗ enterOuterAlt(_localctx, 6);
6730 ✗ setState(886);
6731 ✗ component_reference();
6732 ✗ break;
6733 }
6734
6735 ✗ case 7: {
6736 ✗ enterOuterAlt(_localctx, 7);
6737 ✗ setState(887);
6738 ✗ match(modelicaParser::T__21);
6739 ✗ setState(888);
6740 ✗ output_expression_list();
6741 ✗ setState(889);
6742 ✗ match(modelicaParser::T__23);
6743 ✗ break;
6744 }
6745
6746 ✗ case 8: {
6747 ✗ enterOuterAlt(_localctx, 8);
6748 ✗ setState(891);
6749 ✗ match(modelicaParser::T__83);
6750 ✗ setState(892);
6751 ✗ expression_list();
6752 ✗ setState(897);
6753 ✗ _errHandler->sync(this);
6754 ✗ _la = _input->LA(1);
6755 ✗ while (_la == modelicaParser::T__1) {
6756 ✗ setState(893);
6757 ✗ match(modelicaParser::T__1);
6758 ✗ setState(894);
6759 ✗ expression_list();
6760 ✗ setState(899);
6761 ✗ _errHandler->sync(this);
6762 ✗ _la = _input->LA(1);
6763 }
6764 ✗ setState(900);
6765 ✗ match(modelicaParser::T__84);
6766 ✗ break;
6767 }
6768
6769 ✗ case 9: {
6770 ✗ enterOuterAlt(_localctx, 9);
6771 ✗ setState(902);
6772 ✗ match(modelicaParser::T__85);
6773 ✗ setState(903);
6774 ✗ function_arguments();
6775 ✗ setState(904);
6776 ✗ match(modelicaParser::T__36);
6777 ✗ break;
6778 }
6779
6780 ✗ case 10: {
6781 ✗ enterOuterAlt(_localctx, 10);
6782 ✗ setState(906);
6783 ✗ match(modelicaParser::T__17);
6784 ✗ break;
6785 }
6786
6787 ✗ default:
6788 ✗ break;
6789 }
6790
6791 ✗ } catch (RecognitionException& e) {
6792 ✗ _errHandler->reportError(this, e);
6793 ✗ _localctx->exception = std::current_exception();
6794 ✗ _errHandler->recover(this, _localctx->exception);
6795 ✗ }
6796
6797 ✗ return _localctx;
6798 ✗ }
6799
6800 //----------------- NameContext ------------------------------------------------------------------
6801
6802 ✗ modelicaParser::NameContext::NameContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
6803
6804 ✗ std::vector<tree::TerminalNode*> modelicaParser::NameContext::IDENT() {
6805 ✗ return getTokens(modelicaParser::IDENT);
6806 }
6807
6808 ✗ tree::TerminalNode* modelicaParser::NameContext::IDENT(size_t i) {
6809 ✗ return getToken(modelicaParser::IDENT, i);
6810 }
6811
6812 ✗ size_t modelicaParser::NameContext::getRuleIndex() const {
6813 ✗ return modelicaParser::RuleName;
6814 }
6815
6816 ✗ void modelicaParser::NameContext::enterRule(tree::ParseTreeListener* listener) {
6817 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6818 ✗ if (parserListener != nullptr) parserListener->enterName(this);
6819 ✗ }
6820
6821 ✗ void modelicaParser::NameContext::exitRule(tree::ParseTreeListener* listener) {
6822 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6823 ✗ if (parserListener != nullptr) parserListener->exitName(this);
6824 ✗ }
6825
6826 ✗ std::any modelicaParser::NameContext::accept(tree::ParseTreeVisitor* visitor) {
6827 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6828 ✗ return parserVisitor->visitName(this);
6829 else
6830 ✗ return visitor->visitChildren(this);
6831 }
6832
6833 ✗ modelicaParser::NameContext* modelicaParser::name() {
6834 ✗ NameContext* _localctx = _tracker.createInstance<NameContext>(_ctx, getState());
6835 ✗ enterRule(_localctx, 130, modelicaParser::RuleName);
6836 ✗ size_t _la = 0;
6837
6838 #if __cplusplus > 201703L
6839 ✗ auto onExit = finally([=, this] {
6840 #else
6841 auto onExit = finally([=] {
6842 #endif
6843 ✗ exitRule();
6844 ✗ });
6845 try {
6846 ✗ enterOuterAlt(_localctx, 1);
6847 ✗ setState(910);
6848 ✗ _errHandler->sync(this);
6849
6850 ✗ _la = _input->LA(1);
6851 ✗ if (_la == modelicaParser::T__86) {
6852 ✗ setState(909);
6853 ✗ match(modelicaParser::T__86);
6854 }
6855 ✗ setState(912);
6856 ✗ match(modelicaParser::IDENT);
6857 ✗ setState(917);
6858 ✗ _errHandler->sync(this);
6859 ✗ _la = _input->LA(1);
6860 ✗ while (_la == modelicaParser::T__86) {
6861 ✗ setState(913);
6862 ✗ match(modelicaParser::T__86);
6863 ✗ setState(914);
6864 ✗ match(modelicaParser::IDENT);
6865 ✗ setState(919);
6866 ✗ _errHandler->sync(this);
6867 ✗ _la = _input->LA(1);
6868 }
6869
6870 ✗ } catch (RecognitionException& e) {
6871 ✗ _errHandler->reportError(this, e);
6872 ✗ _localctx->exception = std::current_exception();
6873 ✗ _errHandler->recover(this, _localctx->exception);
6874 ✗ }
6875
6876 ✗ return _localctx;
6877 ✗ }
6878
6879 //----------------- Component_referenceContext ------------------------------------------------------------------
6880
6881 ✗ modelicaParser::Component_referenceContext::Component_referenceContext(ParserRuleContext* parent, size_t invokingState)
6882 ✗ : ParserRuleContext(parent, invokingState) {}
6883
6884 ✗ std::vector<tree::TerminalNode*> modelicaParser::Component_referenceContext::IDENT() {
6885 ✗ return getTokens(modelicaParser::IDENT);
6886 }
6887
6888 ✗ tree::TerminalNode* modelicaParser::Component_referenceContext::IDENT(size_t i) {
6889 ✗ return getToken(modelicaParser::IDENT, i);
6890 }
6891
6892 ✗ std::vector<modelicaParser::Array_subscriptsContext*> modelicaParser::Component_referenceContext::array_subscripts() {
6893 ✗ return getRuleContexts<modelicaParser::Array_subscriptsContext>();
6894 }
6895
6896 ✗ modelicaParser::Array_subscriptsContext* modelicaParser::Component_referenceContext::array_subscripts(size_t i) {
6897 ✗ return getRuleContext<modelicaParser::Array_subscriptsContext>(i);
6898 }
6899
6900 ✗ size_t modelicaParser::Component_referenceContext::getRuleIndex() const {
6901 ✗ return modelicaParser::RuleComponent_reference;
6902 }
6903
6904 ✗ void modelicaParser::Component_referenceContext::enterRule(tree::ParseTreeListener* listener) {
6905 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6906 ✗ if (parserListener != nullptr) parserListener->enterComponent_reference(this);
6907 ✗ }
6908
6909 ✗ void modelicaParser::Component_referenceContext::exitRule(tree::ParseTreeListener* listener) {
6910 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6911 ✗ if (parserListener != nullptr) parserListener->exitComponent_reference(this);
6912 ✗ }
6913
6914 ✗ std::any modelicaParser::Component_referenceContext::accept(tree::ParseTreeVisitor* visitor) {
6915 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
6916 ✗ return parserVisitor->visitComponent_reference(this);
6917 else
6918 ✗ return visitor->visitChildren(this);
6919 }
6920
6921 ✗ modelicaParser::Component_referenceContext* modelicaParser::component_reference() {
6922 ✗ Component_referenceContext* _localctx = _tracker.createInstance<Component_referenceContext>(_ctx, getState());
6923 ✗ enterRule(_localctx, 132, modelicaParser::RuleComponent_reference);
6924 ✗ size_t _la = 0;
6925
6926 #if __cplusplus > 201703L
6927 ✗ auto onExit = finally([=, this] {
6928 #else
6929 auto onExit = finally([=] {
6930 #endif
6931 ✗ exitRule();
6932 ✗ });
6933 try {
6934 ✗ enterOuterAlt(_localctx, 1);
6935 ✗ setState(921);
6936 ✗ _errHandler->sync(this);
6937
6938 ✗ _la = _input->LA(1);
6939 ✗ if (_la == modelicaParser::T__86) {
6940 ✗ setState(920);
6941 ✗ match(modelicaParser::T__86);
6942 }
6943 ✗ setState(923);
6944 ✗ match(modelicaParser::IDENT);
6945 ✗ setState(925);
6946 ✗ _errHandler->sync(this);
6947
6948 ✗ _la = _input->LA(1);
6949 ✗ if (_la == modelicaParser::T__83) {
6950 ✗ setState(924);
6951 ✗ array_subscripts();
6952 }
6953 ✗ setState(934);
6954 ✗ _errHandler->sync(this);
6955 ✗ _la = _input->LA(1);
6956 ✗ while (_la == modelicaParser::T__86) {
6957 ✗ setState(927);
6958 ✗ match(modelicaParser::T__86);
6959 ✗ setState(928);
6960 ✗ match(modelicaParser::IDENT);
6961 ✗ setState(930);
6962 ✗ _errHandler->sync(this);
6963
6964 ✗ _la = _input->LA(1);
6965 ✗ if (_la == modelicaParser::T__83) {
6966 ✗ setState(929);
6967 ✗ array_subscripts();
6968 }
6969 ✗ setState(936);
6970 ✗ _errHandler->sync(this);
6971 ✗ _la = _input->LA(1);
6972 }
6973
6974 ✗ } catch (RecognitionException& e) {
6975 ✗ _errHandler->reportError(this, e);
6976 ✗ _localctx->exception = std::current_exception();
6977 ✗ _errHandler->recover(this, _localctx->exception);
6978 ✗ }
6979
6980 ✗ return _localctx;
6981 ✗ }
6982
6983 //----------------- Function_call_argsContext ------------------------------------------------------------------
6984
6985 ✗ modelicaParser::Function_call_argsContext::Function_call_argsContext(ParserRuleContext* parent, size_t invokingState)
6986 ✗ : ParserRuleContext(parent, invokingState) {}
6987
6988 ✗ modelicaParser::Function_argumentsContext* modelicaParser::Function_call_argsContext::function_arguments() {
6989 ✗ return getRuleContext<modelicaParser::Function_argumentsContext>(0);
6990 }
6991
6992 ✗ size_t modelicaParser::Function_call_argsContext::getRuleIndex() const {
6993 ✗ return modelicaParser::RuleFunction_call_args;
6994 }
6995
6996 ✗ void modelicaParser::Function_call_argsContext::enterRule(tree::ParseTreeListener* listener) {
6997 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
6998 ✗ if (parserListener != nullptr) parserListener->enterFunction_call_args(this);
6999 ✗ }
7000
7001 ✗ void modelicaParser::Function_call_argsContext::exitRule(tree::ParseTreeListener* listener) {
7002 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7003 ✗ if (parserListener != nullptr) parserListener->exitFunction_call_args(this);
7004 ✗ }
7005
7006 ✗ std::any modelicaParser::Function_call_argsContext::accept(tree::ParseTreeVisitor* visitor) {
7007 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7008 ✗ return parserVisitor->visitFunction_call_args(this);
7009 else
7010 ✗ return visitor->visitChildren(this);
7011 }
7012
7013 ✗ modelicaParser::Function_call_argsContext* modelicaParser::function_call_args() {
7014 ✗ Function_call_argsContext* _localctx = _tracker.createInstance<Function_call_argsContext>(_ctx, getState());
7015 ✗ enterRule(_localctx, 134, modelicaParser::RuleFunction_call_args);
7016 ✗ size_t _la = 0;
7017
7018 #if __cplusplus > 201703L
7019 ✗ auto onExit = finally([=, this] {
7020 #else
7021 auto onExit = finally([=] {
7022 #endif
7023 ✗ exitRule();
7024 ✗ });
7025 try {
7026 ✗ enterOuterAlt(_localctx, 1);
7027 ✗ setState(937);
7028 ✗ match(modelicaParser::T__21);
7029 ✗ setState(939);
7030 ✗ _errHandler->sync(this);
7031
7032 ✗ _la = _input->LA(1);
7033 ✗ if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 633318735740928) != 0)
7034 ✗ || ((((_la - 66) & ~0x3fULL) == 0) && ((1ULL << (_la - 66)) & 62326657) != 0)) {
7035 ✗ setState(938);
7036 ✗ function_arguments();
7037 }
7038 ✗ setState(941);
7039 ✗ match(modelicaParser::T__23);
7040
7041 ✗ } catch (RecognitionException& e) {
7042 ✗ _errHandler->reportError(this, e);
7043 ✗ _localctx->exception = std::current_exception();
7044 ✗ _errHandler->recover(this, _localctx->exception);
7045 ✗ }
7046
7047 ✗ return _localctx;
7048 ✗ }
7049
7050 //----------------- Function_argumentsContext ------------------------------------------------------------------
7051
7052 ✗ modelicaParser::Function_argumentsContext::Function_argumentsContext(ParserRuleContext* parent, size_t invokingState)
7053 ✗ : ParserRuleContext(parent, invokingState) {}
7054
7055 ✗ modelicaParser::Function_argumentContext* modelicaParser::Function_argumentsContext::function_argument() {
7056 ✗ return getRuleContext<modelicaParser::Function_argumentContext>(0);
7057 }
7058
7059 ✗ modelicaParser::Function_argumentsContext* modelicaParser::Function_argumentsContext::function_arguments() {
7060 ✗ return getRuleContext<modelicaParser::Function_argumentsContext>(0);
7061 }
7062
7063 ✗ modelicaParser::For_indicesContext* modelicaParser::Function_argumentsContext::for_indices() {
7064 ✗ return getRuleContext<modelicaParser::For_indicesContext>(0);
7065 }
7066
7067 ✗ modelicaParser::Named_argumentsContext* modelicaParser::Function_argumentsContext::named_arguments() {
7068 ✗ return getRuleContext<modelicaParser::Named_argumentsContext>(0);
7069 }
7070
7071 ✗ size_t modelicaParser::Function_argumentsContext::getRuleIndex() const {
7072 ✗ return modelicaParser::RuleFunction_arguments;
7073 }
7074
7075 ✗ void modelicaParser::Function_argumentsContext::enterRule(tree::ParseTreeListener* listener) {
7076 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7077 ✗ if (parserListener != nullptr) parserListener->enterFunction_arguments(this);
7078 ✗ }
7079
7080 ✗ void modelicaParser::Function_argumentsContext::exitRule(tree::ParseTreeListener* listener) {
7081 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7082 ✗ if (parserListener != nullptr) parserListener->exitFunction_arguments(this);
7083 ✗ }
7084
7085 ✗ std::any modelicaParser::Function_argumentsContext::accept(tree::ParseTreeVisitor* visitor) {
7086 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7087 ✗ return parserVisitor->visitFunction_arguments(this);
7088 else
7089 ✗ return visitor->visitChildren(this);
7090 }
7091
7092 ✗ modelicaParser::Function_argumentsContext* modelicaParser::function_arguments() {
7093 ✗ Function_argumentsContext* _localctx = _tracker.createInstance<Function_argumentsContext>(_ctx, getState());
7094 ✗ enterRule(_localctx, 136, modelicaParser::RuleFunction_arguments);
7095
7096 #if __cplusplus > 201703L
7097 ✗ auto onExit = finally([=, this] {
7098 #else
7099 auto onExit = finally([=] {
7100 #endif
7101 ✗ exitRule();
7102 ✗ });
7103 try {
7104 ✗ setState(951);
7105 ✗ _errHandler->sync(this);
7106 ✗ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx)) {
7107 ✗ case 1: {
7108 ✗ enterOuterAlt(_localctx, 1);
7109 ✗ setState(943);
7110 ✗ function_argument();
7111 ✗ setState(948);
7112 ✗ _errHandler->sync(this);
7113 ✗ switch (_input->LA(1)) {
7114 ✗ case modelicaParser::T__25: {
7115 ✗ setState(944);
7116 ✗ match(modelicaParser::T__25);
7117 ✗ setState(945);
7118 ✗ function_arguments();
7119 ✗ break;
7120 }
7121
7122 ✗ case modelicaParser::T__56: {
7123 ✗ setState(946);
7124 ✗ match(modelicaParser::T__56);
7125 ✗ setState(947);
7126 ✗ for_indices();
7127 ✗ break;
7128 }
7129
7130 ✗ case modelicaParser::T__23:
7131 case modelicaParser::T__36: {
7132 ✗ break;
7133 }
7134
7135 ✗ default:
7136 ✗ break;
7137 }
7138 ✗ break;
7139 }
7140
7141 ✗ case 2: {
7142 ✗ enterOuterAlt(_localctx, 2);
7143 ✗ setState(950);
7144 ✗ named_arguments();
7145 ✗ break;
7146 }
7147
7148 ✗ default:
7149 ✗ break;
7150 }
7151
7152 ✗ } catch (RecognitionException& e) {
7153 ✗ _errHandler->reportError(this, e);
7154 ✗ _localctx->exception = std::current_exception();
7155 ✗ _errHandler->recover(this, _localctx->exception);
7156 ✗ }
7157
7158 ✗ return _localctx;
7159 ✗ }
7160
7161 //----------------- Named_argumentsContext ------------------------------------------------------------------
7162
7163 ✗ modelicaParser::Named_argumentsContext::Named_argumentsContext(ParserRuleContext* parent, size_t invokingState)
7164 ✗ : ParserRuleContext(parent, invokingState) {}
7165
7166 ✗ modelicaParser::Named_argumentContext* modelicaParser::Named_argumentsContext::named_argument() {
7167 ✗ return getRuleContext<modelicaParser::Named_argumentContext>(0);
7168 }
7169
7170 ✗ modelicaParser::Named_argumentsContext* modelicaParser::Named_argumentsContext::named_arguments() {
7171 ✗ return getRuleContext<modelicaParser::Named_argumentsContext>(0);
7172 }
7173
7174 ✗ size_t modelicaParser::Named_argumentsContext::getRuleIndex() const {
7175 ✗ return modelicaParser::RuleNamed_arguments;
7176 }
7177
7178 ✗ void modelicaParser::Named_argumentsContext::enterRule(tree::ParseTreeListener* listener) {
7179 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7180 ✗ if (parserListener != nullptr) parserListener->enterNamed_arguments(this);
7181 ✗ }
7182
7183 ✗ void modelicaParser::Named_argumentsContext::exitRule(tree::ParseTreeListener* listener) {
7184 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7185 ✗ if (parserListener != nullptr) parserListener->exitNamed_arguments(this);
7186 ✗ }
7187
7188 ✗ std::any modelicaParser::Named_argumentsContext::accept(tree::ParseTreeVisitor* visitor) {
7189 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7190 ✗ return parserVisitor->visitNamed_arguments(this);
7191 else
7192 ✗ return visitor->visitChildren(this);
7193 }
7194
7195 ✗ modelicaParser::Named_argumentsContext* modelicaParser::named_arguments() {
7196 ✗ Named_argumentsContext* _localctx = _tracker.createInstance<Named_argumentsContext>(_ctx, getState());
7197 ✗ enterRule(_localctx, 138, modelicaParser::RuleNamed_arguments);
7198 ✗ size_t _la = 0;
7199
7200 #if __cplusplus > 201703L
7201 ✗ auto onExit = finally([=, this] {
7202 #else
7203 auto onExit = finally([=] {
7204 #endif
7205 ✗ exitRule();
7206 ✗ });
7207 try {
7208 ✗ enterOuterAlt(_localctx, 1);
7209 ✗ setState(953);
7210 ✗ named_argument();
7211 ✗ setState(956);
7212 ✗ _errHandler->sync(this);
7213
7214 ✗ _la = _input->LA(1);
7215 ✗ if (_la == modelicaParser::T__25) {
7216 ✗ setState(954);
7217 ✗ match(modelicaParser::T__25);
7218 ✗ setState(955);
7219 ✗ named_arguments();
7220 }
7221
7222 ✗ } catch (RecognitionException& e) {
7223 ✗ _errHandler->reportError(this, e);
7224 ✗ _localctx->exception = std::current_exception();
7225 ✗ _errHandler->recover(this, _localctx->exception);
7226 ✗ }
7227
7228 ✗ return _localctx;
7229 ✗ }
7230
7231 //----------------- Named_argumentContext ------------------------------------------------------------------
7232
7233 ✗ modelicaParser::Named_argumentContext::Named_argumentContext(ParserRuleContext* parent, size_t invokingState)
7234 ✗ : ParserRuleContext(parent, invokingState) {}
7235
7236 ✗ tree::TerminalNode* modelicaParser::Named_argumentContext::IDENT() {
7237 ✗ return getToken(modelicaParser::IDENT, 0);
7238 }
7239
7240 ✗ modelicaParser::Function_argumentContext* modelicaParser::Named_argumentContext::function_argument() {
7241 ✗ return getRuleContext<modelicaParser::Function_argumentContext>(0);
7242 }
7243
7244 ✗ size_t modelicaParser::Named_argumentContext::getRuleIndex() const {
7245 ✗ return modelicaParser::RuleNamed_argument;
7246 }
7247
7248 ✗ void modelicaParser::Named_argumentContext::enterRule(tree::ParseTreeListener* listener) {
7249 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7250 ✗ if (parserListener != nullptr) parserListener->enterNamed_argument(this);
7251 ✗ }
7252
7253 ✗ void modelicaParser::Named_argumentContext::exitRule(tree::ParseTreeListener* listener) {
7254 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7255 ✗ if (parserListener != nullptr) parserListener->exitNamed_argument(this);
7256 ✗ }
7257
7258 ✗ std::any modelicaParser::Named_argumentContext::accept(tree::ParseTreeVisitor* visitor) {
7259 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7260 ✗ return parserVisitor->visitNamed_argument(this);
7261 else
7262 ✗ return visitor->visitChildren(this);
7263 }
7264
7265 ✗ modelicaParser::Named_argumentContext* modelicaParser::named_argument() {
7266 ✗ Named_argumentContext* _localctx = _tracker.createInstance<Named_argumentContext>(_ctx, getState());
7267 ✗ enterRule(_localctx, 140, modelicaParser::RuleNamed_argument);
7268
7269 #if __cplusplus > 201703L
7270 ✗ auto onExit = finally([=, this] {
7271 #else
7272 auto onExit = finally([=] {
7273 #endif
7274 ✗ exitRule();
7275 ✗ });
7276 try {
7277 ✗ enterOuterAlt(_localctx, 1);
7278 ✗ setState(958);
7279 ✗ match(modelicaParser::IDENT);
7280 ✗ setState(959);
7281 ✗ match(modelicaParser::T__19);
7282 ✗ setState(960);
7283 ✗ function_argument();
7284
7285 ✗ } catch (RecognitionException& e) {
7286 ✗ _errHandler->reportError(this, e);
7287 ✗ _localctx->exception = std::current_exception();
7288 ✗ _errHandler->recover(this, _localctx->exception);
7289 ✗ }
7290
7291 ✗ return _localctx;
7292 ✗ }
7293
7294 //----------------- Function_argumentContext ------------------------------------------------------------------
7295
7296 ✗ modelicaParser::Function_argumentContext::Function_argumentContext(ParserRuleContext* parent, size_t invokingState)
7297 ✗ : ParserRuleContext(parent, invokingState) {}
7298
7299 ✗ modelicaParser::NameContext* modelicaParser::Function_argumentContext::name() {
7300 ✗ return getRuleContext<modelicaParser::NameContext>(0);
7301 }
7302
7303 ✗ modelicaParser::Named_argumentsContext* modelicaParser::Function_argumentContext::named_arguments() {
7304 ✗ return getRuleContext<modelicaParser::Named_argumentsContext>(0);
7305 }
7306
7307 ✗ modelicaParser::ExpressionContext* modelicaParser::Function_argumentContext::expression() {
7308 ✗ return getRuleContext<modelicaParser::ExpressionContext>(0);
7309 }
7310
7311 ✗ size_t modelicaParser::Function_argumentContext::getRuleIndex() const {
7312 ✗ return modelicaParser::RuleFunction_argument;
7313 }
7314
7315 ✗ void modelicaParser::Function_argumentContext::enterRule(tree::ParseTreeListener* listener) {
7316 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7317 ✗ if (parserListener != nullptr) parserListener->enterFunction_argument(this);
7318 ✗ }
7319
7320 ✗ void modelicaParser::Function_argumentContext::exitRule(tree::ParseTreeListener* listener) {
7321 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7322 ✗ if (parserListener != nullptr) parserListener->exitFunction_argument(this);
7323 ✗ }
7324
7325 ✗ std::any modelicaParser::Function_argumentContext::accept(tree::ParseTreeVisitor* visitor) {
7326 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7327 ✗ return parserVisitor->visitFunction_argument(this);
7328 else
7329 ✗ return visitor->visitChildren(this);
7330 }
7331
7332 ✗ modelicaParser::Function_argumentContext* modelicaParser::function_argument() {
7333 ✗ Function_argumentContext* _localctx = _tracker.createInstance<Function_argumentContext>(_ctx, getState());
7334 ✗ enterRule(_localctx, 142, modelicaParser::RuleFunction_argument);
7335 ✗ size_t _la = 0;
7336
7337 #if __cplusplus > 201703L
7338 ✗ auto onExit = finally([=, this] {
7339 #else
7340 auto onExit = finally([=] {
7341 #endif
7342 ✗ exitRule();
7343 ✗ });
7344 try {
7345 ✗ setState(971);
7346 ✗ _errHandler->sync(this);
7347 ✗ switch (_input->LA(1)) {
7348 ✗ case modelicaParser::T__16: {
7349 ✗ enterOuterAlt(_localctx, 1);
7350 ✗ setState(962);
7351 ✗ match(modelicaParser::T__16);
7352 ✗ setState(963);
7353 ✗ name();
7354 ✗ setState(964);
7355 ✗ match(modelicaParser::T__21);
7356 ✗ setState(966);
7357 ✗ _errHandler->sync(this);
7358
7359 ✗ _la = _input->LA(1);
7360 ✗ if (_la == modelicaParser::IDENT) {
7361 ✗ setState(965);
7362 ✗ named_arguments();
7363 }
7364 ✗ setState(968);
7365 ✗ match(modelicaParser::T__23);
7366 ✗ break;
7367 }
7368
7369 ✗ case modelicaParser::T__17:
7370 case modelicaParser::T__21:
7371 case modelicaParser::T__24:
7372 case modelicaParser::T__45:
7373 case modelicaParser::T__48:
7374 case modelicaParser::T__65:
7375 case modelicaParser::T__72:
7376 case modelicaParser::T__73:
7377 case modelicaParser::T__74:
7378 case modelicaParser::T__75:
7379 case modelicaParser::T__81:
7380 case modelicaParser::T__82:
7381 case modelicaParser::T__83:
7382 case modelicaParser::T__85:
7383 case modelicaParser::T__86:
7384 case modelicaParser::IDENT:
7385 case modelicaParser::STRING:
7386 case modelicaParser::UNSIGNED_NUMBER: {
7387 ✗ enterOuterAlt(_localctx, 2);
7388 ✗ setState(970);
7389 ✗ expression();
7390 ✗ break;
7391 }
7392
7393 ✗ default:
7394 ✗ throw NoViableAltException(this);
7395 }
7396
7397 ✗ } catch (RecognitionException& e) {
7398 ✗ _errHandler->reportError(this, e);
7399 ✗ _localctx->exception = std::current_exception();
7400 ✗ _errHandler->recover(this, _localctx->exception);
7401 ✗ }
7402
7403 ✗ return _localctx;
7404 ✗ }
7405
7406 //----------------- Output_expression_listContext ------------------------------------------------------------------
7407
7408 ✗ modelicaParser::Output_expression_listContext::Output_expression_listContext(ParserRuleContext* parent, size_t invokingState)
7409 ✗ : ParserRuleContext(parent, invokingState) {}
7410
7411 ✗ std::vector<modelicaParser::ExpressionContext*> modelicaParser::Output_expression_listContext::expression() {
7412 ✗ return getRuleContexts<modelicaParser::ExpressionContext>();
7413 }
7414
7415 ✗ modelicaParser::ExpressionContext* modelicaParser::Output_expression_listContext::expression(size_t i) {
7416 ✗ return getRuleContext<modelicaParser::ExpressionContext>(i);
7417 }
7418
7419 ✗ size_t modelicaParser::Output_expression_listContext::getRuleIndex() const {
7420 ✗ return modelicaParser::RuleOutput_expression_list;
7421 }
7422
7423 ✗ void modelicaParser::Output_expression_listContext::enterRule(tree::ParseTreeListener* listener) {
7424 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7425 ✗ if (parserListener != nullptr) parserListener->enterOutput_expression_list(this);
7426 ✗ }
7427
7428 ✗ void modelicaParser::Output_expression_listContext::exitRule(tree::ParseTreeListener* listener) {
7429 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7430 ✗ if (parserListener != nullptr) parserListener->exitOutput_expression_list(this);
7431 ✗ }
7432
7433 ✗ std::any modelicaParser::Output_expression_listContext::accept(tree::ParseTreeVisitor* visitor) {
7434 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7435 ✗ return parserVisitor->visitOutput_expression_list(this);
7436 else
7437 ✗ return visitor->visitChildren(this);
7438 }
7439
7440 ✗ modelicaParser::Output_expression_listContext* modelicaParser::output_expression_list() {
7441 ✗ Output_expression_listContext* _localctx = _tracker.createInstance<Output_expression_listContext>(_ctx, getState());
7442 ✗ enterRule(_localctx, 144, modelicaParser::RuleOutput_expression_list);
7443 ✗ size_t _la = 0;
7444
7445 #if __cplusplus > 201703L
7446 ✗ auto onExit = finally([=, this] {
7447 #else
7448 auto onExit = finally([=] {
7449 #endif
7450 ✗ exitRule();
7451 ✗ });
7452 try {
7453 ✗ enterOuterAlt(_localctx, 1);
7454 ✗ setState(974);
7455 ✗ _errHandler->sync(this);
7456
7457 ✗ _la = _input->LA(1);
7458 ✗ if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 633318735609856) != 0)
7459 ✗ || ((((_la - 66) & ~0x3fULL) == 0) && ((1ULL << (_la - 66)) & 62326657) != 0)) {
7460 ✗ setState(973);
7461 ✗ expression();
7462 }
7463 ✗ setState(982);
7464 ✗ _errHandler->sync(this);
7465 ✗ _la = _input->LA(1);
7466 ✗ while (_la == modelicaParser::T__25) {
7467 ✗ setState(976);
7468 ✗ match(modelicaParser::T__25);
7469 ✗ setState(978);
7470 ✗ _errHandler->sync(this);
7471
7472 ✗ _la = _input->LA(1);
7473 ✗ if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 633318735609856) != 0)
7474 ✗ || ((((_la - 66) & ~0x3fULL) == 0) && ((1ULL << (_la - 66)) & 62326657) != 0)) {
7475 ✗ setState(977);
7476 ✗ expression();
7477 }
7478 ✗ setState(984);
7479 ✗ _errHandler->sync(this);
7480 ✗ _la = _input->LA(1);
7481 }
7482
7483 ✗ } catch (RecognitionException& e) {
7484 ✗ _errHandler->reportError(this, e);
7485 ✗ _localctx->exception = std::current_exception();
7486 ✗ _errHandler->recover(this, _localctx->exception);
7487 ✗ }
7488
7489 ✗ return _localctx;
7490 ✗ }
7491
7492 //----------------- Expression_listContext ------------------------------------------------------------------
7493
7494 ✗ modelicaParser::Expression_listContext::Expression_listContext(ParserRuleContext* parent, size_t invokingState)
7495 ✗ : ParserRuleContext(parent, invokingState) {}
7496
7497 ✗ std::vector<modelicaParser::ExpressionContext*> modelicaParser::Expression_listContext::expression() {
7498 ✗ return getRuleContexts<modelicaParser::ExpressionContext>();
7499 }
7500
7501 ✗ modelicaParser::ExpressionContext* modelicaParser::Expression_listContext::expression(size_t i) {
7502 ✗ return getRuleContext<modelicaParser::ExpressionContext>(i);
7503 }
7504
7505 ✗ size_t modelicaParser::Expression_listContext::getRuleIndex() const {
7506 ✗ return modelicaParser::RuleExpression_list;
7507 }
7508
7509 ✗ void modelicaParser::Expression_listContext::enterRule(tree::ParseTreeListener* listener) {
7510 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7511 ✗ if (parserListener != nullptr) parserListener->enterExpression_list(this);
7512 ✗ }
7513
7514 ✗ void modelicaParser::Expression_listContext::exitRule(tree::ParseTreeListener* listener) {
7515 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7516 ✗ if (parserListener != nullptr) parserListener->exitExpression_list(this);
7517 ✗ }
7518
7519 ✗ std::any modelicaParser::Expression_listContext::accept(tree::ParseTreeVisitor* visitor) {
7520 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7521 ✗ return parserVisitor->visitExpression_list(this);
7522 else
7523 ✗ return visitor->visitChildren(this);
7524 }
7525
7526 ✗ modelicaParser::Expression_listContext* modelicaParser::expression_list() {
7527 ✗ Expression_listContext* _localctx = _tracker.createInstance<Expression_listContext>(_ctx, getState());
7528 ✗ enterRule(_localctx, 146, modelicaParser::RuleExpression_list);
7529 ✗ size_t _la = 0;
7530
7531 #if __cplusplus > 201703L
7532 ✗ auto onExit = finally([=, this] {
7533 #else
7534 auto onExit = finally([=] {
7535 #endif
7536 ✗ exitRule();
7537 ✗ });
7538 try {
7539 ✗ enterOuterAlt(_localctx, 1);
7540 ✗ setState(985);
7541 ✗ expression();
7542 ✗ setState(990);
7543 ✗ _errHandler->sync(this);
7544 ✗ _la = _input->LA(1);
7545 ✗ while (_la == modelicaParser::T__25) {
7546 ✗ setState(986);
7547 ✗ match(modelicaParser::T__25);
7548 ✗ setState(987);
7549 ✗ expression();
7550 ✗ setState(992);
7551 ✗ _errHandler->sync(this);
7552 ✗ _la = _input->LA(1);
7553 }
7554
7555 ✗ } catch (RecognitionException& e) {
7556 ✗ _errHandler->reportError(this, e);
7557 ✗ _localctx->exception = std::current_exception();
7558 ✗ _errHandler->recover(this, _localctx->exception);
7559 ✗ }
7560
7561 ✗ return _localctx;
7562 ✗ }
7563
7564 //----------------- Array_subscriptsContext ------------------------------------------------------------------
7565
7566 ✗ modelicaParser::Array_subscriptsContext::Array_subscriptsContext(ParserRuleContext* parent, size_t invokingState)
7567 ✗ : ParserRuleContext(parent, invokingState) {}
7568
7569 ✗ std::vector<modelicaParser::SubscriptContext*> modelicaParser::Array_subscriptsContext::subscript() {
7570 ✗ return getRuleContexts<modelicaParser::SubscriptContext>();
7571 }
7572
7573 ✗ modelicaParser::SubscriptContext* modelicaParser::Array_subscriptsContext::subscript(size_t i) {
7574 ✗ return getRuleContext<modelicaParser::SubscriptContext>(i);
7575 }
7576
7577 ✗ size_t modelicaParser::Array_subscriptsContext::getRuleIndex() const {
7578 ✗ return modelicaParser::RuleArray_subscripts;
7579 }
7580
7581 ✗ void modelicaParser::Array_subscriptsContext::enterRule(tree::ParseTreeListener* listener) {
7582 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7583 ✗ if (parserListener != nullptr) parserListener->enterArray_subscripts(this);
7584 ✗ }
7585
7586 ✗ void modelicaParser::Array_subscriptsContext::exitRule(tree::ParseTreeListener* listener) {
7587 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7588 ✗ if (parserListener != nullptr) parserListener->exitArray_subscripts(this);
7589 ✗ }
7590
7591 ✗ std::any modelicaParser::Array_subscriptsContext::accept(tree::ParseTreeVisitor* visitor) {
7592 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7593 ✗ return parserVisitor->visitArray_subscripts(this);
7594 else
7595 ✗ return visitor->visitChildren(this);
7596 }
7597
7598 ✗ modelicaParser::Array_subscriptsContext* modelicaParser::array_subscripts() {
7599 ✗ Array_subscriptsContext* _localctx = _tracker.createInstance<Array_subscriptsContext>(_ctx, getState());
7600 ✗ enterRule(_localctx, 148, modelicaParser::RuleArray_subscripts);
7601 ✗ size_t _la = 0;
7602
7603 #if __cplusplus > 201703L
7604 ✗ auto onExit = finally([=, this] {
7605 #else
7606 auto onExit = finally([=] {
7607 #endif
7608 ✗ exitRule();
7609 ✗ });
7610 try {
7611 ✗ enterOuterAlt(_localctx, 1);
7612 ✗ setState(993);
7613 ✗ match(modelicaParser::T__83);
7614 ✗ setState(994);
7615 ✗ subscript();
7616 ✗ setState(999);
7617 ✗ _errHandler->sync(this);
7618 ✗ _la = _input->LA(1);
7619 ✗ while (_la == modelicaParser::T__25) {
7620 ✗ setState(995);
7621 ✗ match(modelicaParser::T__25);
7622 ✗ setState(996);
7623 ✗ subscript();
7624 ✗ setState(1001);
7625 ✗ _errHandler->sync(this);
7626 ✗ _la = _input->LA(1);
7627 }
7628 ✗ setState(1002);
7629 ✗ match(modelicaParser::T__84);
7630
7631 ✗ } catch (RecognitionException& e) {
7632 ✗ _errHandler->reportError(this, e);
7633 ✗ _localctx->exception = std::current_exception();
7634 ✗ _errHandler->recover(this, _localctx->exception);
7635 ✗ }
7636
7637 ✗ return _localctx;
7638 ✗ }
7639
7640 //----------------- SubscriptContext ------------------------------------------------------------------
7641
7642 ✗ modelicaParser::SubscriptContext::SubscriptContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
7643
7644 ✗ modelicaParser::ExpressionContext* modelicaParser::SubscriptContext::expression() {
7645 ✗ return getRuleContext<modelicaParser::ExpressionContext>(0);
7646 }
7647
7648 ✗ size_t modelicaParser::SubscriptContext::getRuleIndex() const {
7649 ✗ return modelicaParser::RuleSubscript;
7650 }
7651
7652 ✗ void modelicaParser::SubscriptContext::enterRule(tree::ParseTreeListener* listener) {
7653 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7654 ✗ if (parserListener != nullptr) parserListener->enterSubscript(this);
7655 ✗ }
7656
7657 ✗ void modelicaParser::SubscriptContext::exitRule(tree::ParseTreeListener* listener) {
7658 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7659 ✗ if (parserListener != nullptr) parserListener->exitSubscript(this);
7660 ✗ }
7661
7662 ✗ std::any modelicaParser::SubscriptContext::accept(tree::ParseTreeVisitor* visitor) {
7663 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7664 ✗ return parserVisitor->visitSubscript(this);
7665 else
7666 ✗ return visitor->visitChildren(this);
7667 }
7668
7669 ✗ modelicaParser::SubscriptContext* modelicaParser::subscript() {
7670 ✗ SubscriptContext* _localctx = _tracker.createInstance<SubscriptContext>(_ctx, getState());
7671 ✗ enterRule(_localctx, 150, modelicaParser::RuleSubscript);
7672
7673 #if __cplusplus > 201703L
7674 ✗ auto onExit = finally([=, this] {
7675 #else
7676 auto onExit = finally([=] {
7677 #endif
7678 ✗ exitRule();
7679 ✗ });
7680 try {
7681 ✗ setState(1006);
7682 ✗ _errHandler->sync(this);
7683 ✗ switch (_input->LA(1)) {
7684 ✗ case modelicaParser::T__22: {
7685 ✗ enterOuterAlt(_localctx, 1);
7686 ✗ setState(1004);
7687 ✗ match(modelicaParser::T__22);
7688 ✗ break;
7689 }
7690
7691 ✗ case modelicaParser::T__17:
7692 case modelicaParser::T__21:
7693 case modelicaParser::T__24:
7694 case modelicaParser::T__45:
7695 case modelicaParser::T__48:
7696 case modelicaParser::T__65:
7697 case modelicaParser::T__72:
7698 case modelicaParser::T__73:
7699 case modelicaParser::T__74:
7700 case modelicaParser::T__75:
7701 case modelicaParser::T__81:
7702 case modelicaParser::T__82:
7703 case modelicaParser::T__83:
7704 case modelicaParser::T__85:
7705 case modelicaParser::T__86:
7706 case modelicaParser::IDENT:
7707 case modelicaParser::STRING:
7708 case modelicaParser::UNSIGNED_NUMBER: {
7709 ✗ enterOuterAlt(_localctx, 2);
7710 ✗ setState(1005);
7711 ✗ expression();
7712 ✗ break;
7713 }
7714
7715 ✗ default:
7716 ✗ throw NoViableAltException(this);
7717 }
7718
7719 ✗ } catch (RecognitionException& e) {
7720 ✗ _errHandler->reportError(this, e);
7721 ✗ _localctx->exception = std::current_exception();
7722 ✗ _errHandler->recover(this, _localctx->exception);
7723 ✗ }
7724
7725 ✗ return _localctx;
7726 ✗ }
7727
7728 //----------------- CommentContext ------------------------------------------------------------------
7729
7730 ✗ modelicaParser::CommentContext::CommentContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
7731
7732 ✗ modelicaParser::String_commentContext* modelicaParser::CommentContext::string_comment() {
7733 ✗ return getRuleContext<modelicaParser::String_commentContext>(0);
7734 }
7735
7736 ✗ modelicaParser::AnnotationContext* modelicaParser::CommentContext::annotation() {
7737 ✗ return getRuleContext<modelicaParser::AnnotationContext>(0);
7738 }
7739
7740 ✗ size_t modelicaParser::CommentContext::getRuleIndex() const {
7741 ✗ return modelicaParser::RuleComment;
7742 }
7743
7744 ✗ void modelicaParser::CommentContext::enterRule(tree::ParseTreeListener* listener) {
7745 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7746 ✗ if (parserListener != nullptr) parserListener->enterComment(this);
7747 ✗ }
7748
7749 ✗ void modelicaParser::CommentContext::exitRule(tree::ParseTreeListener* listener) {
7750 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7751 ✗ if (parserListener != nullptr) parserListener->exitComment(this);
7752 ✗ }
7753
7754 ✗ std::any modelicaParser::CommentContext::accept(tree::ParseTreeVisitor* visitor) {
7755 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7756 ✗ return parserVisitor->visitComment(this);
7757 else
7758 ✗ return visitor->visitChildren(this);
7759 }
7760
7761 ✗ modelicaParser::CommentContext* modelicaParser::comment() {
7762 ✗ CommentContext* _localctx = _tracker.createInstance<CommentContext>(_ctx, getState());
7763 ✗ enterRule(_localctx, 152, modelicaParser::RuleComment);
7764 ✗ size_t _la = 0;
7765
7766 #if __cplusplus > 201703L
7767 ✗ auto onExit = finally([=, this] {
7768 #else
7769 auto onExit = finally([=] {
7770 #endif
7771 ✗ exitRule();
7772 ✗ });
7773 try {
7774 ✗ enterOuterAlt(_localctx, 1);
7775 ✗ setState(1008);
7776 ✗ string_comment();
7777 ✗ setState(1010);
7778 ✗ _errHandler->sync(this);
7779
7780 ✗ _la = _input->LA(1);
7781 ✗ if (_la == modelicaParser::T__87) {
7782 ✗ setState(1009);
7783 ✗ annotation();
7784 }
7785
7786 ✗ } catch (RecognitionException& e) {
7787 ✗ _errHandler->reportError(this, e);
7788 ✗ _localctx->exception = std::current_exception();
7789 ✗ _errHandler->recover(this, _localctx->exception);
7790 ✗ }
7791
7792 ✗ return _localctx;
7793 ✗ }
7794
7795 //----------------- String_commentContext ------------------------------------------------------------------
7796
7797 ✗ modelicaParser::String_commentContext::String_commentContext(ParserRuleContext* parent, size_t invokingState)
7798 ✗ : ParserRuleContext(parent, invokingState) {}
7799
7800 ✗ std::vector<tree::TerminalNode*> modelicaParser::String_commentContext::STRING() {
7801 ✗ return getTokens(modelicaParser::STRING);
7802 }
7803
7804 ✗ tree::TerminalNode* modelicaParser::String_commentContext::STRING(size_t i) {
7805 ✗ return getToken(modelicaParser::STRING, i);
7806 }
7807
7808 ✗ size_t modelicaParser::String_commentContext::getRuleIndex() const {
7809 ✗ return modelicaParser::RuleString_comment;
7810 }
7811
7812 ✗ void modelicaParser::String_commentContext::enterRule(tree::ParseTreeListener* listener) {
7813 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7814 ✗ if (parserListener != nullptr) parserListener->enterString_comment(this);
7815 ✗ }
7816
7817 ✗ void modelicaParser::String_commentContext::exitRule(tree::ParseTreeListener* listener) {
7818 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7819 ✗ if (parserListener != nullptr) parserListener->exitString_comment(this);
7820 ✗ }
7821
7822 ✗ std::any modelicaParser::String_commentContext::accept(tree::ParseTreeVisitor* visitor) {
7823 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7824 ✗ return parserVisitor->visitString_comment(this);
7825 else
7826 ✗ return visitor->visitChildren(this);
7827 }
7828
7829 ✗ modelicaParser::String_commentContext* modelicaParser::string_comment() {
7830 ✗ String_commentContext* _localctx = _tracker.createInstance<String_commentContext>(_ctx, getState());
7831 ✗ enterRule(_localctx, 154, modelicaParser::RuleString_comment);
7832 ✗ size_t _la = 0;
7833
7834 #if __cplusplus > 201703L
7835 ✗ auto onExit = finally([=, this] {
7836 #else
7837 auto onExit = finally([=] {
7838 #endif
7839 ✗ exitRule();
7840 ✗ });
7841 try {
7842 ✗ enterOuterAlt(_localctx, 1);
7843 ✗ setState(1020);
7844 ✗ _errHandler->sync(this);
7845
7846 ✗ _la = _input->LA(1);
7847 ✗ if (_la == modelicaParser::STRING) {
7848 ✗ setState(1012);
7849 ✗ match(modelicaParser::STRING);
7850 ✗ setState(1017);
7851 ✗ _errHandler->sync(this);
7852 ✗ _la = _input->LA(1);
7853 ✗ while (_la == modelicaParser::T__72) {
7854 ✗ setState(1013);
7855 ✗ match(modelicaParser::T__72);
7856 ✗ setState(1014);
7857 ✗ match(modelicaParser::STRING);
7858 ✗ setState(1019);
7859 ✗ _errHandler->sync(this);
7860 ✗ _la = _input->LA(1);
7861 }
7862 }
7863
7864 ✗ } catch (RecognitionException& e) {
7865 ✗ _errHandler->reportError(this, e);
7866 ✗ _localctx->exception = std::current_exception();
7867 ✗ _errHandler->recover(this, _localctx->exception);
7868 ✗ }
7869
7870 ✗ return _localctx;
7871 ✗ }
7872
7873 //----------------- Model_annotationContext ------------------------------------------------------------------
7874
7875 ✗ modelicaParser::Model_annotationContext::Model_annotationContext(ParserRuleContext* parent, size_t invokingState)
7876 ✗ : ParserRuleContext(parent, invokingState) {}
7877
7878 ✗ modelicaParser::AnnotationContext* modelicaParser::Model_annotationContext::annotation() {
7879 ✗ return getRuleContext<modelicaParser::AnnotationContext>(0);
7880 }
7881
7882 ✗ size_t modelicaParser::Model_annotationContext::getRuleIndex() const {
7883 ✗ return modelicaParser::RuleModel_annotation;
7884 }
7885
7886 ✗ void modelicaParser::Model_annotationContext::enterRule(tree::ParseTreeListener* listener) {
7887 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7888 ✗ if (parserListener != nullptr) parserListener->enterModel_annotation(this);
7889 ✗ }
7890
7891 ✗ void modelicaParser::Model_annotationContext::exitRule(tree::ParseTreeListener* listener) {
7892 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7893 ✗ if (parserListener != nullptr) parserListener->exitModel_annotation(this);
7894 ✗ }
7895
7896 ✗ std::any modelicaParser::Model_annotationContext::accept(tree::ParseTreeVisitor* visitor) {
7897 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7898 ✗ return parserVisitor->visitModel_annotation(this);
7899 else
7900 ✗ return visitor->visitChildren(this);
7901 }
7902
7903 ✗ modelicaParser::Model_annotationContext* modelicaParser::model_annotation() {
7904 ✗ Model_annotationContext* _localctx = _tracker.createInstance<Model_annotationContext>(_ctx, getState());
7905 ✗ enterRule(_localctx, 156, modelicaParser::RuleModel_annotation);
7906
7907 #if __cplusplus > 201703L
7908 ✗ auto onExit = finally([=, this] {
7909 #else
7910 auto onExit = finally([=] {
7911 #endif
7912 ✗ exitRule();
7913 ✗ });
7914 try {
7915 ✗ enterOuterAlt(_localctx, 1);
7916 ✗ setState(1022);
7917 ✗ annotation();
7918
7919 ✗ } catch (RecognitionException& e) {
7920 ✗ _errHandler->reportError(this, e);
7921 ✗ _localctx->exception = std::current_exception();
7922 ✗ _errHandler->recover(this, _localctx->exception);
7923 ✗ }
7924
7925 ✗ return _localctx;
7926 ✗ }
7927
7928 //----------------- AnnotationContext ------------------------------------------------------------------
7929
7930 ✗ modelicaParser::AnnotationContext::AnnotationContext(ParserRuleContext* parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {}
7931
7932 ✗ modelicaParser::Class_modificationContext* modelicaParser::AnnotationContext::class_modification() {
7933 ✗ return getRuleContext<modelicaParser::Class_modificationContext>(0);
7934 }
7935
7936 ✗ size_t modelicaParser::AnnotationContext::getRuleIndex() const {
7937 ✗ return modelicaParser::RuleAnnotation;
7938 }
7939
7940 ✗ void modelicaParser::AnnotationContext::enterRule(tree::ParseTreeListener* listener) {
7941 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7942 ✗ if (parserListener != nullptr) parserListener->enterAnnotation(this);
7943 ✗ }
7944
7945 ✗ void modelicaParser::AnnotationContext::exitRule(tree::ParseTreeListener* listener) {
7946 ✗ auto parserListener = dynamic_cast<modelicaListener*>(listener);
7947 ✗ if (parserListener != nullptr) parserListener->exitAnnotation(this);
7948 ✗ }
7949
7950 ✗ std::any modelicaParser::AnnotationContext::accept(tree::ParseTreeVisitor* visitor) {
7951 ✗ if (auto parserVisitor = dynamic_cast<modelicaVisitor*>(visitor))
7952 ✗ return parserVisitor->visitAnnotation(this);
7953 else
7954 ✗ return visitor->visitChildren(this);
7955 }
7956
7957 ✗ modelicaParser::AnnotationContext* modelicaParser::annotation() {
7958 ✗ AnnotationContext* _localctx = _tracker.createInstance<AnnotationContext>(_ctx, getState());
7959 ✗ enterRule(_localctx, 158, modelicaParser::RuleAnnotation);
7960
7961 #if __cplusplus > 201703L
7962 ✗ auto onExit = finally([=, this] {
7963 #else
7964 auto onExit = finally([=] {
7965 #endif
7966 ✗ exitRule();
7967 ✗ });
7968 try {
7969 ✗ enterOuterAlt(_localctx, 1);
7970 ✗ setState(1024);
7971 ✗ match(modelicaParser::T__87);
7972 ✗ setState(1025);
7973 ✗ class_modification();
7974
7975 ✗ } catch (RecognitionException& e) {
7976 ✗ _errHandler->reportError(this, e);
7977 ✗ _localctx->exception = std::current_exception();
7978 ✗ _errHandler->recover(this, _localctx->exception);
7979 ✗ }
7980
7981 ✗ return _localctx;
7982 ✗ }
7983
7984 ✗ void modelicaParser::initialize() {
7985 #if ANTLR4_USE_THREAD_LOCAL_CACHE
7986 modelicaParserInitialize();
7987 #else
7988 ✗ ::antlr4::internal::call_once(modelicaParserOnceFlag, modelicaParserInitialize);
7989 #endif
7990 ✗ }
7991