diff options
Diffstat (limited to 'Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/parser/antlr/internal/InternalVampireLanguage.g')
-rw-r--r-- | Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/parser/antlr/internal/InternalVampireLanguage.g | 2521 |
1 files changed, 2521 insertions, 0 deletions
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/parser/antlr/internal/InternalVampireLanguage.g b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/parser/antlr/internal/InternalVampireLanguage.g new file mode 100644 index 00000000..2ab53393 --- /dev/null +++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/parser/antlr/internal/InternalVampireLanguage.g | |||
@@ -0,0 +1,2521 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.12.0 | ||
3 | */ | ||
4 | grammar InternalVampireLanguage; | ||
5 | |||
6 | options { | ||
7 | superClass=AbstractInternalAntlrParser; | ||
8 | } | ||
9 | |||
10 | @lexer::header { | ||
11 | package ca.mcgill.ecse.dslreasoner.parser.antlr.internal; | ||
12 | |||
13 | // Hack: Use our own Lexer superclass by means of import. | ||
14 | // Currently there is no other way to specify the superclass for the lexer. | ||
15 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
16 | } | ||
17 | |||
18 | @parser::header { | ||
19 | package ca.mcgill.ecse.dslreasoner.parser.antlr.internal; | ||
20 | |||
21 | import org.eclipse.xtext.*; | ||
22 | import org.eclipse.xtext.parser.*; | ||
23 | import org.eclipse.xtext.parser.impl.*; | ||
24 | import org.eclipse.emf.ecore.util.EcoreUtil; | ||
25 | import org.eclipse.emf.ecore.EObject; | ||
26 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; | ||
27 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
28 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | ||
29 | import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; | ||
30 | import ca.mcgill.ecse.dslreasoner.services.VampireLanguageGrammarAccess; | ||
31 | |||
32 | } | ||
33 | |||
34 | @parser::members { | ||
35 | |||
36 | private VampireLanguageGrammarAccess grammarAccess; | ||
37 | |||
38 | public InternalVampireLanguageParser(TokenStream input, VampireLanguageGrammarAccess grammarAccess) { | ||
39 | this(input); | ||
40 | this.grammarAccess = grammarAccess; | ||
41 | registerRules(grammarAccess.getGrammar()); | ||
42 | } | ||
43 | |||
44 | @Override | ||
45 | protected String getFirstRuleName() { | ||
46 | return "VampireModel"; | ||
47 | } | ||
48 | |||
49 | @Override | ||
50 | protected VampireLanguageGrammarAccess getGrammarAccess() { | ||
51 | return grammarAccess; | ||
52 | } | ||
53 | |||
54 | } | ||
55 | |||
56 | @rulecatch { | ||
57 | catch (RecognitionException re) { | ||
58 | recover(input,re); | ||
59 | appendSkippedTokens(); | ||
60 | } | ||
61 | } | ||
62 | |||
63 | // Entry rule entryRuleVampireModel | ||
64 | entryRuleVampireModel returns [EObject current=null]: | ||
65 | { newCompositeNode(grammarAccess.getVampireModelRule()); } | ||
66 | iv_ruleVampireModel=ruleVampireModel | ||
67 | { $current=$iv_ruleVampireModel.current; } | ||
68 | EOF; | ||
69 | |||
70 | // Rule VampireModel | ||
71 | ruleVampireModel returns [EObject current=null] | ||
72 | @init { | ||
73 | enterRule(); | ||
74 | } | ||
75 | @after { | ||
76 | leaveRule(); | ||
77 | }: | ||
78 | ( | ||
79 | ( | ||
80 | ( | ||
81 | { | ||
82 | newCompositeNode(grammarAccess.getVampireModelAccess().getIncludesVLSIncludeParserRuleCall_0_0()); | ||
83 | } | ||
84 | lv_includes_0_0=ruleVLSInclude | ||
85 | { | ||
86 | if ($current==null) { | ||
87 | $current = createModelElementForParent(grammarAccess.getVampireModelRule()); | ||
88 | } | ||
89 | add( | ||
90 | $current, | ||
91 | "includes", | ||
92 | lv_includes_0_0, | ||
93 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSInclude"); | ||
94 | afterParserOrEnumRuleCall(); | ||
95 | } | ||
96 | ) | ||
97 | ) | ||
98 | | | ||
99 | ( | ||
100 | ( | ||
101 | { | ||
102 | newCompositeNode(grammarAccess.getVampireModelAccess().getCommentsVLSCommentParserRuleCall_1_0()); | ||
103 | } | ||
104 | lv_comments_1_0=ruleVLSComment | ||
105 | { | ||
106 | if ($current==null) { | ||
107 | $current = createModelElementForParent(grammarAccess.getVampireModelRule()); | ||
108 | } | ||
109 | add( | ||
110 | $current, | ||
111 | "comments", | ||
112 | lv_comments_1_0, | ||
113 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSComment"); | ||
114 | afterParserOrEnumRuleCall(); | ||
115 | } | ||
116 | ) | ||
117 | ) | ||
118 | | | ||
119 | ( | ||
120 | ( | ||
121 | { | ||
122 | newCompositeNode(grammarAccess.getVampireModelAccess().getConfirmationsVLSConfirmationsParserRuleCall_2_0()); | ||
123 | } | ||
124 | lv_confirmations_2_0=ruleVLSConfirmations | ||
125 | { | ||
126 | if ($current==null) { | ||
127 | $current = createModelElementForParent(grammarAccess.getVampireModelRule()); | ||
128 | } | ||
129 | add( | ||
130 | $current, | ||
131 | "confirmations", | ||
132 | lv_confirmations_2_0, | ||
133 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSConfirmations"); | ||
134 | afterParserOrEnumRuleCall(); | ||
135 | } | ||
136 | ) | ||
137 | ) | ||
138 | | | ||
139 | ( | ||
140 | ( | ||
141 | { | ||
142 | newCompositeNode(grammarAccess.getVampireModelAccess().getFormulasVLSFofFormulaParserRuleCall_3_0()); | ||
143 | } | ||
144 | lv_formulas_3_0=ruleVLSFofFormula | ||
145 | { | ||
146 | if ($current==null) { | ||
147 | $current = createModelElementForParent(grammarAccess.getVampireModelRule()); | ||
148 | } | ||
149 | add( | ||
150 | $current, | ||
151 | "formulas", | ||
152 | lv_formulas_3_0, | ||
153 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSFofFormula"); | ||
154 | afterParserOrEnumRuleCall(); | ||
155 | } | ||
156 | ) | ||
157 | ) | ||
158 | | | ||
159 | ( | ||
160 | ( | ||
161 | { | ||
162 | newCompositeNode(grammarAccess.getVampireModelAccess().getTfformulasVLSTffFormulaParserRuleCall_4_0()); | ||
163 | } | ||
164 | lv_tfformulas_4_0=ruleVLSTffFormula | ||
165 | { | ||
166 | if ($current==null) { | ||
167 | $current = createModelElementForParent(grammarAccess.getVampireModelRule()); | ||
168 | } | ||
169 | add( | ||
170 | $current, | ||
171 | "tfformulas", | ||
172 | lv_tfformulas_4_0, | ||
173 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSTffFormula"); | ||
174 | afterParserOrEnumRuleCall(); | ||
175 | } | ||
176 | ) | ||
177 | ) | ||
178 | )* | ||
179 | ; | ||
180 | |||
181 | // Entry rule entryRuleVLSInclude | ||
182 | entryRuleVLSInclude returns [EObject current=null]: | ||
183 | { newCompositeNode(grammarAccess.getVLSIncludeRule()); } | ||
184 | iv_ruleVLSInclude=ruleVLSInclude | ||
185 | { $current=$iv_ruleVLSInclude.current; } | ||
186 | EOF; | ||
187 | |||
188 | // Rule VLSInclude | ||
189 | ruleVLSInclude returns [EObject current=null] | ||
190 | @init { | ||
191 | enterRule(); | ||
192 | } | ||
193 | @after { | ||
194 | leaveRule(); | ||
195 | }: | ||
196 | ( | ||
197 | otherlv_0='include(' | ||
198 | { | ||
199 | newLeafNode(otherlv_0, grammarAccess.getVLSIncludeAccess().getIncludeKeyword_0()); | ||
200 | } | ||
201 | ( | ||
202 | ( | ||
203 | lv_fileName_1_0=RULE_SINGLE_QUOTE | ||
204 | { | ||
205 | newLeafNode(lv_fileName_1_0, grammarAccess.getVLSIncludeAccess().getFileNameSINGLE_QUOTETerminalRuleCall_1_0()); | ||
206 | } | ||
207 | { | ||
208 | if ($current==null) { | ||
209 | $current = createModelElement(grammarAccess.getVLSIncludeRule()); | ||
210 | } | ||
211 | setWithLastConsumed( | ||
212 | $current, | ||
213 | "fileName", | ||
214 | lv_fileName_1_0, | ||
215 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SINGLE_QUOTE"); | ||
216 | } | ||
217 | ) | ||
218 | ) | ||
219 | ( | ||
220 | otherlv_2=',[' | ||
221 | { | ||
222 | newLeafNode(otherlv_2, grammarAccess.getVLSIncludeAccess().getCommaLeftSquareBracketKeyword_2_0()); | ||
223 | } | ||
224 | ( | ||
225 | ( | ||
226 | { | ||
227 | newCompositeNode(grammarAccess.getVLSIncludeAccess().getNamesVLSNameParserRuleCall_2_1_0()); | ||
228 | } | ||
229 | lv_names_3_0=ruleVLSName | ||
230 | { | ||
231 | if ($current==null) { | ||
232 | $current = createModelElementForParent(grammarAccess.getVLSIncludeRule()); | ||
233 | } | ||
234 | add( | ||
235 | $current, | ||
236 | "names", | ||
237 | lv_names_3_0, | ||
238 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSName"); | ||
239 | afterParserOrEnumRuleCall(); | ||
240 | } | ||
241 | ) | ||
242 | ) | ||
243 | ( | ||
244 | otherlv_4=',' | ||
245 | { | ||
246 | newLeafNode(otherlv_4, grammarAccess.getVLSIncludeAccess().getCommaKeyword_2_2_0()); | ||
247 | } | ||
248 | ( | ||
249 | ( | ||
250 | { | ||
251 | newCompositeNode(grammarAccess.getVLSIncludeAccess().getNamesVLSNameParserRuleCall_2_2_1_0()); | ||
252 | } | ||
253 | lv_names_5_0=ruleVLSName | ||
254 | { | ||
255 | if ($current==null) { | ||
256 | $current = createModelElementForParent(grammarAccess.getVLSIncludeRule()); | ||
257 | } | ||
258 | add( | ||
259 | $current, | ||
260 | "names", | ||
261 | lv_names_5_0, | ||
262 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSName"); | ||
263 | afterParserOrEnumRuleCall(); | ||
264 | } | ||
265 | ) | ||
266 | ) | ||
267 | )* | ||
268 | otherlv_6=']' | ||
269 | { | ||
270 | newLeafNode(otherlv_6, grammarAccess.getVLSIncludeAccess().getRightSquareBracketKeyword_2_3()); | ||
271 | } | ||
272 | )? | ||
273 | ) | ||
274 | ; | ||
275 | |||
276 | // Entry rule entryRuleVLSName | ||
277 | entryRuleVLSName returns [EObject current=null]: | ||
278 | { newCompositeNode(grammarAccess.getVLSNameRule()); } | ||
279 | iv_ruleVLSName=ruleVLSName | ||
280 | { $current=$iv_ruleVLSName.current; } | ||
281 | EOF; | ||
282 | |||
283 | // Rule VLSName | ||
284 | ruleVLSName returns [EObject current=null] | ||
285 | @init { | ||
286 | enterRule(); | ||
287 | } | ||
288 | @after { | ||
289 | leaveRule(); | ||
290 | }: | ||
291 | ( | ||
292 | ( | ||
293 | ( | ||
294 | lv_name_0_1=RULE_LOWER_WORD_ID | ||
295 | { | ||
296 | newLeafNode(lv_name_0_1, grammarAccess.getVLSNameAccess().getNameLOWER_WORD_IDTerminalRuleCall_0_0()); | ||
297 | } | ||
298 | { | ||
299 | if ($current==null) { | ||
300 | $current = createModelElement(grammarAccess.getVLSNameRule()); | ||
301 | } | ||
302 | setWithLastConsumed( | ||
303 | $current, | ||
304 | "name", | ||
305 | lv_name_0_1, | ||
306 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.LOWER_WORD_ID"); | ||
307 | } | ||
308 | | | ||
309 | lv_name_0_2=RULE_SINGLE_QUOTE | ||
310 | { | ||
311 | newLeafNode(lv_name_0_2, grammarAccess.getVLSNameAccess().getNameSINGLE_QUOTETerminalRuleCall_0_1()); | ||
312 | } | ||
313 | { | ||
314 | if ($current==null) { | ||
315 | $current = createModelElement(grammarAccess.getVLSNameRule()); | ||
316 | } | ||
317 | setWithLastConsumed( | ||
318 | $current, | ||
319 | "name", | ||
320 | lv_name_0_2, | ||
321 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SINGLE_QUOTE"); | ||
322 | } | ||
323 | | | ||
324 | lv_name_0_3=RULE_LITERAL | ||
325 | { | ||
326 | newLeafNode(lv_name_0_3, grammarAccess.getVLSNameAccess().getNameLITERALTerminalRuleCall_0_2()); | ||
327 | } | ||
328 | { | ||
329 | if ($current==null) { | ||
330 | $current = createModelElement(grammarAccess.getVLSNameRule()); | ||
331 | } | ||
332 | setWithLastConsumed( | ||
333 | $current, | ||
334 | "name", | ||
335 | lv_name_0_3, | ||
336 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.LITERAL"); | ||
337 | } | ||
338 | | | ||
339 | lv_name_0_4=RULE_SIGNED_LITERAL | ||
340 | { | ||
341 | newLeafNode(lv_name_0_4, grammarAccess.getVLSNameAccess().getNameSIGNED_LITERALTerminalRuleCall_0_3()); | ||
342 | } | ||
343 | { | ||
344 | if ($current==null) { | ||
345 | $current = createModelElement(grammarAccess.getVLSNameRule()); | ||
346 | } | ||
347 | setWithLastConsumed( | ||
348 | $current, | ||
349 | "name", | ||
350 | lv_name_0_4, | ||
351 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SIGNED_LITERAL"); | ||
352 | } | ||
353 | ) | ||
354 | ) | ||
355 | ) | ||
356 | ; | ||
357 | |||
358 | // Entry rule entryRuleVLSComment | ||
359 | entryRuleVLSComment returns [EObject current=null]: | ||
360 | { newCompositeNode(grammarAccess.getVLSCommentRule()); } | ||
361 | iv_ruleVLSComment=ruleVLSComment | ||
362 | { $current=$iv_ruleVLSComment.current; } | ||
363 | EOF; | ||
364 | |||
365 | // Rule VLSComment | ||
366 | ruleVLSComment returns [EObject current=null] | ||
367 | @init { | ||
368 | enterRule(); | ||
369 | } | ||
370 | @after { | ||
371 | leaveRule(); | ||
372 | }: | ||
373 | ( | ||
374 | otherlv_0='%' | ||
375 | { | ||
376 | newLeafNode(otherlv_0, grammarAccess.getVLSCommentAccess().getPercentSignKeyword_0()); | ||
377 | } | ||
378 | ( | ||
379 | ( | ||
380 | lv_comment_1_0=RULE_SINGLE_COMMENT | ||
381 | { | ||
382 | newLeafNode(lv_comment_1_0, grammarAccess.getVLSCommentAccess().getCommentSINGLE_COMMENTTerminalRuleCall_1_0()); | ||
383 | } | ||
384 | { | ||
385 | if ($current==null) { | ||
386 | $current = createModelElement(grammarAccess.getVLSCommentRule()); | ||
387 | } | ||
388 | setWithLastConsumed( | ||
389 | $current, | ||
390 | "comment", | ||
391 | lv_comment_1_0, | ||
392 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SINGLE_COMMENT"); | ||
393 | } | ||
394 | ) | ||
395 | ) | ||
396 | ) | ||
397 | ; | ||
398 | |||
399 | // Entry rule entryRuleVLSConfirmations | ||
400 | entryRuleVLSConfirmations returns [EObject current=null]: | ||
401 | { newCompositeNode(grammarAccess.getVLSConfirmationsRule()); } | ||
402 | iv_ruleVLSConfirmations=ruleVLSConfirmations | ||
403 | { $current=$iv_ruleVLSConfirmations.current; } | ||
404 | EOF; | ||
405 | |||
406 | // Rule VLSConfirmations | ||
407 | ruleVLSConfirmations returns [EObject current=null] | ||
408 | @init { | ||
409 | enterRule(); | ||
410 | } | ||
411 | @after { | ||
412 | leaveRule(); | ||
413 | }: | ||
414 | { | ||
415 | newCompositeNode(grammarAccess.getVLSConfirmationsAccess().getVLSSatisfiableParserRuleCall()); | ||
416 | } | ||
417 | this_VLSSatisfiable_0=ruleVLSSatisfiable | ||
418 | { | ||
419 | $current = $this_VLSSatisfiable_0.current; | ||
420 | afterParserOrEnumRuleCall(); | ||
421 | } | ||
422 | ; | ||
423 | |||
424 | // Entry rule entryRuleVLSSatisfiable | ||
425 | entryRuleVLSSatisfiable returns [EObject current=null]: | ||
426 | { newCompositeNode(grammarAccess.getVLSSatisfiableRule()); } | ||
427 | iv_ruleVLSSatisfiable=ruleVLSSatisfiable | ||
428 | { $current=$iv_ruleVLSSatisfiable.current; } | ||
429 | EOF; | ||
430 | |||
431 | // Rule VLSSatisfiable | ||
432 | ruleVLSSatisfiable returns [EObject current=null] | ||
433 | @init { | ||
434 | enterRule(); | ||
435 | } | ||
436 | @after { | ||
437 | leaveRule(); | ||
438 | }: | ||
439 | ( | ||
440 | ( | ||
441 | { | ||
442 | $current = forceCreateModelElement( | ||
443 | grammarAccess.getVLSSatisfiableAccess().getVLSSatisfiableAction_0(), | ||
444 | $current); | ||
445 | } | ||
446 | ) | ||
447 | otherlv_1='Satisfiable!' | ||
448 | { | ||
449 | newLeafNode(otherlv_1, grammarAccess.getVLSSatisfiableAccess().getSatisfiableKeyword_1()); | ||
450 | } | ||
451 | ) | ||
452 | ; | ||
453 | |||
454 | // Entry rule entryRuleVLSFofFormula | ||
455 | entryRuleVLSFofFormula returns [EObject current=null]: | ||
456 | { newCompositeNode(grammarAccess.getVLSFofFormulaRule()); } | ||
457 | iv_ruleVLSFofFormula=ruleVLSFofFormula | ||
458 | { $current=$iv_ruleVLSFofFormula.current; } | ||
459 | EOF; | ||
460 | |||
461 | // Rule VLSFofFormula | ||
462 | ruleVLSFofFormula returns [EObject current=null] | ||
463 | @init { | ||
464 | enterRule(); | ||
465 | } | ||
466 | @after { | ||
467 | leaveRule(); | ||
468 | }: | ||
469 | ( | ||
470 | otherlv_0='fof' | ||
471 | { | ||
472 | newLeafNode(otherlv_0, grammarAccess.getVLSFofFormulaAccess().getFofKeyword_0()); | ||
473 | } | ||
474 | otherlv_1='(' | ||
475 | { | ||
476 | newLeafNode(otherlv_1, grammarAccess.getVLSFofFormulaAccess().getLeftParenthesisKeyword_1()); | ||
477 | } | ||
478 | ( | ||
479 | ( | ||
480 | ( | ||
481 | lv_name_2_1=RULE_LOWER_WORD_ID | ||
482 | { | ||
483 | newLeafNode(lv_name_2_1, grammarAccess.getVLSFofFormulaAccess().getNameLOWER_WORD_IDTerminalRuleCall_2_0_0()); | ||
484 | } | ||
485 | { | ||
486 | if ($current==null) { | ||
487 | $current = createModelElement(grammarAccess.getVLSFofFormulaRule()); | ||
488 | } | ||
489 | setWithLastConsumed( | ||
490 | $current, | ||
491 | "name", | ||
492 | lv_name_2_1, | ||
493 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.LOWER_WORD_ID"); | ||
494 | } | ||
495 | | | ||
496 | lv_name_2_2=RULE_SIGNED_LITERAL | ||
497 | { | ||
498 | newLeafNode(lv_name_2_2, grammarAccess.getVLSFofFormulaAccess().getNameSIGNED_LITERALTerminalRuleCall_2_0_1()); | ||
499 | } | ||
500 | { | ||
501 | if ($current==null) { | ||
502 | $current = createModelElement(grammarAccess.getVLSFofFormulaRule()); | ||
503 | } | ||
504 | setWithLastConsumed( | ||
505 | $current, | ||
506 | "name", | ||
507 | lv_name_2_2, | ||
508 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SIGNED_LITERAL"); | ||
509 | } | ||
510 | | | ||
511 | lv_name_2_3=RULE_SINGLE_QUOTE | ||
512 | { | ||
513 | newLeafNode(lv_name_2_3, grammarAccess.getVLSFofFormulaAccess().getNameSINGLE_QUOTETerminalRuleCall_2_0_2()); | ||
514 | } | ||
515 | { | ||
516 | if ($current==null) { | ||
517 | $current = createModelElement(grammarAccess.getVLSFofFormulaRule()); | ||
518 | } | ||
519 | setWithLastConsumed( | ||
520 | $current, | ||
521 | "name", | ||
522 | lv_name_2_3, | ||
523 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SINGLE_QUOTE"); | ||
524 | } | ||
525 | ) | ||
526 | ) | ||
527 | ) | ||
528 | otherlv_3=',' | ||
529 | { | ||
530 | newLeafNode(otherlv_3, grammarAccess.getVLSFofFormulaAccess().getCommaKeyword_3()); | ||
531 | } | ||
532 | ( | ||
533 | ( | ||
534 | { | ||
535 | newCompositeNode(grammarAccess.getVLSFofFormulaAccess().getFofRoleVLSRoleParserRuleCall_4_0()); | ||
536 | } | ||
537 | lv_fofRole_4_0=ruleVLSRole | ||
538 | { | ||
539 | if ($current==null) { | ||
540 | $current = createModelElementForParent(grammarAccess.getVLSFofFormulaRule()); | ||
541 | } | ||
542 | set( | ||
543 | $current, | ||
544 | "fofRole", | ||
545 | lv_fofRole_4_0, | ||
546 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSRole"); | ||
547 | afterParserOrEnumRuleCall(); | ||
548 | } | ||
549 | ) | ||
550 | ) | ||
551 | otherlv_5=',' | ||
552 | { | ||
553 | newLeafNode(otherlv_5, grammarAccess.getVLSFofFormulaAccess().getCommaKeyword_5()); | ||
554 | } | ||
555 | ( | ||
556 | ( | ||
557 | { | ||
558 | newCompositeNode(grammarAccess.getVLSFofFormulaAccess().getFofFormulaVLSTermParserRuleCall_6_0()); | ||
559 | } | ||
560 | lv_fofFormula_6_0=ruleVLSTerm | ||
561 | { | ||
562 | if ($current==null) { | ||
563 | $current = createModelElementForParent(grammarAccess.getVLSFofFormulaRule()); | ||
564 | } | ||
565 | set( | ||
566 | $current, | ||
567 | "fofFormula", | ||
568 | lv_fofFormula_6_0, | ||
569 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSTerm"); | ||
570 | afterParserOrEnumRuleCall(); | ||
571 | } | ||
572 | ) | ||
573 | ) | ||
574 | ( | ||
575 | otherlv_7=',' | ||
576 | { | ||
577 | newLeafNode(otherlv_7, grammarAccess.getVLSFofFormulaAccess().getCommaKeyword_7_0()); | ||
578 | } | ||
579 | ( | ||
580 | ( | ||
581 | { | ||
582 | newCompositeNode(grammarAccess.getVLSFofFormulaAccess().getAnnotationsVLSAnnotationParserRuleCall_7_1_0()); | ||
583 | } | ||
584 | lv_annotations_8_0=ruleVLSAnnotation | ||
585 | { | ||
586 | if ($current==null) { | ||
587 | $current = createModelElementForParent(grammarAccess.getVLSFofFormulaRule()); | ||
588 | } | ||
589 | set( | ||
590 | $current, | ||
591 | "annotations", | ||
592 | lv_annotations_8_0, | ||
593 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSAnnotation"); | ||
594 | afterParserOrEnumRuleCall(); | ||
595 | } | ||
596 | ) | ||
597 | ) | ||
598 | )? | ||
599 | otherlv_9=')' | ||
600 | { | ||
601 | newLeafNode(otherlv_9, grammarAccess.getVLSFofFormulaAccess().getRightParenthesisKeyword_8()); | ||
602 | } | ||
603 | otherlv_10='.' | ||
604 | { | ||
605 | newLeafNode(otherlv_10, grammarAccess.getVLSFofFormulaAccess().getFullStopKeyword_9()); | ||
606 | } | ||
607 | ) | ||
608 | ; | ||
609 | |||
610 | // Entry rule entryRuleVLSTffFormula | ||
611 | entryRuleVLSTffFormula returns [EObject current=null]: | ||
612 | { newCompositeNode(grammarAccess.getVLSTffFormulaRule()); } | ||
613 | iv_ruleVLSTffFormula=ruleVLSTffFormula | ||
614 | { $current=$iv_ruleVLSTffFormula.current; } | ||
615 | EOF; | ||
616 | |||
617 | // Rule VLSTffFormula | ||
618 | ruleVLSTffFormula returns [EObject current=null] | ||
619 | @init { | ||
620 | enterRule(); | ||
621 | } | ||
622 | @after { | ||
623 | leaveRule(); | ||
624 | }: | ||
625 | ( | ||
626 | otherlv_0='tff' | ||
627 | { | ||
628 | newLeafNode(otherlv_0, grammarAccess.getVLSTffFormulaAccess().getTffKeyword_0()); | ||
629 | } | ||
630 | otherlv_1='(' | ||
631 | { | ||
632 | newLeafNode(otherlv_1, grammarAccess.getVLSTffFormulaAccess().getLeftParenthesisKeyword_1()); | ||
633 | } | ||
634 | ( | ||
635 | ( | ||
636 | ( | ||
637 | lv_name_2_1=RULE_LOWER_WORD_ID | ||
638 | { | ||
639 | newLeafNode(lv_name_2_1, grammarAccess.getVLSTffFormulaAccess().getNameLOWER_WORD_IDTerminalRuleCall_2_0_0()); | ||
640 | } | ||
641 | { | ||
642 | if ($current==null) { | ||
643 | $current = createModelElement(grammarAccess.getVLSTffFormulaRule()); | ||
644 | } | ||
645 | setWithLastConsumed( | ||
646 | $current, | ||
647 | "name", | ||
648 | lv_name_2_1, | ||
649 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.LOWER_WORD_ID"); | ||
650 | } | ||
651 | | | ||
652 | lv_name_2_2=RULE_SIGNED_LITERAL | ||
653 | { | ||
654 | newLeafNode(lv_name_2_2, grammarAccess.getVLSTffFormulaAccess().getNameSIGNED_LITERALTerminalRuleCall_2_0_1()); | ||
655 | } | ||
656 | { | ||
657 | if ($current==null) { | ||
658 | $current = createModelElement(grammarAccess.getVLSTffFormulaRule()); | ||
659 | } | ||
660 | setWithLastConsumed( | ||
661 | $current, | ||
662 | "name", | ||
663 | lv_name_2_2, | ||
664 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SIGNED_LITERAL"); | ||
665 | } | ||
666 | | | ||
667 | lv_name_2_3=RULE_SINGLE_QUOTE | ||
668 | { | ||
669 | newLeafNode(lv_name_2_3, grammarAccess.getVLSTffFormulaAccess().getNameSINGLE_QUOTETerminalRuleCall_2_0_2()); | ||
670 | } | ||
671 | { | ||
672 | if ($current==null) { | ||
673 | $current = createModelElement(grammarAccess.getVLSTffFormulaRule()); | ||
674 | } | ||
675 | setWithLastConsumed( | ||
676 | $current, | ||
677 | "name", | ||
678 | lv_name_2_3, | ||
679 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SINGLE_QUOTE"); | ||
680 | } | ||
681 | ) | ||
682 | ) | ||
683 | ) | ||
684 | otherlv_3=',' | ||
685 | { | ||
686 | newLeafNode(otherlv_3, grammarAccess.getVLSTffFormulaAccess().getCommaKeyword_3()); | ||
687 | } | ||
688 | ( | ||
689 | ( | ||
690 | { | ||
691 | newCompositeNode(grammarAccess.getVLSTffFormulaAccess().getFofRoleVLSRoleParserRuleCall_4_0()); | ||
692 | } | ||
693 | lv_fofRole_4_0=ruleVLSRole | ||
694 | { | ||
695 | if ($current==null) { | ||
696 | $current = createModelElementForParent(grammarAccess.getVLSTffFormulaRule()); | ||
697 | } | ||
698 | set( | ||
699 | $current, | ||
700 | "fofRole", | ||
701 | lv_fofRole_4_0, | ||
702 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSRole"); | ||
703 | afterParserOrEnumRuleCall(); | ||
704 | } | ||
705 | ) | ||
706 | ) | ||
707 | otherlv_5=',' | ||
708 | { | ||
709 | newLeafNode(otherlv_5, grammarAccess.getVLSTffFormulaAccess().getCommaKeyword_5()); | ||
710 | } | ||
711 | ( | ||
712 | ( | ||
713 | { | ||
714 | newCompositeNode(grammarAccess.getVLSTffFormulaAccess().getFofFormulaVLSTermParserRuleCall_6_0()); | ||
715 | } | ||
716 | lv_fofFormula_6_0=ruleVLSTerm | ||
717 | { | ||
718 | if ($current==null) { | ||
719 | $current = createModelElementForParent(grammarAccess.getVLSTffFormulaRule()); | ||
720 | } | ||
721 | set( | ||
722 | $current, | ||
723 | "fofFormula", | ||
724 | lv_fofFormula_6_0, | ||
725 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSTerm"); | ||
726 | afterParserOrEnumRuleCall(); | ||
727 | } | ||
728 | ) | ||
729 | ) | ||
730 | ( | ||
731 | otherlv_7=',' | ||
732 | { | ||
733 | newLeafNode(otherlv_7, grammarAccess.getVLSTffFormulaAccess().getCommaKeyword_7_0()); | ||
734 | } | ||
735 | ( | ||
736 | ( | ||
737 | { | ||
738 | newCompositeNode(grammarAccess.getVLSTffFormulaAccess().getAnnotationsVLSAnnotationParserRuleCall_7_1_0()); | ||
739 | } | ||
740 | lv_annotations_8_0=ruleVLSAnnotation | ||
741 | { | ||
742 | if ($current==null) { | ||
743 | $current = createModelElementForParent(grammarAccess.getVLSTffFormulaRule()); | ||
744 | } | ||
745 | set( | ||
746 | $current, | ||
747 | "annotations", | ||
748 | lv_annotations_8_0, | ||
749 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSAnnotation"); | ||
750 | afterParserOrEnumRuleCall(); | ||
751 | } | ||
752 | ) | ||
753 | ) | ||
754 | )? | ||
755 | otherlv_9=')' | ||
756 | { | ||
757 | newLeafNode(otherlv_9, grammarAccess.getVLSTffFormulaAccess().getRightParenthesisKeyword_8()); | ||
758 | } | ||
759 | otherlv_10='.' | ||
760 | { | ||
761 | newLeafNode(otherlv_10, grammarAccess.getVLSTffFormulaAccess().getFullStopKeyword_9()); | ||
762 | } | ||
763 | ) | ||
764 | ; | ||
765 | |||
766 | // Entry rule entryRuleVLSRole | ||
767 | entryRuleVLSRole returns [String current=null]: | ||
768 | { newCompositeNode(grammarAccess.getVLSRoleRule()); } | ||
769 | iv_ruleVLSRole=ruleVLSRole | ||
770 | { $current=$iv_ruleVLSRole.current.getText(); } | ||
771 | EOF; | ||
772 | |||
773 | // Rule VLSRole | ||
774 | ruleVLSRole returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
775 | @init { | ||
776 | enterRule(); | ||
777 | } | ||
778 | @after { | ||
779 | leaveRule(); | ||
780 | }: | ||
781 | ( | ||
782 | kw='axiom' | ||
783 | { | ||
784 | $current.merge(kw); | ||
785 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getAxiomKeyword_0()); | ||
786 | } | ||
787 | | | ||
788 | kw='conjecture' | ||
789 | { | ||
790 | $current.merge(kw); | ||
791 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getConjectureKeyword_1()); | ||
792 | } | ||
793 | | | ||
794 | kw='hypothesis' | ||
795 | { | ||
796 | $current.merge(kw); | ||
797 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getHypothesisKeyword_2()); | ||
798 | } | ||
799 | | | ||
800 | kw='definition' | ||
801 | { | ||
802 | $current.merge(kw); | ||
803 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getDefinitionKeyword_3()); | ||
804 | } | ||
805 | | | ||
806 | kw='assumption' | ||
807 | { | ||
808 | $current.merge(kw); | ||
809 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getAssumptionKeyword_4()); | ||
810 | } | ||
811 | | | ||
812 | kw='lemma' | ||
813 | { | ||
814 | $current.merge(kw); | ||
815 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getLemmaKeyword_5()); | ||
816 | } | ||
817 | | | ||
818 | kw='theorem' | ||
819 | { | ||
820 | $current.merge(kw); | ||
821 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getTheoremKeyword_6()); | ||
822 | } | ||
823 | | | ||
824 | kw='corollary' | ||
825 | { | ||
826 | $current.merge(kw); | ||
827 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getCorollaryKeyword_7()); | ||
828 | } | ||
829 | | | ||
830 | kw='negated_conjecture' | ||
831 | { | ||
832 | $current.merge(kw); | ||
833 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getNegated_conjectureKeyword_8()); | ||
834 | } | ||
835 | | | ||
836 | kw='plain' | ||
837 | { | ||
838 | $current.merge(kw); | ||
839 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getPlainKeyword_9()); | ||
840 | } | ||
841 | | | ||
842 | kw='type' | ||
843 | { | ||
844 | $current.merge(kw); | ||
845 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getTypeKeyword_10()); | ||
846 | } | ||
847 | | | ||
848 | kw='fi_domain' | ||
849 | { | ||
850 | $current.merge(kw); | ||
851 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getFi_domainKeyword_11()); | ||
852 | } | ||
853 | | | ||
854 | kw='fi_functors' | ||
855 | { | ||
856 | $current.merge(kw); | ||
857 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getFi_functorsKeyword_12()); | ||
858 | } | ||
859 | | | ||
860 | kw='fi_predicates' | ||
861 | { | ||
862 | $current.merge(kw); | ||
863 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getFi_predicatesKeyword_13()); | ||
864 | } | ||
865 | | | ||
866 | kw='unknown' | ||
867 | { | ||
868 | $current.merge(kw); | ||
869 | newLeafNode(kw, grammarAccess.getVLSRoleAccess().getUnknownKeyword_14()); | ||
870 | } | ||
871 | ) | ||
872 | ; | ||
873 | |||
874 | // Entry rule entryRuleVLSAnnotation | ||
875 | entryRuleVLSAnnotation returns [EObject current=null]: | ||
876 | { newCompositeNode(grammarAccess.getVLSAnnotationRule()); } | ||
877 | iv_ruleVLSAnnotation=ruleVLSAnnotation | ||
878 | { $current=$iv_ruleVLSAnnotation.current; } | ||
879 | EOF; | ||
880 | |||
881 | // Rule VLSAnnotation | ||
882 | ruleVLSAnnotation returns [EObject current=null] | ||
883 | @init { | ||
884 | enterRule(); | ||
885 | } | ||
886 | @after { | ||
887 | leaveRule(); | ||
888 | }: | ||
889 | ( | ||
890 | ( | ||
891 | otherlv_0='[' | ||
892 | { | ||
893 | newLeafNode(otherlv_0, grammarAccess.getVLSAnnotationAccess().getLeftSquareBracketKeyword_0()); | ||
894 | } | ||
895 | )? | ||
896 | ( | ||
897 | ( | ||
898 | ( | ||
899 | lv_name_1_1=RULE_LOWER_WORD_ID | ||
900 | { | ||
901 | newLeafNode(lv_name_1_1, grammarAccess.getVLSAnnotationAccess().getNameLOWER_WORD_IDTerminalRuleCall_1_0_0()); | ||
902 | } | ||
903 | { | ||
904 | if ($current==null) { | ||
905 | $current = createModelElement(grammarAccess.getVLSAnnotationRule()); | ||
906 | } | ||
907 | setWithLastConsumed( | ||
908 | $current, | ||
909 | "name", | ||
910 | lv_name_1_1, | ||
911 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.LOWER_WORD_ID"); | ||
912 | } | ||
913 | | | ||
914 | lv_name_1_2=RULE_SINGLE_QUOTE | ||
915 | { | ||
916 | newLeafNode(lv_name_1_2, grammarAccess.getVLSAnnotationAccess().getNameSINGLE_QUOTETerminalRuleCall_1_0_1()); | ||
917 | } | ||
918 | { | ||
919 | if ($current==null) { | ||
920 | $current = createModelElement(grammarAccess.getVLSAnnotationRule()); | ||
921 | } | ||
922 | setWithLastConsumed( | ||
923 | $current, | ||
924 | "name", | ||
925 | lv_name_1_2, | ||
926 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SINGLE_QUOTE"); | ||
927 | } | ||
928 | | | ||
929 | { | ||
930 | newCompositeNode(grammarAccess.getVLSAnnotationAccess().getNameVLSRoleParserRuleCall_1_0_2()); | ||
931 | } | ||
932 | lv_name_1_3=ruleVLSRole | ||
933 | { | ||
934 | if ($current==null) { | ||
935 | $current = createModelElementForParent(grammarAccess.getVLSAnnotationRule()); | ||
936 | } | ||
937 | set( | ||
938 | $current, | ||
939 | "name", | ||
940 | lv_name_1_3, | ||
941 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSRole"); | ||
942 | afterParserOrEnumRuleCall(); | ||
943 | } | ||
944 | ) | ||
945 | ) | ||
946 | )? | ||
947 | ( | ||
948 | otherlv_2='(' | ||
949 | { | ||
950 | newLeafNode(otherlv_2, grammarAccess.getVLSAnnotationAccess().getLeftParenthesisKeyword_2_0()); | ||
951 | } | ||
952 | ( | ||
953 | ( | ||
954 | { | ||
955 | newCompositeNode(grammarAccess.getVLSAnnotationAccess().getFollowupVLSAnnotationTermsParserRuleCall_2_1_0()); | ||
956 | } | ||
957 | lv_followup_3_0=ruleVLSAnnotationTerms | ||
958 | { | ||
959 | if ($current==null) { | ||
960 | $current = createModelElementForParent(grammarAccess.getVLSAnnotationRule()); | ||
961 | } | ||
962 | set( | ||
963 | $current, | ||
964 | "followup", | ||
965 | lv_followup_3_0, | ||
966 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSAnnotationTerms"); | ||
967 | afterParserOrEnumRuleCall(); | ||
968 | } | ||
969 | ) | ||
970 | ) | ||
971 | otherlv_4=')' | ||
972 | { | ||
973 | newLeafNode(otherlv_4, grammarAccess.getVLSAnnotationAccess().getRightParenthesisKeyword_2_2()); | ||
974 | } | ||
975 | )? | ||
976 | ( | ||
977 | otherlv_5=']' | ||
978 | { | ||
979 | newLeafNode(otherlv_5, grammarAccess.getVLSAnnotationAccess().getRightSquareBracketKeyword_3()); | ||
980 | } | ||
981 | )? | ||
982 | ) | ||
983 | ; | ||
984 | |||
985 | // Entry rule entryRuleVLSAnnotationTerms | ||
986 | entryRuleVLSAnnotationTerms returns [EObject current=null]: | ||
987 | { newCompositeNode(grammarAccess.getVLSAnnotationTermsRule()); } | ||
988 | iv_ruleVLSAnnotationTerms=ruleVLSAnnotationTerms | ||
989 | { $current=$iv_ruleVLSAnnotationTerms.current; } | ||
990 | EOF; | ||
991 | |||
992 | // Rule VLSAnnotationTerms | ||
993 | ruleVLSAnnotationTerms returns [EObject current=null] | ||
994 | @init { | ||
995 | enterRule(); | ||
996 | } | ||
997 | @after { | ||
998 | leaveRule(); | ||
999 | }: | ||
1000 | ( | ||
1001 | ( | ||
1002 | ( | ||
1003 | { | ||
1004 | newCompositeNode(grammarAccess.getVLSAnnotationTermsAccess().getTermsVLSAnnotationParserRuleCall_0_0()); | ||
1005 | } | ||
1006 | lv_terms_0_0=ruleVLSAnnotation | ||
1007 | { | ||
1008 | if ($current==null) { | ||
1009 | $current = createModelElementForParent(grammarAccess.getVLSAnnotationTermsRule()); | ||
1010 | } | ||
1011 | add( | ||
1012 | $current, | ||
1013 | "terms", | ||
1014 | lv_terms_0_0, | ||
1015 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSAnnotation"); | ||
1016 | afterParserOrEnumRuleCall(); | ||
1017 | } | ||
1018 | ) | ||
1019 | ) | ||
1020 | ( | ||
1021 | otherlv_1=',' | ||
1022 | { | ||
1023 | newLeafNode(otherlv_1, grammarAccess.getVLSAnnotationTermsAccess().getCommaKeyword_1_0()); | ||
1024 | } | ||
1025 | ( | ||
1026 | ( | ||
1027 | { | ||
1028 | newCompositeNode(grammarAccess.getVLSAnnotationTermsAccess().getTermsVLSAnnotationParserRuleCall_1_1_0()); | ||
1029 | } | ||
1030 | lv_terms_2_0=ruleVLSAnnotation | ||
1031 | { | ||
1032 | if ($current==null) { | ||
1033 | $current = createModelElementForParent(grammarAccess.getVLSAnnotationTermsRule()); | ||
1034 | } | ||
1035 | add( | ||
1036 | $current, | ||
1037 | "terms", | ||
1038 | lv_terms_2_0, | ||
1039 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSAnnotation"); | ||
1040 | afterParserOrEnumRuleCall(); | ||
1041 | } | ||
1042 | ) | ||
1043 | ) | ||
1044 | )* | ||
1045 | ) | ||
1046 | ; | ||
1047 | |||
1048 | // Entry rule entryRuleVLSTerm | ||
1049 | entryRuleVLSTerm returns [EObject current=null]: | ||
1050 | { newCompositeNode(grammarAccess.getVLSTermRule()); } | ||
1051 | iv_ruleVLSTerm=ruleVLSTerm | ||
1052 | { $current=$iv_ruleVLSTerm.current; } | ||
1053 | EOF; | ||
1054 | |||
1055 | // Rule VLSTerm | ||
1056 | ruleVLSTerm returns [EObject current=null] | ||
1057 | @init { | ||
1058 | enterRule(); | ||
1059 | } | ||
1060 | @after { | ||
1061 | leaveRule(); | ||
1062 | }: | ||
1063 | { | ||
1064 | newCompositeNode(grammarAccess.getVLSTermAccess().getVLSBinaryParserRuleCall()); | ||
1065 | } | ||
1066 | this_VLSBinary_0=ruleVLSBinary | ||
1067 | { | ||
1068 | $current = $this_VLSBinary_0.current; | ||
1069 | afterParserOrEnumRuleCall(); | ||
1070 | } | ||
1071 | ; | ||
1072 | |||
1073 | // Entry rule entryRuleVLSBinary | ||
1074 | entryRuleVLSBinary returns [EObject current=null]: | ||
1075 | { newCompositeNode(grammarAccess.getVLSBinaryRule()); } | ||
1076 | iv_ruleVLSBinary=ruleVLSBinary | ||
1077 | { $current=$iv_ruleVLSBinary.current; } | ||
1078 | EOF; | ||
1079 | |||
1080 | // Rule VLSBinary | ||
1081 | ruleVLSBinary returns [EObject current=null] | ||
1082 | @init { | ||
1083 | enterRule(); | ||
1084 | } | ||
1085 | @after { | ||
1086 | leaveRule(); | ||
1087 | }: | ||
1088 | ( | ||
1089 | { | ||
1090 | newCompositeNode(grammarAccess.getVLSBinaryAccess().getVLSUnitaryFormulaParserRuleCall_0()); | ||
1091 | } | ||
1092 | this_VLSUnitaryFormula_0=ruleVLSUnitaryFormula | ||
1093 | { | ||
1094 | $current = $this_VLSUnitaryFormula_0.current; | ||
1095 | afterParserOrEnumRuleCall(); | ||
1096 | } | ||
1097 | ( | ||
1098 | ( | ||
1099 | ( | ||
1100 | ( | ||
1101 | ( | ||
1102 | { | ||
1103 | $current = forceCreateModelElementAndSet( | ||
1104 | grammarAccess.getVLSBinaryAccess().getVLSEquivalentLeftAction_1_0_0_0_0(), | ||
1105 | $current); | ||
1106 | } | ||
1107 | ) | ||
1108 | otherlv_2='<=>' | ||
1109 | { | ||
1110 | newLeafNode(otherlv_2, grammarAccess.getVLSBinaryAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_0_0_0_1()); | ||
1111 | } | ||
1112 | ) | ||
1113 | | | ||
1114 | ( | ||
1115 | ( | ||
1116 | { | ||
1117 | $current = forceCreateModelElementAndSet( | ||
1118 | grammarAccess.getVLSBinaryAccess().getVLSImpliesLeftAction_1_0_0_1_0(), | ||
1119 | $current); | ||
1120 | } | ||
1121 | ) | ||
1122 | otherlv_4='=>' | ||
1123 | { | ||
1124 | newLeafNode(otherlv_4, grammarAccess.getVLSBinaryAccess().getEqualsSignGreaterThanSignKeyword_1_0_0_1_1()); | ||
1125 | } | ||
1126 | ) | ||
1127 | | | ||
1128 | ( | ||
1129 | ( | ||
1130 | { | ||
1131 | $current = forceCreateModelElementAndSet( | ||
1132 | grammarAccess.getVLSBinaryAccess().getVLSRevImpliesLeftAction_1_0_0_2_0(), | ||
1133 | $current); | ||
1134 | } | ||
1135 | ) | ||
1136 | otherlv_6='<=' | ||
1137 | { | ||
1138 | newLeafNode(otherlv_6, grammarAccess.getVLSBinaryAccess().getLessThanSignEqualsSignKeyword_1_0_0_2_1()); | ||
1139 | } | ||
1140 | ) | ||
1141 | | | ||
1142 | ( | ||
1143 | ( | ||
1144 | { | ||
1145 | $current = forceCreateModelElementAndSet( | ||
1146 | grammarAccess.getVLSBinaryAccess().getVLSXnorLeftAction_1_0_0_3_0(), | ||
1147 | $current); | ||
1148 | } | ||
1149 | ) | ||
1150 | otherlv_8='<~>' | ||
1151 | { | ||
1152 | newLeafNode(otherlv_8, grammarAccess.getVLSBinaryAccess().getLessThanSignTildeGreaterThanSignKeyword_1_0_0_3_1()); | ||
1153 | } | ||
1154 | ) | ||
1155 | | | ||
1156 | ( | ||
1157 | ( | ||
1158 | { | ||
1159 | $current = forceCreateModelElementAndSet( | ||
1160 | grammarAccess.getVLSBinaryAccess().getVLSNorLeftAction_1_0_0_4_0(), | ||
1161 | $current); | ||
1162 | } | ||
1163 | ) | ||
1164 | otherlv_10='~|' | ||
1165 | { | ||
1166 | newLeafNode(otherlv_10, grammarAccess.getVLSBinaryAccess().getTildeVerticalLineKeyword_1_0_0_4_1()); | ||
1167 | } | ||
1168 | ) | ||
1169 | | | ||
1170 | ( | ||
1171 | ( | ||
1172 | { | ||
1173 | $current = forceCreateModelElementAndSet( | ||
1174 | grammarAccess.getVLSBinaryAccess().getVLSNandLeftAction_1_0_0_5_0(), | ||
1175 | $current); | ||
1176 | } | ||
1177 | ) | ||
1178 | otherlv_12='~&' | ||
1179 | { | ||
1180 | newLeafNode(otherlv_12, grammarAccess.getVLSBinaryAccess().getTildeAmpersandKeyword_1_0_0_5_1()); | ||
1181 | } | ||
1182 | ) | ||
1183 | ) | ||
1184 | ( | ||
1185 | ( | ||
1186 | { | ||
1187 | newCompositeNode(grammarAccess.getVLSBinaryAccess().getRightVLSUnitaryFormulaParserRuleCall_1_0_1_0()); | ||
1188 | } | ||
1189 | lv_right_13_0=ruleVLSUnitaryFormula | ||
1190 | { | ||
1191 | if ($current==null) { | ||
1192 | $current = createModelElementForParent(grammarAccess.getVLSBinaryRule()); | ||
1193 | } | ||
1194 | set( | ||
1195 | $current, | ||
1196 | "right", | ||
1197 | lv_right_13_0, | ||
1198 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSUnitaryFormula"); | ||
1199 | afterParserOrEnumRuleCall(); | ||
1200 | } | ||
1201 | ) | ||
1202 | ) | ||
1203 | ) | ||
1204 | | | ||
1205 | ( | ||
1206 | ( | ||
1207 | { | ||
1208 | $current = forceCreateModelElementAndSet( | ||
1209 | grammarAccess.getVLSBinaryAccess().getVLSAndLeftAction_1_1_0(), | ||
1210 | $current); | ||
1211 | } | ||
1212 | ) | ||
1213 | otherlv_15='&' | ||
1214 | { | ||
1215 | newLeafNode(otherlv_15, grammarAccess.getVLSBinaryAccess().getAmpersandKeyword_1_1_1()); | ||
1216 | } | ||
1217 | ( | ||
1218 | ( | ||
1219 | { | ||
1220 | newCompositeNode(grammarAccess.getVLSBinaryAccess().getRightVLSUnitaryFormulaParserRuleCall_1_1_2_0()); | ||
1221 | } | ||
1222 | lv_right_16_0=ruleVLSUnitaryFormula | ||
1223 | { | ||
1224 | if ($current==null) { | ||
1225 | $current = createModelElementForParent(grammarAccess.getVLSBinaryRule()); | ||
1226 | } | ||
1227 | set( | ||
1228 | $current, | ||
1229 | "right", | ||
1230 | lv_right_16_0, | ||
1231 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSUnitaryFormula"); | ||
1232 | afterParserOrEnumRuleCall(); | ||
1233 | } | ||
1234 | ) | ||
1235 | ) | ||
1236 | )+ | ||
1237 | | | ||
1238 | ( | ||
1239 | ( | ||
1240 | { | ||
1241 | $current = forceCreateModelElementAndSet( | ||
1242 | grammarAccess.getVLSBinaryAccess().getVLSOrLeftAction_1_2_0(), | ||
1243 | $current); | ||
1244 | } | ||
1245 | ) | ||
1246 | otherlv_18='|' | ||
1247 | { | ||
1248 | newLeafNode(otherlv_18, grammarAccess.getVLSBinaryAccess().getVerticalLineKeyword_1_2_1()); | ||
1249 | } | ||
1250 | ( | ||
1251 | ( | ||
1252 | { | ||
1253 | newCompositeNode(grammarAccess.getVLSBinaryAccess().getRightVLSUnitaryFormulaParserRuleCall_1_2_2_0()); | ||
1254 | } | ||
1255 | lv_right_19_0=ruleVLSUnitaryFormula | ||
1256 | { | ||
1257 | if ($current==null) { | ||
1258 | $current = createModelElementForParent(grammarAccess.getVLSBinaryRule()); | ||
1259 | } | ||
1260 | set( | ||
1261 | $current, | ||
1262 | "right", | ||
1263 | lv_right_19_0, | ||
1264 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSUnitaryFormula"); | ||
1265 | afterParserOrEnumRuleCall(); | ||
1266 | } | ||
1267 | ) | ||
1268 | ) | ||
1269 | )+ | ||
1270 | )? | ||
1271 | ) | ||
1272 | ; | ||
1273 | |||
1274 | // Entry rule entryRuleVLSUnitaryFormula | ||
1275 | entryRuleVLSUnitaryFormula returns [EObject current=null]: | ||
1276 | { newCompositeNode(grammarAccess.getVLSUnitaryFormulaRule()); } | ||
1277 | iv_ruleVLSUnitaryFormula=ruleVLSUnitaryFormula | ||
1278 | { $current=$iv_ruleVLSUnitaryFormula.current; } | ||
1279 | EOF; | ||
1280 | |||
1281 | // Rule VLSUnitaryFormula | ||
1282 | ruleVLSUnitaryFormula returns [EObject current=null] | ||
1283 | @init { | ||
1284 | enterRule(); | ||
1285 | } | ||
1286 | @after { | ||
1287 | leaveRule(); | ||
1288 | }: | ||
1289 | ( | ||
1290 | { | ||
1291 | newCompositeNode(grammarAccess.getVLSUnitaryFormulaAccess().getVLSUniversalQuantifierParserRuleCall_0()); | ||
1292 | } | ||
1293 | this_VLSUniversalQuantifier_0=ruleVLSUniversalQuantifier | ||
1294 | { | ||
1295 | $current = $this_VLSUniversalQuantifier_0.current; | ||
1296 | afterParserOrEnumRuleCall(); | ||
1297 | } | ||
1298 | | | ||
1299 | { | ||
1300 | newCompositeNode(grammarAccess.getVLSUnitaryFormulaAccess().getVLSExistentialQuantifierParserRuleCall_1()); | ||
1301 | } | ||
1302 | this_VLSExistentialQuantifier_1=ruleVLSExistentialQuantifier | ||
1303 | { | ||
1304 | $current = $this_VLSExistentialQuantifier_1.current; | ||
1305 | afterParserOrEnumRuleCall(); | ||
1306 | } | ||
1307 | | | ||
1308 | { | ||
1309 | newCompositeNode(grammarAccess.getVLSUnitaryFormulaAccess().getVLSUnaryNegationParserRuleCall_2()); | ||
1310 | } | ||
1311 | this_VLSUnaryNegation_2=ruleVLSUnaryNegation | ||
1312 | { | ||
1313 | $current = $this_VLSUnaryNegation_2.current; | ||
1314 | afterParserOrEnumRuleCall(); | ||
1315 | } | ||
1316 | | | ||
1317 | { | ||
1318 | newCompositeNode(grammarAccess.getVLSUnitaryFormulaAccess().getVLSUnaryInfixParserRuleCall_3()); | ||
1319 | } | ||
1320 | this_VLSUnaryInfix_3=ruleVLSUnaryInfix | ||
1321 | { | ||
1322 | $current = $this_VLSUnaryInfix_3.current; | ||
1323 | afterParserOrEnumRuleCall(); | ||
1324 | } | ||
1325 | | | ||
1326 | ( | ||
1327 | otherlv_4='(' | ||
1328 | { | ||
1329 | newLeafNode(otherlv_4, grammarAccess.getVLSUnitaryFormulaAccess().getLeftParenthesisKeyword_4_0()); | ||
1330 | } | ||
1331 | { | ||
1332 | newCompositeNode(grammarAccess.getVLSUnitaryFormulaAccess().getVLSTermParserRuleCall_4_1()); | ||
1333 | } | ||
1334 | this_VLSTerm_5=ruleVLSTerm | ||
1335 | { | ||
1336 | $current = $this_VLSTerm_5.current; | ||
1337 | afterParserOrEnumRuleCall(); | ||
1338 | } | ||
1339 | otherlv_6=')' | ||
1340 | { | ||
1341 | newLeafNode(otherlv_6, grammarAccess.getVLSUnitaryFormulaAccess().getRightParenthesisKeyword_4_2()); | ||
1342 | } | ||
1343 | ) | ||
1344 | ) | ||
1345 | ; | ||
1346 | |||
1347 | // Entry rule entryRuleVLSUniversalQuantifier | ||
1348 | entryRuleVLSUniversalQuantifier returns [EObject current=null]: | ||
1349 | { newCompositeNode(grammarAccess.getVLSUniversalQuantifierRule()); } | ||
1350 | iv_ruleVLSUniversalQuantifier=ruleVLSUniversalQuantifier | ||
1351 | { $current=$iv_ruleVLSUniversalQuantifier.current; } | ||
1352 | EOF; | ||
1353 | |||
1354 | // Rule VLSUniversalQuantifier | ||
1355 | ruleVLSUniversalQuantifier returns [EObject current=null] | ||
1356 | @init { | ||
1357 | enterRule(); | ||
1358 | } | ||
1359 | @after { | ||
1360 | leaveRule(); | ||
1361 | }: | ||
1362 | ( | ||
1363 | ( | ||
1364 | { | ||
1365 | $current = forceCreateModelElement( | ||
1366 | grammarAccess.getVLSUniversalQuantifierAccess().getVLSUniversalQuantifierAction_0(), | ||
1367 | $current); | ||
1368 | } | ||
1369 | ) | ||
1370 | ( | ||
1371 | otherlv_1='!' | ||
1372 | { | ||
1373 | newLeafNode(otherlv_1, grammarAccess.getVLSUniversalQuantifierAccess().getExclamationMarkKeyword_1_0()); | ||
1374 | } | ||
1375 | otherlv_2='[' | ||
1376 | { | ||
1377 | newLeafNode(otherlv_2, grammarAccess.getVLSUniversalQuantifierAccess().getLeftSquareBracketKeyword_1_1()); | ||
1378 | } | ||
1379 | ( | ||
1380 | ( | ||
1381 | { | ||
1382 | newCompositeNode(grammarAccess.getVLSUniversalQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_2_0()); | ||
1383 | } | ||
1384 | lv_variables_3_0=ruleVLSVariable | ||
1385 | { | ||
1386 | if ($current==null) { | ||
1387 | $current = createModelElementForParent(grammarAccess.getVLSUniversalQuantifierRule()); | ||
1388 | } | ||
1389 | add( | ||
1390 | $current, | ||
1391 | "variables", | ||
1392 | lv_variables_3_0, | ||
1393 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSVariable"); | ||
1394 | afterParserOrEnumRuleCall(); | ||
1395 | } | ||
1396 | ) | ||
1397 | ) | ||
1398 | ( | ||
1399 | otherlv_4=',' | ||
1400 | { | ||
1401 | newLeafNode(otherlv_4, grammarAccess.getVLSUniversalQuantifierAccess().getCommaKeyword_1_3_0()); | ||
1402 | } | ||
1403 | ( | ||
1404 | ( | ||
1405 | { | ||
1406 | newCompositeNode(grammarAccess.getVLSUniversalQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_3_1_0()); | ||
1407 | } | ||
1408 | lv_variables_5_0=ruleVLSVariable | ||
1409 | { | ||
1410 | if ($current==null) { | ||
1411 | $current = createModelElementForParent(grammarAccess.getVLSUniversalQuantifierRule()); | ||
1412 | } | ||
1413 | add( | ||
1414 | $current, | ||
1415 | "variables", | ||
1416 | lv_variables_5_0, | ||
1417 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSVariable"); | ||
1418 | afterParserOrEnumRuleCall(); | ||
1419 | } | ||
1420 | ) | ||
1421 | ) | ||
1422 | )* | ||
1423 | otherlv_6=']' | ||
1424 | { | ||
1425 | newLeafNode(otherlv_6, grammarAccess.getVLSUniversalQuantifierAccess().getRightSquareBracketKeyword_1_4()); | ||
1426 | } | ||
1427 | otherlv_7=':' | ||
1428 | { | ||
1429 | newLeafNode(otherlv_7, grammarAccess.getVLSUniversalQuantifierAccess().getColonKeyword_1_5()); | ||
1430 | } | ||
1431 | ) | ||
1432 | ( | ||
1433 | ( | ||
1434 | { | ||
1435 | newCompositeNode(grammarAccess.getVLSUniversalQuantifierAccess().getOperandVLSUnitaryFormulaParserRuleCall_2_0()); | ||
1436 | } | ||
1437 | lv_operand_8_0=ruleVLSUnitaryFormula | ||
1438 | { | ||
1439 | if ($current==null) { | ||
1440 | $current = createModelElementForParent(grammarAccess.getVLSUniversalQuantifierRule()); | ||
1441 | } | ||
1442 | set( | ||
1443 | $current, | ||
1444 | "operand", | ||
1445 | lv_operand_8_0, | ||
1446 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSUnitaryFormula"); | ||
1447 | afterParserOrEnumRuleCall(); | ||
1448 | } | ||
1449 | ) | ||
1450 | ) | ||
1451 | ) | ||
1452 | ; | ||
1453 | |||
1454 | // Entry rule entryRuleVLSExistentialQuantifier | ||
1455 | entryRuleVLSExistentialQuantifier returns [EObject current=null]: | ||
1456 | { newCompositeNode(grammarAccess.getVLSExistentialQuantifierRule()); } | ||
1457 | iv_ruleVLSExistentialQuantifier=ruleVLSExistentialQuantifier | ||
1458 | { $current=$iv_ruleVLSExistentialQuantifier.current; } | ||
1459 | EOF; | ||
1460 | |||
1461 | // Rule VLSExistentialQuantifier | ||
1462 | ruleVLSExistentialQuantifier returns [EObject current=null] | ||
1463 | @init { | ||
1464 | enterRule(); | ||
1465 | } | ||
1466 | @after { | ||
1467 | leaveRule(); | ||
1468 | }: | ||
1469 | ( | ||
1470 | ( | ||
1471 | { | ||
1472 | $current = forceCreateModelElement( | ||
1473 | grammarAccess.getVLSExistentialQuantifierAccess().getVLSExistentialQuantifierAction_0(), | ||
1474 | $current); | ||
1475 | } | ||
1476 | ) | ||
1477 | ( | ||
1478 | otherlv_1='?' | ||
1479 | { | ||
1480 | newLeafNode(otherlv_1, grammarAccess.getVLSExistentialQuantifierAccess().getQuestionMarkKeyword_1_0()); | ||
1481 | } | ||
1482 | otherlv_2='[' | ||
1483 | { | ||
1484 | newLeafNode(otherlv_2, grammarAccess.getVLSExistentialQuantifierAccess().getLeftSquareBracketKeyword_1_1()); | ||
1485 | } | ||
1486 | ( | ||
1487 | ( | ||
1488 | { | ||
1489 | newCompositeNode(grammarAccess.getVLSExistentialQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_2_0()); | ||
1490 | } | ||
1491 | lv_variables_3_0=ruleVLSVariable | ||
1492 | { | ||
1493 | if ($current==null) { | ||
1494 | $current = createModelElementForParent(grammarAccess.getVLSExistentialQuantifierRule()); | ||
1495 | } | ||
1496 | add( | ||
1497 | $current, | ||
1498 | "variables", | ||
1499 | lv_variables_3_0, | ||
1500 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSVariable"); | ||
1501 | afterParserOrEnumRuleCall(); | ||
1502 | } | ||
1503 | ) | ||
1504 | ) | ||
1505 | ( | ||
1506 | otherlv_4=',' | ||
1507 | { | ||
1508 | newLeafNode(otherlv_4, grammarAccess.getVLSExistentialQuantifierAccess().getCommaKeyword_1_3_0()); | ||
1509 | } | ||
1510 | ( | ||
1511 | ( | ||
1512 | { | ||
1513 | newCompositeNode(grammarAccess.getVLSExistentialQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_3_1_0()); | ||
1514 | } | ||
1515 | lv_variables_5_0=ruleVLSVariable | ||
1516 | { | ||
1517 | if ($current==null) { | ||
1518 | $current = createModelElementForParent(grammarAccess.getVLSExistentialQuantifierRule()); | ||
1519 | } | ||
1520 | add( | ||
1521 | $current, | ||
1522 | "variables", | ||
1523 | lv_variables_5_0, | ||
1524 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSVariable"); | ||
1525 | afterParserOrEnumRuleCall(); | ||
1526 | } | ||
1527 | ) | ||
1528 | ) | ||
1529 | )* | ||
1530 | otherlv_6=']' | ||
1531 | { | ||
1532 | newLeafNode(otherlv_6, grammarAccess.getVLSExistentialQuantifierAccess().getRightSquareBracketKeyword_1_4()); | ||
1533 | } | ||
1534 | otherlv_7=':' | ||
1535 | { | ||
1536 | newLeafNode(otherlv_7, grammarAccess.getVLSExistentialQuantifierAccess().getColonKeyword_1_5()); | ||
1537 | } | ||
1538 | ) | ||
1539 | ( | ||
1540 | ( | ||
1541 | { | ||
1542 | newCompositeNode(grammarAccess.getVLSExistentialQuantifierAccess().getOperandVLSUnitaryFormulaParserRuleCall_2_0()); | ||
1543 | } | ||
1544 | lv_operand_8_0=ruleVLSUnitaryFormula | ||
1545 | { | ||
1546 | if ($current==null) { | ||
1547 | $current = createModelElementForParent(grammarAccess.getVLSExistentialQuantifierRule()); | ||
1548 | } | ||
1549 | set( | ||
1550 | $current, | ||
1551 | "operand", | ||
1552 | lv_operand_8_0, | ||
1553 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSUnitaryFormula"); | ||
1554 | afterParserOrEnumRuleCall(); | ||
1555 | } | ||
1556 | ) | ||
1557 | ) | ||
1558 | ) | ||
1559 | ; | ||
1560 | |||
1561 | // Entry rule entryRuleVLSUnaryNegation | ||
1562 | entryRuleVLSUnaryNegation returns [EObject current=null]: | ||
1563 | { newCompositeNode(grammarAccess.getVLSUnaryNegationRule()); } | ||
1564 | iv_ruleVLSUnaryNegation=ruleVLSUnaryNegation | ||
1565 | { $current=$iv_ruleVLSUnaryNegation.current; } | ||
1566 | EOF; | ||
1567 | |||
1568 | // Rule VLSUnaryNegation | ||
1569 | ruleVLSUnaryNegation returns [EObject current=null] | ||
1570 | @init { | ||
1571 | enterRule(); | ||
1572 | } | ||
1573 | @after { | ||
1574 | leaveRule(); | ||
1575 | }: | ||
1576 | ( | ||
1577 | ( | ||
1578 | { | ||
1579 | $current = forceCreateModelElement( | ||
1580 | grammarAccess.getVLSUnaryNegationAccess().getVLSUnaryNegationAction_0(), | ||
1581 | $current); | ||
1582 | } | ||
1583 | ) | ||
1584 | otherlv_1='~' | ||
1585 | { | ||
1586 | newLeafNode(otherlv_1, grammarAccess.getVLSUnaryNegationAccess().getTildeKeyword_1()); | ||
1587 | } | ||
1588 | ( | ||
1589 | ( | ||
1590 | { | ||
1591 | newCompositeNode(grammarAccess.getVLSUnaryNegationAccess().getOperandVLSUnitaryFormulaParserRuleCall_2_0()); | ||
1592 | } | ||
1593 | lv_operand_2_0=ruleVLSUnitaryFormula | ||
1594 | { | ||
1595 | if ($current==null) { | ||
1596 | $current = createModelElementForParent(grammarAccess.getVLSUnaryNegationRule()); | ||
1597 | } | ||
1598 | set( | ||
1599 | $current, | ||
1600 | "operand", | ||
1601 | lv_operand_2_0, | ||
1602 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSUnitaryFormula"); | ||
1603 | afterParserOrEnumRuleCall(); | ||
1604 | } | ||
1605 | ) | ||
1606 | ) | ||
1607 | ) | ||
1608 | ; | ||
1609 | |||
1610 | // Entry rule entryRuleVLSUnaryInfix | ||
1611 | entryRuleVLSUnaryInfix returns [EObject current=null]: | ||
1612 | { newCompositeNode(grammarAccess.getVLSUnaryInfixRule()); } | ||
1613 | iv_ruleVLSUnaryInfix=ruleVLSUnaryInfix | ||
1614 | { $current=$iv_ruleVLSUnaryInfix.current; } | ||
1615 | EOF; | ||
1616 | |||
1617 | // Rule VLSUnaryInfix | ||
1618 | ruleVLSUnaryInfix returns [EObject current=null] | ||
1619 | @init { | ||
1620 | enterRule(); | ||
1621 | } | ||
1622 | @after { | ||
1623 | leaveRule(); | ||
1624 | }: | ||
1625 | ( | ||
1626 | { | ||
1627 | newCompositeNode(grammarAccess.getVLSUnaryInfixAccess().getVLSAtomicParserRuleCall_0()); | ||
1628 | } | ||
1629 | this_VLSAtomic_0=ruleVLSAtomic | ||
1630 | { | ||
1631 | $current = $this_VLSAtomic_0.current; | ||
1632 | afterParserOrEnumRuleCall(); | ||
1633 | } | ||
1634 | ( | ||
1635 | ( | ||
1636 | ( | ||
1637 | ( | ||
1638 | { | ||
1639 | $current = forceCreateModelElementAndSet( | ||
1640 | grammarAccess.getVLSUnaryInfixAccess().getVLSInequalityLeftAction_1_0_0_0(), | ||
1641 | $current); | ||
1642 | } | ||
1643 | ) | ||
1644 | otherlv_2='!=' | ||
1645 | { | ||
1646 | newLeafNode(otherlv_2, grammarAccess.getVLSUnaryInfixAccess().getExclamationMarkEqualsSignKeyword_1_0_0_1()); | ||
1647 | } | ||
1648 | ) | ||
1649 | | | ||
1650 | ( | ||
1651 | ( | ||
1652 | { | ||
1653 | $current = forceCreateModelElementAndSet( | ||
1654 | grammarAccess.getVLSUnaryInfixAccess().getVLSEqualityLeftAction_1_0_1_0(), | ||
1655 | $current); | ||
1656 | } | ||
1657 | ) | ||
1658 | otherlv_4='=' | ||
1659 | { | ||
1660 | newLeafNode(otherlv_4, grammarAccess.getVLSUnaryInfixAccess().getEqualsSignKeyword_1_0_1_1()); | ||
1661 | } | ||
1662 | ) | ||
1663 | | | ||
1664 | ( | ||
1665 | ( | ||
1666 | { | ||
1667 | $current = forceCreateModelElementAndSet( | ||
1668 | grammarAccess.getVLSUnaryInfixAccess().getVLSAssignmentLeftAction_1_0_2_0(), | ||
1669 | $current); | ||
1670 | } | ||
1671 | ) | ||
1672 | otherlv_6=':=' | ||
1673 | { | ||
1674 | newLeafNode(otherlv_6, grammarAccess.getVLSUnaryInfixAccess().getColonEqualsSignKeyword_1_0_2_1()); | ||
1675 | } | ||
1676 | ) | ||
1677 | ) | ||
1678 | ( | ||
1679 | ( | ||
1680 | { | ||
1681 | newCompositeNode(grammarAccess.getVLSUnaryInfixAccess().getRightVLSAtomicParserRuleCall_1_1_0()); | ||
1682 | } | ||
1683 | lv_right_7_0=ruleVLSAtomic | ||
1684 | { | ||
1685 | if ($current==null) { | ||
1686 | $current = createModelElementForParent(grammarAccess.getVLSUnaryInfixRule()); | ||
1687 | } | ||
1688 | set( | ||
1689 | $current, | ||
1690 | "right", | ||
1691 | lv_right_7_0, | ||
1692 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSAtomic"); | ||
1693 | afterParserOrEnumRuleCall(); | ||
1694 | } | ||
1695 | ) | ||
1696 | ) | ||
1697 | )? | ||
1698 | ) | ||
1699 | ; | ||
1700 | |||
1701 | // Entry rule entryRuleVLSAtomic | ||
1702 | entryRuleVLSAtomic returns [EObject current=null]: | ||
1703 | { newCompositeNode(grammarAccess.getVLSAtomicRule()); } | ||
1704 | iv_ruleVLSAtomic=ruleVLSAtomic | ||
1705 | { $current=$iv_ruleVLSAtomic.current; } | ||
1706 | EOF; | ||
1707 | |||
1708 | // Rule VLSAtomic | ||
1709 | ruleVLSAtomic returns [EObject current=null] | ||
1710 | @init { | ||
1711 | enterRule(); | ||
1712 | } | ||
1713 | @after { | ||
1714 | leaveRule(); | ||
1715 | }: | ||
1716 | ( | ||
1717 | { | ||
1718 | newCompositeNode(grammarAccess.getVLSAtomicAccess().getVLSAtomicConstantParserRuleCall_0()); | ||
1719 | } | ||
1720 | this_VLSAtomicConstant_0=ruleVLSAtomicConstant | ||
1721 | { | ||
1722 | $current = $this_VLSAtomicConstant_0.current; | ||
1723 | afterParserOrEnumRuleCall(); | ||
1724 | } | ||
1725 | | | ||
1726 | { | ||
1727 | newCompositeNode(grammarAccess.getVLSAtomicAccess().getVLSAtomicFunctionParserRuleCall_1()); | ||
1728 | } | ||
1729 | this_VLSAtomicFunction_1=ruleVLSAtomicFunction | ||
1730 | { | ||
1731 | $current = $this_VLSAtomicFunction_1.current; | ||
1732 | afterParserOrEnumRuleCall(); | ||
1733 | } | ||
1734 | | | ||
1735 | { | ||
1736 | newCompositeNode(grammarAccess.getVLSAtomicAccess().getVLSVariableParserRuleCall_2()); | ||
1737 | } | ||
1738 | this_VLSVariable_2=ruleVLSVariable | ||
1739 | { | ||
1740 | $current = $this_VLSVariable_2.current; | ||
1741 | afterParserOrEnumRuleCall(); | ||
1742 | } | ||
1743 | | | ||
1744 | { | ||
1745 | newCompositeNode(grammarAccess.getVLSAtomicAccess().getVLSDefinedTermParserRuleCall_3()); | ||
1746 | } | ||
1747 | this_VLSDefinedTerm_3=ruleVLSDefinedTerm | ||
1748 | { | ||
1749 | $current = $this_VLSDefinedTerm_3.current; | ||
1750 | afterParserOrEnumRuleCall(); | ||
1751 | } | ||
1752 | ) | ||
1753 | ; | ||
1754 | |||
1755 | // Entry rule entryRuleVLSAtomicConstant | ||
1756 | entryRuleVLSAtomicConstant returns [EObject current=null]: | ||
1757 | { newCompositeNode(grammarAccess.getVLSAtomicConstantRule()); } | ||
1758 | iv_ruleVLSAtomicConstant=ruleVLSAtomicConstant | ||
1759 | { $current=$iv_ruleVLSAtomicConstant.current; } | ||
1760 | EOF; | ||
1761 | |||
1762 | // Rule VLSAtomicConstant | ||
1763 | ruleVLSAtomicConstant returns [EObject current=null] | ||
1764 | @init { | ||
1765 | enterRule(); | ||
1766 | } | ||
1767 | @after { | ||
1768 | leaveRule(); | ||
1769 | }: | ||
1770 | ( | ||
1771 | ( | ||
1772 | ( | ||
1773 | { | ||
1774 | $current = forceCreateModelElement( | ||
1775 | grammarAccess.getVLSAtomicConstantAccess().getVLSConstantAction_0_0(), | ||
1776 | $current); | ||
1777 | } | ||
1778 | ) | ||
1779 | ( | ||
1780 | ( | ||
1781 | ( | ||
1782 | lv_name_1_1=RULE_LOWER_WORD_ID | ||
1783 | { | ||
1784 | newLeafNode(lv_name_1_1, grammarAccess.getVLSAtomicConstantAccess().getNameLOWER_WORD_IDTerminalRuleCall_0_1_0_0()); | ||
1785 | } | ||
1786 | { | ||
1787 | if ($current==null) { | ||
1788 | $current = createModelElement(grammarAccess.getVLSAtomicConstantRule()); | ||
1789 | } | ||
1790 | setWithLastConsumed( | ||
1791 | $current, | ||
1792 | "name", | ||
1793 | lv_name_1_1, | ||
1794 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.LOWER_WORD_ID"); | ||
1795 | } | ||
1796 | | | ||
1797 | lv_name_1_2=RULE_SINGLE_QUOTE | ||
1798 | { | ||
1799 | newLeafNode(lv_name_1_2, grammarAccess.getVLSAtomicConstantAccess().getNameSINGLE_QUOTETerminalRuleCall_0_1_0_1()); | ||
1800 | } | ||
1801 | { | ||
1802 | if ($current==null) { | ||
1803 | $current = createModelElement(grammarAccess.getVLSAtomicConstantRule()); | ||
1804 | } | ||
1805 | setWithLastConsumed( | ||
1806 | $current, | ||
1807 | "name", | ||
1808 | lv_name_1_2, | ||
1809 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SINGLE_QUOTE"); | ||
1810 | } | ||
1811 | | | ||
1812 | lv_name_1_3=RULE_DOLLAR_ID | ||
1813 | { | ||
1814 | newLeafNode(lv_name_1_3, grammarAccess.getVLSAtomicConstantAccess().getNameDOLLAR_IDTerminalRuleCall_0_1_0_2()); | ||
1815 | } | ||
1816 | { | ||
1817 | if ($current==null) { | ||
1818 | $current = createModelElement(grammarAccess.getVLSAtomicConstantRule()); | ||
1819 | } | ||
1820 | setWithLastConsumed( | ||
1821 | $current, | ||
1822 | "name", | ||
1823 | lv_name_1_3, | ||
1824 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.DOLLAR_ID"); | ||
1825 | } | ||
1826 | | | ||
1827 | lv_name_1_4=RULE_DOUBLE_DOLLAR_ID | ||
1828 | { | ||
1829 | newLeafNode(lv_name_1_4, grammarAccess.getVLSAtomicConstantAccess().getNameDOUBLE_DOLLAR_IDTerminalRuleCall_0_1_0_3()); | ||
1830 | } | ||
1831 | { | ||
1832 | if ($current==null) { | ||
1833 | $current = createModelElement(grammarAccess.getVLSAtomicConstantRule()); | ||
1834 | } | ||
1835 | setWithLastConsumed( | ||
1836 | $current, | ||
1837 | "name", | ||
1838 | lv_name_1_4, | ||
1839 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.DOUBLE_DOLLAR_ID"); | ||
1840 | } | ||
1841 | | | ||
1842 | { | ||
1843 | newCompositeNode(grammarAccess.getVLSAtomicConstantAccess().getNameVLSRoleParserRuleCall_0_1_0_4()); | ||
1844 | } | ||
1845 | lv_name_1_5=ruleVLSRole | ||
1846 | { | ||
1847 | if ($current==null) { | ||
1848 | $current = createModelElementForParent(grammarAccess.getVLSAtomicConstantRule()); | ||
1849 | } | ||
1850 | set( | ||
1851 | $current, | ||
1852 | "name", | ||
1853 | lv_name_1_5, | ||
1854 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSRole"); | ||
1855 | afterParserOrEnumRuleCall(); | ||
1856 | } | ||
1857 | ) | ||
1858 | ) | ||
1859 | ) | ||
1860 | ) | ||
1861 | | | ||
1862 | ( | ||
1863 | ( | ||
1864 | { | ||
1865 | $current = forceCreateModelElement( | ||
1866 | grammarAccess.getVLSAtomicConstantAccess().getVLSTrueAction_1_0(), | ||
1867 | $current); | ||
1868 | } | ||
1869 | ) | ||
1870 | otherlv_3='$true' | ||
1871 | { | ||
1872 | newLeafNode(otherlv_3, grammarAccess.getVLSAtomicConstantAccess().getTrueKeyword_1_1()); | ||
1873 | } | ||
1874 | ) | ||
1875 | | | ||
1876 | ( | ||
1877 | ( | ||
1878 | { | ||
1879 | $current = forceCreateModelElement( | ||
1880 | grammarAccess.getVLSAtomicConstantAccess().getVLSFalseAction_2_0(), | ||
1881 | $current); | ||
1882 | } | ||
1883 | ) | ||
1884 | otherlv_5='$false' | ||
1885 | { | ||
1886 | newLeafNode(otherlv_5, grammarAccess.getVLSAtomicConstantAccess().getFalseKeyword_2_1()); | ||
1887 | } | ||
1888 | ) | ||
1889 | ) | ||
1890 | ; | ||
1891 | |||
1892 | // Entry rule entryRuleVLSAtomicFunction | ||
1893 | entryRuleVLSAtomicFunction returns [EObject current=null]: | ||
1894 | { newCompositeNode(grammarAccess.getVLSAtomicFunctionRule()); } | ||
1895 | iv_ruleVLSAtomicFunction=ruleVLSAtomicFunction | ||
1896 | { $current=$iv_ruleVLSAtomicFunction.current; } | ||
1897 | EOF; | ||
1898 | |||
1899 | // Rule VLSAtomicFunction | ||
1900 | ruleVLSAtomicFunction returns [EObject current=null] | ||
1901 | @init { | ||
1902 | enterRule(); | ||
1903 | } | ||
1904 | @after { | ||
1905 | leaveRule(); | ||
1906 | }: | ||
1907 | ( | ||
1908 | ( | ||
1909 | ( | ||
1910 | { | ||
1911 | $current = forceCreateModelElement( | ||
1912 | grammarAccess.getVLSAtomicFunctionAccess().getVLSFunctionAction_0_0(), | ||
1913 | $current); | ||
1914 | } | ||
1915 | ) | ||
1916 | ( | ||
1917 | ( | ||
1918 | ( | ||
1919 | lv_constant_1_1=RULE_LOWER_WORD_ID | ||
1920 | { | ||
1921 | newLeafNode(lv_constant_1_1, grammarAccess.getVLSAtomicFunctionAccess().getConstantLOWER_WORD_IDTerminalRuleCall_0_1_0_0()); | ||
1922 | } | ||
1923 | { | ||
1924 | if ($current==null) { | ||
1925 | $current = createModelElement(grammarAccess.getVLSAtomicFunctionRule()); | ||
1926 | } | ||
1927 | setWithLastConsumed( | ||
1928 | $current, | ||
1929 | "constant", | ||
1930 | lv_constant_1_1, | ||
1931 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.LOWER_WORD_ID"); | ||
1932 | } | ||
1933 | | | ||
1934 | lv_constant_1_2=RULE_SINGLE_QUOTE | ||
1935 | { | ||
1936 | newLeafNode(lv_constant_1_2, grammarAccess.getVLSAtomicFunctionAccess().getConstantSINGLE_QUOTETerminalRuleCall_0_1_0_1()); | ||
1937 | } | ||
1938 | { | ||
1939 | if ($current==null) { | ||
1940 | $current = createModelElement(grammarAccess.getVLSAtomicFunctionRule()); | ||
1941 | } | ||
1942 | setWithLastConsumed( | ||
1943 | $current, | ||
1944 | "constant", | ||
1945 | lv_constant_1_2, | ||
1946 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SINGLE_QUOTE"); | ||
1947 | } | ||
1948 | | | ||
1949 | lv_constant_1_3=RULE_DOLLAR_ID | ||
1950 | { | ||
1951 | newLeafNode(lv_constant_1_3, grammarAccess.getVLSAtomicFunctionAccess().getConstantDOLLAR_IDTerminalRuleCall_0_1_0_2()); | ||
1952 | } | ||
1953 | { | ||
1954 | if ($current==null) { | ||
1955 | $current = createModelElement(grammarAccess.getVLSAtomicFunctionRule()); | ||
1956 | } | ||
1957 | setWithLastConsumed( | ||
1958 | $current, | ||
1959 | "constant", | ||
1960 | lv_constant_1_3, | ||
1961 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.DOLLAR_ID"); | ||
1962 | } | ||
1963 | | | ||
1964 | lv_constant_1_4=RULE_DOUBLE_DOLLAR_ID | ||
1965 | { | ||
1966 | newLeafNode(lv_constant_1_4, grammarAccess.getVLSAtomicFunctionAccess().getConstantDOUBLE_DOLLAR_IDTerminalRuleCall_0_1_0_3()); | ||
1967 | } | ||
1968 | { | ||
1969 | if ($current==null) { | ||
1970 | $current = createModelElement(grammarAccess.getVLSAtomicFunctionRule()); | ||
1971 | } | ||
1972 | setWithLastConsumed( | ||
1973 | $current, | ||
1974 | "constant", | ||
1975 | lv_constant_1_4, | ||
1976 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.DOUBLE_DOLLAR_ID"); | ||
1977 | } | ||
1978 | | | ||
1979 | { | ||
1980 | newCompositeNode(grammarAccess.getVLSAtomicFunctionAccess().getConstantVLSRoleParserRuleCall_0_1_0_4()); | ||
1981 | } | ||
1982 | lv_constant_1_5=ruleVLSRole | ||
1983 | { | ||
1984 | if ($current==null) { | ||
1985 | $current = createModelElementForParent(grammarAccess.getVLSAtomicFunctionRule()); | ||
1986 | } | ||
1987 | set( | ||
1988 | $current, | ||
1989 | "constant", | ||
1990 | lv_constant_1_5, | ||
1991 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSRole"); | ||
1992 | afterParserOrEnumRuleCall(); | ||
1993 | } | ||
1994 | ) | ||
1995 | ) | ||
1996 | ) | ||
1997 | ( | ||
1998 | otherlv_2='(' | ||
1999 | { | ||
2000 | newLeafNode(otherlv_2, grammarAccess.getVLSAtomicFunctionAccess().getLeftParenthesisKeyword_0_2_0()); | ||
2001 | } | ||
2002 | ( | ||
2003 | ( | ||
2004 | { | ||
2005 | newCompositeNode(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_0_2_1_0()); | ||
2006 | } | ||
2007 | lv_terms_3_0=ruleVLSFofTerm | ||
2008 | { | ||
2009 | if ($current==null) { | ||
2010 | $current = createModelElementForParent(grammarAccess.getVLSAtomicFunctionRule()); | ||
2011 | } | ||
2012 | add( | ||
2013 | $current, | ||
2014 | "terms", | ||
2015 | lv_terms_3_0, | ||
2016 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSFofTerm"); | ||
2017 | afterParserOrEnumRuleCall(); | ||
2018 | } | ||
2019 | ) | ||
2020 | ) | ||
2021 | ( | ||
2022 | otherlv_4=',' | ||
2023 | { | ||
2024 | newLeafNode(otherlv_4, grammarAccess.getVLSAtomicFunctionAccess().getCommaKeyword_0_2_2_0()); | ||
2025 | } | ||
2026 | ( | ||
2027 | ( | ||
2028 | { | ||
2029 | newCompositeNode(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_0_2_2_1_0()); | ||
2030 | } | ||
2031 | lv_terms_5_0=ruleVLSFofTerm | ||
2032 | { | ||
2033 | if ($current==null) { | ||
2034 | $current = createModelElementForParent(grammarAccess.getVLSAtomicFunctionRule()); | ||
2035 | } | ||
2036 | add( | ||
2037 | $current, | ||
2038 | "terms", | ||
2039 | lv_terms_5_0, | ||
2040 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSFofTerm"); | ||
2041 | afterParserOrEnumRuleCall(); | ||
2042 | } | ||
2043 | ) | ||
2044 | ) | ||
2045 | )* | ||
2046 | otherlv_6=')' | ||
2047 | { | ||
2048 | newLeafNode(otherlv_6, grammarAccess.getVLSAtomicFunctionAccess().getRightParenthesisKeyword_0_2_3()); | ||
2049 | } | ||
2050 | ) | ||
2051 | ) | ||
2052 | | | ||
2053 | ( | ||
2054 | ( | ||
2055 | { | ||
2056 | $current = forceCreateModelElement( | ||
2057 | grammarAccess.getVLSAtomicFunctionAccess().getVLSLessAction_1_0(), | ||
2058 | $current); | ||
2059 | } | ||
2060 | ) | ||
2061 | ( | ||
2062 | ( | ||
2063 | lv_name_8_0='$less' | ||
2064 | { | ||
2065 | newLeafNode(lv_name_8_0, grammarAccess.getVLSAtomicFunctionAccess().getNameLessKeyword_1_1_0()); | ||
2066 | } | ||
2067 | { | ||
2068 | if ($current==null) { | ||
2069 | $current = createModelElement(grammarAccess.getVLSAtomicFunctionRule()); | ||
2070 | } | ||
2071 | setWithLastConsumed($current, "name", lv_name_8_0, "\$less"); | ||
2072 | } | ||
2073 | ) | ||
2074 | ) | ||
2075 | otherlv_9='(' | ||
2076 | { | ||
2077 | newLeafNode(otherlv_9, grammarAccess.getVLSAtomicFunctionAccess().getLeftParenthesisKeyword_1_2()); | ||
2078 | } | ||
2079 | ( | ||
2080 | ( | ||
2081 | { | ||
2082 | newCompositeNode(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_1_3_0()); | ||
2083 | } | ||
2084 | lv_terms_10_0=ruleVLSFofTerm | ||
2085 | { | ||
2086 | if ($current==null) { | ||
2087 | $current = createModelElementForParent(grammarAccess.getVLSAtomicFunctionRule()); | ||
2088 | } | ||
2089 | add( | ||
2090 | $current, | ||
2091 | "terms", | ||
2092 | lv_terms_10_0, | ||
2093 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSFofTerm"); | ||
2094 | afterParserOrEnumRuleCall(); | ||
2095 | } | ||
2096 | ) | ||
2097 | ) | ||
2098 | otherlv_11=',' | ||
2099 | { | ||
2100 | newLeafNode(otherlv_11, grammarAccess.getVLSAtomicFunctionAccess().getCommaKeyword_1_4()); | ||
2101 | } | ||
2102 | ( | ||
2103 | ( | ||
2104 | { | ||
2105 | newCompositeNode(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_1_5_0()); | ||
2106 | } | ||
2107 | lv_terms_12_0=ruleVLSFofTerm | ||
2108 | { | ||
2109 | if ($current==null) { | ||
2110 | $current = createModelElementForParent(grammarAccess.getVLSAtomicFunctionRule()); | ||
2111 | } | ||
2112 | add( | ||
2113 | $current, | ||
2114 | "terms", | ||
2115 | lv_terms_12_0, | ||
2116 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSFofTerm"); | ||
2117 | afterParserOrEnumRuleCall(); | ||
2118 | } | ||
2119 | ) | ||
2120 | ) | ||
2121 | otherlv_13=')' | ||
2122 | { | ||
2123 | newLeafNode(otherlv_13, grammarAccess.getVLSAtomicFunctionAccess().getRightParenthesisKeyword_1_6()); | ||
2124 | } | ||
2125 | ) | ||
2126 | ) | ||
2127 | ; | ||
2128 | |||
2129 | // Entry rule entryRuleVLSVariable | ||
2130 | entryRuleVLSVariable returns [EObject current=null]: | ||
2131 | { newCompositeNode(grammarAccess.getVLSVariableRule()); } | ||
2132 | iv_ruleVLSVariable=ruleVLSVariable | ||
2133 | { $current=$iv_ruleVLSVariable.current; } | ||
2134 | EOF; | ||
2135 | |||
2136 | // Rule VLSVariable | ||
2137 | ruleVLSVariable returns [EObject current=null] | ||
2138 | @init { | ||
2139 | enterRule(); | ||
2140 | } | ||
2141 | @after { | ||
2142 | leaveRule(); | ||
2143 | }: | ||
2144 | ( | ||
2145 | ( | ||
2146 | lv_name_0_0=RULE_UPPER_WORD_ID | ||
2147 | { | ||
2148 | newLeafNode(lv_name_0_0, grammarAccess.getVLSVariableAccess().getNameUPPER_WORD_IDTerminalRuleCall_0()); | ||
2149 | } | ||
2150 | { | ||
2151 | if ($current==null) { | ||
2152 | $current = createModelElement(grammarAccess.getVLSVariableRule()); | ||
2153 | } | ||
2154 | setWithLastConsumed( | ||
2155 | $current, | ||
2156 | "name", | ||
2157 | lv_name_0_0, | ||
2158 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.UPPER_WORD_ID"); | ||
2159 | } | ||
2160 | ) | ||
2161 | ) | ||
2162 | ; | ||
2163 | |||
2164 | // Entry rule entryRuleVLSFofTerm | ||
2165 | entryRuleVLSFofTerm returns [EObject current=null]: | ||
2166 | { newCompositeNode(grammarAccess.getVLSFofTermRule()); } | ||
2167 | iv_ruleVLSFofTerm=ruleVLSFofTerm | ||
2168 | { $current=$iv_ruleVLSFofTerm.current; } | ||
2169 | EOF; | ||
2170 | |||
2171 | // Rule VLSFofTerm | ||
2172 | ruleVLSFofTerm returns [EObject current=null] | ||
2173 | @init { | ||
2174 | enterRule(); | ||
2175 | } | ||
2176 | @after { | ||
2177 | leaveRule(); | ||
2178 | }: | ||
2179 | ( | ||
2180 | { | ||
2181 | newCompositeNode(grammarAccess.getVLSFofTermAccess().getVLSVariableParserRuleCall_0()); | ||
2182 | } | ||
2183 | this_VLSVariable_0=ruleVLSVariable | ||
2184 | { | ||
2185 | $current = $this_VLSVariable_0.current; | ||
2186 | afterParserOrEnumRuleCall(); | ||
2187 | } | ||
2188 | | | ||
2189 | { | ||
2190 | newCompositeNode(grammarAccess.getVLSFofTermAccess().getVLSFunctionFofParserRuleCall_1()); | ||
2191 | } | ||
2192 | this_VLSFunctionFof_1=ruleVLSFunctionFof | ||
2193 | { | ||
2194 | $current = $this_VLSFunctionFof_1.current; | ||
2195 | afterParserOrEnumRuleCall(); | ||
2196 | } | ||
2197 | | | ||
2198 | { | ||
2199 | newCompositeNode(grammarAccess.getVLSFofTermAccess().getVLSDefinedTermParserRuleCall_2()); | ||
2200 | } | ||
2201 | this_VLSDefinedTerm_2=ruleVLSDefinedTerm | ||
2202 | { | ||
2203 | $current = $this_VLSDefinedTerm_2.current; | ||
2204 | afterParserOrEnumRuleCall(); | ||
2205 | } | ||
2206 | ) | ||
2207 | ; | ||
2208 | |||
2209 | // Entry rule entryRuleVLSFunctionFof | ||
2210 | entryRuleVLSFunctionFof returns [EObject current=null]: | ||
2211 | { newCompositeNode(grammarAccess.getVLSFunctionFofRule()); } | ||
2212 | iv_ruleVLSFunctionFof=ruleVLSFunctionFof | ||
2213 | { $current=$iv_ruleVLSFunctionFof.current; } | ||
2214 | EOF; | ||
2215 | |||
2216 | // Rule VLSFunctionFof | ||
2217 | ruleVLSFunctionFof returns [EObject current=null] | ||
2218 | @init { | ||
2219 | enterRule(); | ||
2220 | } | ||
2221 | @after { | ||
2222 | leaveRule(); | ||
2223 | }: | ||
2224 | ( | ||
2225 | ( | ||
2226 | ( | ||
2227 | ( | ||
2228 | lv_functor_0_1=RULE_LOWER_WORD_ID | ||
2229 | { | ||
2230 | newLeafNode(lv_functor_0_1, grammarAccess.getVLSFunctionFofAccess().getFunctorLOWER_WORD_IDTerminalRuleCall_0_0_0()); | ||
2231 | } | ||
2232 | { | ||
2233 | if ($current==null) { | ||
2234 | $current = createModelElement(grammarAccess.getVLSFunctionFofRule()); | ||
2235 | } | ||
2236 | setWithLastConsumed( | ||
2237 | $current, | ||
2238 | "functor", | ||
2239 | lv_functor_0_1, | ||
2240 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.LOWER_WORD_ID"); | ||
2241 | } | ||
2242 | | | ||
2243 | lv_functor_0_2=RULE_SINGLE_QUOTE | ||
2244 | { | ||
2245 | newLeafNode(lv_functor_0_2, grammarAccess.getVLSFunctionFofAccess().getFunctorSINGLE_QUOTETerminalRuleCall_0_0_1()); | ||
2246 | } | ||
2247 | { | ||
2248 | if ($current==null) { | ||
2249 | $current = createModelElement(grammarAccess.getVLSFunctionFofRule()); | ||
2250 | } | ||
2251 | setWithLastConsumed( | ||
2252 | $current, | ||
2253 | "functor", | ||
2254 | lv_functor_0_2, | ||
2255 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SINGLE_QUOTE"); | ||
2256 | } | ||
2257 | | | ||
2258 | lv_functor_0_3=RULE_DOLLAR_ID | ||
2259 | { | ||
2260 | newLeafNode(lv_functor_0_3, grammarAccess.getVLSFunctionFofAccess().getFunctorDOLLAR_IDTerminalRuleCall_0_0_2()); | ||
2261 | } | ||
2262 | { | ||
2263 | if ($current==null) { | ||
2264 | $current = createModelElement(grammarAccess.getVLSFunctionFofRule()); | ||
2265 | } | ||
2266 | setWithLastConsumed( | ||
2267 | $current, | ||
2268 | "functor", | ||
2269 | lv_functor_0_3, | ||
2270 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.DOLLAR_ID"); | ||
2271 | } | ||
2272 | | | ||
2273 | lv_functor_0_4=RULE_DOUBLE_DOLLAR_ID | ||
2274 | { | ||
2275 | newLeafNode(lv_functor_0_4, grammarAccess.getVLSFunctionFofAccess().getFunctorDOUBLE_DOLLAR_IDTerminalRuleCall_0_0_3()); | ||
2276 | } | ||
2277 | { | ||
2278 | if ($current==null) { | ||
2279 | $current = createModelElement(grammarAccess.getVLSFunctionFofRule()); | ||
2280 | } | ||
2281 | setWithLastConsumed( | ||
2282 | $current, | ||
2283 | "functor", | ||
2284 | lv_functor_0_4, | ||
2285 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.DOUBLE_DOLLAR_ID"); | ||
2286 | } | ||
2287 | ) | ||
2288 | ) | ||
2289 | ) | ||
2290 | ( | ||
2291 | otherlv_1='(' | ||
2292 | { | ||
2293 | newLeafNode(otherlv_1, grammarAccess.getVLSFunctionFofAccess().getLeftParenthesisKeyword_1_0()); | ||
2294 | } | ||
2295 | ( | ||
2296 | ( | ||
2297 | { | ||
2298 | newCompositeNode(grammarAccess.getVLSFunctionFofAccess().getTermsVLSFofTermParserRuleCall_1_1_0()); | ||
2299 | } | ||
2300 | lv_terms_2_0=ruleVLSFofTerm | ||
2301 | { | ||
2302 | if ($current==null) { | ||
2303 | $current = createModelElementForParent(grammarAccess.getVLSFunctionFofRule()); | ||
2304 | } | ||
2305 | add( | ||
2306 | $current, | ||
2307 | "terms", | ||
2308 | lv_terms_2_0, | ||
2309 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSFofTerm"); | ||
2310 | afterParserOrEnumRuleCall(); | ||
2311 | } | ||
2312 | ) | ||
2313 | ) | ||
2314 | ( | ||
2315 | otherlv_3=',' | ||
2316 | { | ||
2317 | newLeafNode(otherlv_3, grammarAccess.getVLSFunctionFofAccess().getCommaKeyword_1_2_0()); | ||
2318 | } | ||
2319 | ( | ||
2320 | ( | ||
2321 | { | ||
2322 | newCompositeNode(grammarAccess.getVLSFunctionFofAccess().getTermsVLSFofTermParserRuleCall_1_2_1_0()); | ||
2323 | } | ||
2324 | lv_terms_4_0=ruleVLSFofTerm | ||
2325 | { | ||
2326 | if ($current==null) { | ||
2327 | $current = createModelElementForParent(grammarAccess.getVLSFunctionFofRule()); | ||
2328 | } | ||
2329 | add( | ||
2330 | $current, | ||
2331 | "terms", | ||
2332 | lv_terms_4_0, | ||
2333 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.VLSFofTerm"); | ||
2334 | afterParserOrEnumRuleCall(); | ||
2335 | } | ||
2336 | ) | ||
2337 | ) | ||
2338 | )* | ||
2339 | otherlv_5=')' | ||
2340 | { | ||
2341 | newLeafNode(otherlv_5, grammarAccess.getVLSFunctionFofAccess().getRightParenthesisKeyword_1_3()); | ||
2342 | } | ||
2343 | )? | ||
2344 | ) | ||
2345 | ; | ||
2346 | |||
2347 | // Entry rule entryRuleVLSDefinedTerm | ||
2348 | entryRuleVLSDefinedTerm returns [EObject current=null]: | ||
2349 | { newCompositeNode(grammarAccess.getVLSDefinedTermRule()); } | ||
2350 | iv_ruleVLSDefinedTerm=ruleVLSDefinedTerm | ||
2351 | { $current=$iv_ruleVLSDefinedTerm.current; } | ||
2352 | EOF; | ||
2353 | |||
2354 | // Rule VLSDefinedTerm | ||
2355 | ruleVLSDefinedTerm returns [EObject current=null] | ||
2356 | @init { | ||
2357 | enterRule(); | ||
2358 | } | ||
2359 | @after { | ||
2360 | leaveRule(); | ||
2361 | }: | ||
2362 | ( | ||
2363 | ( | ||
2364 | ( | ||
2365 | { | ||
2366 | $current = forceCreateModelElement( | ||
2367 | grammarAccess.getVLSDefinedTermAccess().getVLSIntAction_0_0(), | ||
2368 | $current); | ||
2369 | } | ||
2370 | ) | ||
2371 | ( | ||
2372 | ( | ||
2373 | lv_value_1_0=RULE_SIGNED_LITERAL | ||
2374 | { | ||
2375 | newLeafNode(lv_value_1_0, grammarAccess.getVLSDefinedTermAccess().getValueSIGNED_LITERALTerminalRuleCall_0_1_0()); | ||
2376 | } | ||
2377 | { | ||
2378 | if ($current==null) { | ||
2379 | $current = createModelElement(grammarAccess.getVLSDefinedTermRule()); | ||
2380 | } | ||
2381 | setWithLastConsumed( | ||
2382 | $current, | ||
2383 | "value", | ||
2384 | lv_value_1_0, | ||
2385 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SIGNED_LITERAL"); | ||
2386 | } | ||
2387 | ) | ||
2388 | ) | ||
2389 | ) | ||
2390 | | | ||
2391 | ( | ||
2392 | ( | ||
2393 | { | ||
2394 | $current = forceCreateModelElement( | ||
2395 | grammarAccess.getVLSDefinedTermAccess().getVLSRealAction_1_0(), | ||
2396 | $current); | ||
2397 | } | ||
2398 | ) | ||
2399 | ( | ||
2400 | ( | ||
2401 | lv_value_3_0=RULE_SIGNED_REAL_ID | ||
2402 | { | ||
2403 | newLeafNode(lv_value_3_0, grammarAccess.getVLSDefinedTermAccess().getValueSIGNED_REAL_IDTerminalRuleCall_1_1_0()); | ||
2404 | } | ||
2405 | { | ||
2406 | if ($current==null) { | ||
2407 | $current = createModelElement(grammarAccess.getVLSDefinedTermRule()); | ||
2408 | } | ||
2409 | setWithLastConsumed( | ||
2410 | $current, | ||
2411 | "value", | ||
2412 | lv_value_3_0, | ||
2413 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SIGNED_REAL_ID"); | ||
2414 | } | ||
2415 | ) | ||
2416 | ) | ||
2417 | ) | ||
2418 | | | ||
2419 | ( | ||
2420 | ( | ||
2421 | { | ||
2422 | $current = forceCreateModelElement( | ||
2423 | grammarAccess.getVLSDefinedTermAccess().getVLSRationalAction_2_0(), | ||
2424 | $current); | ||
2425 | } | ||
2426 | ) | ||
2427 | ( | ||
2428 | ( | ||
2429 | lv_value_5_0=RULE_SIGNED_RAT_ID | ||
2430 | { | ||
2431 | newLeafNode(lv_value_5_0, grammarAccess.getVLSDefinedTermAccess().getValueSIGNED_RAT_IDTerminalRuleCall_2_1_0()); | ||
2432 | } | ||
2433 | { | ||
2434 | if ($current==null) { | ||
2435 | $current = createModelElement(grammarAccess.getVLSDefinedTermRule()); | ||
2436 | } | ||
2437 | setWithLastConsumed( | ||
2438 | $current, | ||
2439 | "value", | ||
2440 | lv_value_5_0, | ||
2441 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.SIGNED_RAT_ID"); | ||
2442 | } | ||
2443 | ) | ||
2444 | ) | ||
2445 | ) | ||
2446 | | | ||
2447 | ( | ||
2448 | ( | ||
2449 | { | ||
2450 | $current = forceCreateModelElement( | ||
2451 | grammarAccess.getVLSDefinedTermAccess().getVLSDoubleQuoteAction_3_0(), | ||
2452 | $current); | ||
2453 | } | ||
2454 | ) | ||
2455 | ( | ||
2456 | ( | ||
2457 | lv_value_7_0=RULE_DOUBLE_QUOTE | ||
2458 | { | ||
2459 | newLeafNode(lv_value_7_0, grammarAccess.getVLSDefinedTermAccess().getValueDOUBLE_QUOTETerminalRuleCall_3_1_0()); | ||
2460 | } | ||
2461 | { | ||
2462 | if ($current==null) { | ||
2463 | $current = createModelElement(grammarAccess.getVLSDefinedTermRule()); | ||
2464 | } | ||
2465 | setWithLastConsumed( | ||
2466 | $current, | ||
2467 | "value", | ||
2468 | lv_value_7_0, | ||
2469 | "ca.mcgill.ecse.dslreasoner.VampireLanguage.DOUBLE_QUOTE"); | ||
2470 | } | ||
2471 | ) | ||
2472 | ) | ||
2473 | ) | ||
2474 | ) | ||
2475 | ; | ||
2476 | |||
2477 | fragment RULE_ALPHA_NUMERIC : ('a'..'z'|'A'..'Z'|'0'..'9'|'_'); | ||
2478 | |||
2479 | RULE_UPPER_WORD_ID : 'A'..'Z' RULE_ALPHA_NUMERIC*; | ||
2480 | |||
2481 | RULE_LOWER_WORD_ID : 'a'..'z' RULE_ALPHA_NUMERIC*; | ||
2482 | |||
2483 | RULE_DOUBLE_QUOTE : '"' ('\\' ('"'|'\\')|~(('\\'|'"')))* '"'; | ||
2484 | |||
2485 | RULE_SINGLE_QUOTE : '\'' ('\\' ('\''|'\\')|~(('\\'|'\'')))+ '\''; | ||
2486 | |||
2487 | fragment RULE_SIGN : ('+'|'-'); | ||
2488 | |||
2489 | RULE_DOLLAR_ID : '$' RULE_LOWER_WORD_ID; | ||
2490 | |||
2491 | RULE_DOUBLE_DOLLAR_ID : '$$' RULE_LOWER_WORD_ID; | ||
2492 | |||
2493 | RULE_LITERAL : ('0'|'1'..'9' RULE_INT?); | ||
2494 | |||
2495 | RULE_SIGNED_LITERAL : RULE_SIGN* RULE_LITERAL; | ||
2496 | |||
2497 | fragment RULE_UNSIGNED_REAL_FRAC_ID : RULE_LITERAL '.' RULE_INT; | ||
2498 | |||
2499 | fragment RULE_UNSIGNED_REAL_EXP_ID : (RULE_LITERAL|RULE_UNSIGNED_REAL_FRAC_ID) 'Ee' RULE_SIGN* RULE_INT; | ||
2500 | |||
2501 | RULE_SIGNED_REAL_ID : RULE_SIGN* (RULE_UNSIGNED_REAL_FRAC_ID|RULE_UNSIGNED_REAL_EXP_ID); | ||
2502 | |||
2503 | fragment RULE_UNSIGNED_RAT_ID : RULE_LITERAL '/' '1'..'9' RULE_INT?; | ||
2504 | |||
2505 | RULE_SIGNED_RAT_ID : RULE_SIGN* RULE_UNSIGNED_RAT_ID; | ||
2506 | |||
2507 | fragment RULE_ID : ~(('\n'|'\r'))*; | ||
2508 | |||
2509 | fragment RULE_ANY_OTHER : RULE_ID; | ||
2510 | |||
2511 | RULE_SINGLE_COMMENT : RULE_ANY_OTHER; | ||
2512 | |||
2513 | fragment RULE_INT : ('0'..'9')+; | ||
2514 | |||
2515 | RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); | ||
2516 | |||
2517 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | ||
2518 | |||
2519 | RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; | ||
2520 | |||
2521 | RULE_WS : (' '|'\t'|'\r'|'\n')+; | ||