aboutsummaryrefslogtreecommitdiffstats
path: root/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g
diff options
context:
space:
mode:
authorLibravatar Kristóf Marussy <marussy@mit.bme.hu>2020-05-08 21:02:33 +0200
committerLibravatar Kristóf Marussy <marussy@mit.bme.hu>2020-05-08 21:02:33 +0200
commit771e3773bb7ebbf6712724cb2b248467c9cc2e3c (patch)
treeb1724af24b9c583b2780c7a2fe76e76fd174359d /Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g
parentUpdate solver language grammar (diff)
downloadVIATRA-Generator-771e3773bb7ebbf6712724cb2b248467c9cc2e3c.tar.gz
VIATRA-Generator-771e3773bb7ebbf6712724cb2b248467c9cc2e3c.tar.zst
VIATRA-Generator-771e3773bb7ebbf6712724cb2b248467c9cc2e3c.zip
Synthetic tokens for solver language
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g')
-rw-r--r--Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g3902
1 files changed, 0 insertions, 3902 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g
deleted file mode 100644
index 3fac9254..00000000
--- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g
+++ /dev/null
@@ -1,3902 +0,0 @@
1/*
2 * generated by Xtext 2.21.0
3 */
4grammar InternalSolverLanguage;
5
6options {
7 superClass=AbstractInternalAntlrParser;
8}
9
10@lexer::header {
11package org.eclipse.viatra.solver.language.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.
15import org.eclipse.xtext.parser.antlr.Lexer;
16}
17
18@parser::header {
19package org.eclipse.viatra.solver.language.parser.antlr.internal;
20
21import org.eclipse.xtext.*;
22import org.eclipse.xtext.parser.*;
23import org.eclipse.xtext.parser.impl.*;
24import org.eclipse.emf.ecore.util.EcoreUtil;
25import org.eclipse.emf.ecore.EObject;
26import org.eclipse.emf.common.util.Enumerator;
27import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
28import org.eclipse.xtext.parser.antlr.XtextTokenStream;
29import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
30import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
31import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
32
33}
34
35@parser::members {
36
37 private SolverLanguageGrammarAccess grammarAccess;
38
39 public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) {
40 this(input);
41 this.grammarAccess = grammarAccess;
42 registerRules(grammarAccess.getGrammar());
43 }
44
45 @Override
46 protected String getFirstRuleName() {
47 return "Problem";
48 }
49
50 @Override
51 protected SolverLanguageGrammarAccess getGrammarAccess() {
52 return grammarAccess;
53 }
54
55}
56
57@rulecatch {
58 catch (RecognitionException re) {
59 recover(input,re);
60 appendSkippedTokens();
61 }
62}
63
64// Entry rule entryRuleProblem
65entryRuleProblem returns [EObject current=null]:
66 { newCompositeNode(grammarAccess.getProblemRule()); }
67 iv_ruleProblem=ruleProblem
68 { $current=$iv_ruleProblem.current; }
69 EOF;
70
71// Rule Problem
72ruleProblem returns [EObject current=null]
73@init {
74 enterRule();
75}
76@after {
77 leaveRule();
78}:
79 (
80 (
81 {
82 newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0());
83 }
84 lv_statements_0_0=ruleStatement
85 {
86 if ($current==null) {
87 $current = createModelElementForParent(grammarAccess.getProblemRule());
88 }
89 add(
90 $current,
91 "statements",
92 lv_statements_0_0,
93 "org.eclipse.viatra.solver.language.SolverLanguage.Statement");
94 afterParserOrEnumRuleCall();
95 }
96 )
97 )*
98;
99
100// Entry rule entryRuleStatement
101entryRuleStatement returns [EObject current=null]:
102 { newCompositeNode(grammarAccess.getStatementRule()); }
103 iv_ruleStatement=ruleStatement
104 { $current=$iv_ruleStatement.current; }
105 EOF;
106
107// Rule Statement
108ruleStatement returns [EObject current=null]
109@init {
110 enterRule();
111}
112@after {
113 leaveRule();
114}:
115 (
116 (
117 {
118 newCompositeNode(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0());
119 }
120 this_AssertionOrDefinition_0=ruleAssertionOrDefinition
121 {
122 $current = $this_AssertionOrDefinition_0.current;
123 afterParserOrEnumRuleCall();
124 }
125 |
126 {
127 newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1());
128 }
129 this_PredicateDefinition_1=rulePredicateDefinition
130 {
131 $current = $this_PredicateDefinition_1.current;
132 afterParserOrEnumRuleCall();
133 }
134 |
135 {
136 newCompositeNode(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2());
137 }
138 this_UnnamedErrorPrediateDefinition_2=ruleUnnamedErrorPrediateDefinition
139 {
140 $current = $this_UnnamedErrorPrediateDefinition_2.current;
141 afterParserOrEnumRuleCall();
142 }
143 |
144 {
145 newCompositeNode(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3());
146 }
147 this_DefaultDefinition_3=ruleDefaultDefinition
148 {
149 $current = $this_DefaultDefinition_3.current;
150 afterParserOrEnumRuleCall();
151 }
152 |
153 {
154 newCompositeNode(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4());
155 }
156 this_ExternPredicateDefinition_4=ruleExternPredicateDefinition
157 {
158 $current = $this_ExternPredicateDefinition_4.current;
159 afterParserOrEnumRuleCall();
160 }
161 |
162 {
163 newCompositeNode(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5());
164 }
165 this_MetricDefinition_5=ruleMetricDefinition
166 {
167 $current = $this_MetricDefinition_5.current;
168 afterParserOrEnumRuleCall();
169 }
170 |
171 {
172 newCompositeNode(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6());
173 }
174 this_ExternMetricDefinition_6=ruleExternMetricDefinition
175 {
176 $current = $this_ExternMetricDefinition_6.current;
177 afterParserOrEnumRuleCall();
178 }
179 |
180 {
181 newCompositeNode(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7());
182 }
183 this_ClassDefinition_7=ruleClassDefinition
184 {
185 $current = $this_ClassDefinition_7.current;
186 afterParserOrEnumRuleCall();
187 }
188 |
189 {
190 newCompositeNode(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8());
191 }
192 this_ScopeDefinition_8=ruleScopeDefinition
193 {
194 $current = $this_ScopeDefinition_8.current;
195 afterParserOrEnumRuleCall();
196 }
197 |
198 {
199 newCompositeNode(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9());
200 }
201 this_ObjectiveDefinition_9=ruleObjectiveDefinition
202 {
203 $current = $this_ObjectiveDefinition_9.current;
204 afterParserOrEnumRuleCall();
205 }
206 )
207 this_DOT_10=RULE_DOT
208 {
209 newLeafNode(this_DOT_10, grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1());
210 }
211 )
212;
213
214// Entry rule entryRuleAssertionOrDefinition
215entryRuleAssertionOrDefinition returns [EObject current=null]:
216 { newCompositeNode(grammarAccess.getAssertionOrDefinitionRule()); }
217 iv_ruleAssertionOrDefinition=ruleAssertionOrDefinition
218 { $current=$iv_ruleAssertionOrDefinition.current; }
219 EOF;
220
221// Rule AssertionOrDefinition
222ruleAssertionOrDefinition returns [EObject current=null]
223@init {
224 enterRule();
225}
226@after {
227 leaveRule();
228}:
229 (
230 {
231 newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0());
232 }
233 this_Expression_0=ruleExpression
234 {
235 $current = $this_Expression_0.current;
236 afterParserOrEnumRuleCall();
237 }
238 (
239 (
240 (
241 {
242 $current = forceCreateModelElementAndSet(
243 grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0(),
244 $current);
245 }
246 )
247 (
248 otherlv_2=':'
249 {
250 newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0());
251 }
252 (
253 (
254 {
255 newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0());
256 }
257 lv_range_3_0=ruleExpression
258 {
259 if ($current==null) {
260 $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule());
261 }
262 set(
263 $current,
264 "range",
265 lv_range_3_0,
266 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
267 afterParserOrEnumRuleCall();
268 }
269 )
270 )
271 )?
272 )
273 |
274 (
275 (
276 {
277 $current = forceCreateModelElementAndSet(
278 grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(),
279 $current);
280 }
281 )
282 otherlv_5=':-'
283 {
284 newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1());
285 }
286 (
287 (
288 {
289 newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0());
290 }
291 lv_body_6_0=ruleExpression
292 {
293 if ($current==null) {
294 $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule());
295 }
296 set(
297 $current,
298 "body",
299 lv_body_6_0,
300 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
301 afterParserOrEnumRuleCall();
302 }
303 )
304 )
305 )
306 |
307 (
308 (
309 {
310 $current = forceCreateModelElementAndSet(
311 grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(),
312 $current);
313 }
314 )
315 otherlv_8='='
316 {
317 newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1());
318 }
319 (
320 (
321 {
322 newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0());
323 }
324 lv_body_9_0=ruleExpression
325 {
326 if ($current==null) {
327 $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule());
328 }
329 set(
330 $current,
331 "body",
332 lv_body_9_0,
333 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
334 afterParserOrEnumRuleCall();
335 }
336 )
337 )
338 )
339 )
340 )
341;
342
343// Entry rule entryRulePredicateDefinition
344entryRulePredicateDefinition returns [EObject current=null]:
345 { newCompositeNode(grammarAccess.getPredicateDefinitionRule()); }
346 iv_rulePredicateDefinition=rulePredicateDefinition
347 { $current=$iv_rulePredicateDefinition.current; }
348 EOF;
349
350// Rule PredicateDefinition
351rulePredicateDefinition returns [EObject current=null]
352@init {
353 enterRule();
354}
355@after {
356 leaveRule();
357}:
358 (
359 (
360 (
361 (
362 (
363 lv_functional_0_0='functional'
364 {
365 newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0());
366 }
367 {
368 if ($current==null) {
369 $current = createModelElement(grammarAccess.getPredicateDefinitionRule());
370 }
371 setWithLastConsumed($current, "functional", true, "functional");
372 }
373 )
374 )
375 (
376 (
377 lv_error_1_0='error'
378 {
379 newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0());
380 }
381 {
382 if ($current==null) {
383 $current = createModelElement(grammarAccess.getPredicateDefinitionRule());
384 }
385 setWithLastConsumed($current, "error", true, "error");
386 }
387 )
388 )?
389 )
390 |
391 (
392 (
393 (
394 lv_error_2_0='error'
395 {
396 newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0());
397 }
398 {
399 if ($current==null) {
400 $current = createModelElement(grammarAccess.getPredicateDefinitionRule());
401 }
402 setWithLastConsumed($current, "error", true, "error");
403 }
404 )
405 )
406 (
407 (
408 lv_functional_3_0='functional'
409 {
410 newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0());
411 }
412 {
413 if ($current==null) {
414 $current = createModelElement(grammarAccess.getPredicateDefinitionRule());
415 }
416 setWithLastConsumed($current, "functional", true, "functional");
417 }
418 )
419 )?
420 )
421 )
422 (
423 (
424 {
425 newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0());
426 }
427 lv_head_4_0=ruleCall
428 {
429 if ($current==null) {
430 $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule());
431 }
432 set(
433 $current,
434 "head",
435 lv_head_4_0,
436 "org.eclipse.viatra.solver.language.SolverLanguage.Call");
437 afterParserOrEnumRuleCall();
438 }
439 )
440 )
441 otherlv_5=':-'
442 {
443 newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2());
444 }
445 (
446 (
447 {
448 newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0());
449 }
450 lv_body_6_0=ruleExpression
451 {
452 if ($current==null) {
453 $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule());
454 }
455 set(
456 $current,
457 "body",
458 lv_body_6_0,
459 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
460 afterParserOrEnumRuleCall();
461 }
462 )
463 )
464 )
465;
466
467// Entry rule entryRuleUnnamedErrorPrediateDefinition
468entryRuleUnnamedErrorPrediateDefinition returns [EObject current=null]:
469 { newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); }
470 iv_ruleUnnamedErrorPrediateDefinition=ruleUnnamedErrorPrediateDefinition
471 { $current=$iv_ruleUnnamedErrorPrediateDefinition.current; }
472 EOF;
473
474// Rule UnnamedErrorPrediateDefinition
475ruleUnnamedErrorPrediateDefinition returns [EObject current=null]
476@init {
477 enterRule();
478}
479@after {
480 leaveRule();
481}:
482 (
483 otherlv_0='error'
484 {
485 newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0());
486 }
487 (
488 (
489 {
490 newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0());
491 }
492 lv_argumentList_1_0=ruleArgumentList
493 {
494 if ($current==null) {
495 $current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule());
496 }
497 set(
498 $current,
499 "argumentList",
500 lv_argumentList_1_0,
501 "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList");
502 afterParserOrEnumRuleCall();
503 }
504 )
505 )
506 otherlv_2=':-'
507 {
508 newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2());
509 }
510 (
511 (
512 {
513 newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0());
514 }
515 lv_body_3_0=ruleExpression
516 {
517 if ($current==null) {
518 $current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule());
519 }
520 set(
521 $current,
522 "body",
523 lv_body_3_0,
524 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
525 afterParserOrEnumRuleCall();
526 }
527 )
528 )
529 )
530;
531
532// Entry rule entryRuleDefaultDefinition
533entryRuleDefaultDefinition returns [EObject current=null]:
534 { newCompositeNode(grammarAccess.getDefaultDefinitionRule()); }
535 iv_ruleDefaultDefinition=ruleDefaultDefinition
536 { $current=$iv_ruleDefaultDefinition.current; }
537 EOF;
538
539// Rule DefaultDefinition
540ruleDefaultDefinition returns [EObject current=null]
541@init {
542 enterRule();
543}
544@after {
545 leaveRule();
546}:
547 (
548 otherlv_0='default'
549 {
550 newLeafNode(otherlv_0, grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0());
551 }
552 (
553 (
554 {
555 newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0());
556 }
557 lv_head_1_0=ruleCall
558 {
559 if ($current==null) {
560 $current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule());
561 }
562 set(
563 $current,
564 "head",
565 lv_head_1_0,
566 "org.eclipse.viatra.solver.language.SolverLanguage.Call");
567 afterParserOrEnumRuleCall();
568 }
569 )
570 )
571 otherlv_2=':'
572 {
573 newLeafNode(otherlv_2, grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2());
574 }
575 (
576 (
577 {
578 newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0());
579 }
580 lv_range_3_0=ruleExpression
581 {
582 if ($current==null) {
583 $current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule());
584 }
585 set(
586 $current,
587 "range",
588 lv_range_3_0,
589 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
590 afterParserOrEnumRuleCall();
591 }
592 )
593 )
594 )
595;
596
597// Entry rule entryRuleExternPredicateDefinition
598entryRuleExternPredicateDefinition returns [EObject current=null]:
599 { newCompositeNode(grammarAccess.getExternPredicateDefinitionRule()); }
600 iv_ruleExternPredicateDefinition=ruleExternPredicateDefinition
601 { $current=$iv_ruleExternPredicateDefinition.current; }
602 EOF;
603
604// Rule ExternPredicateDefinition
605ruleExternPredicateDefinition returns [EObject current=null]
606@init {
607 enterRule();
608}
609@after {
610 leaveRule();
611}:
612 (
613 otherlv_0='extern'
614 {
615 newLeafNode(otherlv_0, grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0());
616 }
617 (
618 (
619 {
620 newCompositeNode(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0());
621 }
622 lv_head_1_0=ruleCall
623 {
624 if ($current==null) {
625 $current = createModelElementForParent(grammarAccess.getExternPredicateDefinitionRule());
626 }
627 set(
628 $current,
629 "head",
630 lv_head_1_0,
631 "org.eclipse.viatra.solver.language.SolverLanguage.Call");
632 afterParserOrEnumRuleCall();
633 }
634 )
635 )
636 otherlv_2='.'
637 {
638 newLeafNode(otherlv_2, grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2());
639 }
640 )
641;
642
643// Entry rule entryRuleMetricDefinition
644entryRuleMetricDefinition returns [EObject current=null]:
645 { newCompositeNode(grammarAccess.getMetricDefinitionRule()); }
646 iv_ruleMetricDefinition=ruleMetricDefinition
647 { $current=$iv_ruleMetricDefinition.current; }
648 EOF;
649
650// Rule MetricDefinition
651ruleMetricDefinition returns [EObject current=null]
652@init {
653 enterRule();
654}
655@after {
656 leaveRule();
657}:
658 (
659 (
660 (
661 {
662 newCompositeNode(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0());
663 }
664 lv_type_0_0=ruleMetricType
665 {
666 if ($current==null) {
667 $current = createModelElementForParent(grammarAccess.getMetricDefinitionRule());
668 }
669 set(
670 $current,
671 "type",
672 lv_type_0_0,
673 "org.eclipse.viatra.solver.language.SolverLanguage.MetricType");
674 afterParserOrEnumRuleCall();
675 }
676 )
677 )
678 (
679 (
680 {
681 newCompositeNode(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0());
682 }
683 lv_head_1_0=ruleExpression
684 {
685 if ($current==null) {
686 $current = createModelElementForParent(grammarAccess.getMetricDefinitionRule());
687 }
688 set(
689 $current,
690 "head",
691 lv_head_1_0,
692 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
693 afterParserOrEnumRuleCall();
694 }
695 )
696 )
697 otherlv_2='='
698 {
699 newLeafNode(otherlv_2, grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2());
700 }
701 (
702 (
703 {
704 newCompositeNode(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0());
705 }
706 lv_body_3_0=ruleExpression
707 {
708 if ($current==null) {
709 $current = createModelElementForParent(grammarAccess.getMetricDefinitionRule());
710 }
711 set(
712 $current,
713 "body",
714 lv_body_3_0,
715 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
716 afterParserOrEnumRuleCall();
717 }
718 )
719 )
720 )
721;
722
723// Entry rule entryRuleExternMetricDefinition
724entryRuleExternMetricDefinition returns [EObject current=null]:
725 { newCompositeNode(grammarAccess.getExternMetricDefinitionRule()); }
726 iv_ruleExternMetricDefinition=ruleExternMetricDefinition
727 { $current=$iv_ruleExternMetricDefinition.current; }
728 EOF;
729
730// Rule ExternMetricDefinition
731ruleExternMetricDefinition returns [EObject current=null]
732@init {
733 enterRule();
734}
735@after {
736 leaveRule();
737}:
738 (
739 otherlv_0='extern'
740 {
741 newLeafNode(otherlv_0, grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0());
742 }
743 (
744 (
745 {
746 newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0());
747 }
748 lv_type_1_0=ruleMetricType
749 {
750 if ($current==null) {
751 $current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule());
752 }
753 set(
754 $current,
755 "type",
756 lv_type_1_0,
757 "org.eclipse.viatra.solver.language.SolverLanguage.MetricType");
758 afterParserOrEnumRuleCall();
759 }
760 )
761 )
762 (
763 (
764 {
765 newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0());
766 }
767 lv_head_2_0=ruleCall
768 {
769 if ($current==null) {
770 $current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule());
771 }
772 set(
773 $current,
774 "head",
775 lv_head_2_0,
776 "org.eclipse.viatra.solver.language.SolverLanguage.Call");
777 afterParserOrEnumRuleCall();
778 }
779 )
780 )
781 )
782;
783
784// Entry rule entryRuleExpression
785entryRuleExpression returns [EObject current=null]:
786 { newCompositeNode(grammarAccess.getExpressionRule()); }
787 iv_ruleExpression=ruleExpression
788 { $current=$iv_ruleExpression.current; }
789 EOF;
790
791// Rule Expression
792ruleExpression returns [EObject current=null]
793@init {
794 enterRule();
795}
796@after {
797 leaveRule();
798}:
799 (
800 {
801 newCompositeNode(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0());
802 }
803 this_IfElse_0=ruleIfElse
804 {
805 $current = $this_IfElse_0.current;
806 afterParserOrEnumRuleCall();
807 }
808 |
809 {
810 newCompositeNode(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1());
811 }
812 this_DisjunctiveExpression_1=ruleDisjunctiveExpression
813 {
814 $current = $this_DisjunctiveExpression_1.current;
815 afterParserOrEnumRuleCall();
816 }
817 )
818;
819
820// Entry rule entryRuleIfElse
821entryRuleIfElse returns [EObject current=null]:
822 { newCompositeNode(grammarAccess.getIfElseRule()); }
823 iv_ruleIfElse=ruleIfElse
824 { $current=$iv_ruleIfElse.current; }
825 EOF;
826
827// Rule IfElse
828ruleIfElse returns [EObject current=null]
829@init {
830 enterRule();
831}
832@after {
833 leaveRule();
834}:
835 (
836 otherlv_0='if'
837 {
838 newLeafNode(otherlv_0, grammarAccess.getIfElseAccess().getIfKeyword_0());
839 }
840 (
841 (
842 {
843 newCompositeNode(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0());
844 }
845 lv_condition_1_0=ruleExpression
846 {
847 if ($current==null) {
848 $current = createModelElementForParent(grammarAccess.getIfElseRule());
849 }
850 set(
851 $current,
852 "condition",
853 lv_condition_1_0,
854 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
855 afterParserOrEnumRuleCall();
856 }
857 )
858 )
859 otherlv_2='then'
860 {
861 newLeafNode(otherlv_2, grammarAccess.getIfElseAccess().getThenKeyword_2());
862 }
863 (
864 (
865 {
866 newCompositeNode(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0());
867 }
868 lv_then_3_0=ruleExpression
869 {
870 if ($current==null) {
871 $current = createModelElementForParent(grammarAccess.getIfElseRule());
872 }
873 set(
874 $current,
875 "then",
876 lv_then_3_0,
877 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
878 afterParserOrEnumRuleCall();
879 }
880 )
881 )
882 otherlv_4='else'
883 {
884 newLeafNode(otherlv_4, grammarAccess.getIfElseAccess().getElseKeyword_4());
885 }
886 (
887 (
888 {
889 newCompositeNode(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0());
890 }
891 lv_else_5_0=ruleExpression
892 {
893 if ($current==null) {
894 $current = createModelElementForParent(grammarAccess.getIfElseRule());
895 }
896 set(
897 $current,
898 "else",
899 lv_else_5_0,
900 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
901 afterParserOrEnumRuleCall();
902 }
903 )
904 )
905 )
906;
907
908// Entry rule entryRuleDisjunctiveExpression
909entryRuleDisjunctiveExpression returns [EObject current=null]:
910 { newCompositeNode(grammarAccess.getDisjunctiveExpressionRule()); }
911 iv_ruleDisjunctiveExpression=ruleDisjunctiveExpression
912 { $current=$iv_ruleDisjunctiveExpression.current; }
913 EOF;
914
915// Rule DisjunctiveExpression
916ruleDisjunctiveExpression returns [EObject current=null]
917@init {
918 enterRule();
919}
920@after {
921 leaveRule();
922}:
923 (
924 {
925 newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0());
926 }
927 this_ConjunctiveExpression_0=ruleConjunctiveExpression
928 {
929 $current = $this_ConjunctiveExpression_0.current;
930 afterParserOrEnumRuleCall();
931 }
932 (
933 (
934 (
935 {
936 $current = forceCreateModelElementAndAdd(
937 grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0(),
938 $current);
939 }
940 )
941 (
942 otherlv_2=';'
943 {
944 newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0());
945 }
946 (
947 (
948 {
949 newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0());
950 }
951 lv_children_3_0=ruleConjunctiveExpression
952 {
953 if ($current==null) {
954 $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule());
955 }
956 add(
957 $current,
958 "children",
959 lv_children_3_0,
960 "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression");
961 afterParserOrEnumRuleCall();
962 }
963 )
964 )
965 )+
966 )
967 |
968 (
969 (
970 {
971 $current = forceCreateModelElementAndSet(
972 grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(),
973 $current);
974 }
975 )
976 otherlv_5='->'
977 {
978 newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1());
979 }
980 (
981 (
982 {
983 newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0());
984 }
985 lv_body_6_0=ruleConjunctiveExpression
986 {
987 if ($current==null) {
988 $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule());
989 }
990 set(
991 $current,
992 "body",
993 lv_body_6_0,
994 "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression");
995 afterParserOrEnumRuleCall();
996 }
997 )
998 )
999 (
1000 {
1001 $current = forceCreateModelElementAndAdd(
1002 grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3(),
1003 $current);
1004 }
1005 )
1006 (
1007 otherlv_8=';'
1008 {
1009 newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0());
1010 }
1011 (
1012 (
1013 {
1014 newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0());
1015 }
1016 lv_cases_9_0=ruleCase
1017 {
1018 if ($current==null) {
1019 $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule());
1020 }
1021 add(
1022 $current,
1023 "cases",
1024 lv_cases_9_0,
1025 "org.eclipse.viatra.solver.language.SolverLanguage.Case");
1026 afterParserOrEnumRuleCall();
1027 }
1028 )
1029 )
1030 )*
1031 )
1032 )?
1033 )
1034;
1035
1036// Entry rule entryRuleCase
1037entryRuleCase returns [EObject current=null]:
1038 { newCompositeNode(grammarAccess.getCaseRule()); }
1039 iv_ruleCase=ruleCase
1040 { $current=$iv_ruleCase.current; }
1041 EOF;
1042
1043// Rule Case
1044ruleCase returns [EObject current=null]
1045@init {
1046 enterRule();
1047}
1048@after {
1049 leaveRule();
1050}:
1051 (
1052 (
1053 (
1054 {
1055 newCompositeNode(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0());
1056 }
1057 lv_condition_0_0=ruleConjunctiveExpression
1058 {
1059 if ($current==null) {
1060 $current = createModelElementForParent(grammarAccess.getCaseRule());
1061 }
1062 set(
1063 $current,
1064 "condition",
1065 lv_condition_0_0,
1066 "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression");
1067 afterParserOrEnumRuleCall();
1068 }
1069 )
1070 )
1071 otherlv_1='->'
1072 {
1073 newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1());
1074 }
1075 (
1076 (
1077 {
1078 newCompositeNode(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0());
1079 }
1080 lv_body_2_0=ruleConjunctiveExpression
1081 {
1082 if ($current==null) {
1083 $current = createModelElementForParent(grammarAccess.getCaseRule());
1084 }
1085 set(
1086 $current,
1087 "body",
1088 lv_body_2_0,
1089 "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression");
1090 afterParserOrEnumRuleCall();
1091 }
1092 )
1093 )
1094 )
1095;
1096
1097// Entry rule entryRuleConjunctiveExpression
1098entryRuleConjunctiveExpression returns [EObject current=null]:
1099 { newCompositeNode(grammarAccess.getConjunctiveExpressionRule()); }
1100 iv_ruleConjunctiveExpression=ruleConjunctiveExpression
1101 { $current=$iv_ruleConjunctiveExpression.current; }
1102 EOF;
1103
1104// Rule ConjunctiveExpression
1105ruleConjunctiveExpression returns [EObject current=null]
1106@init {
1107 enterRule();
1108}
1109@after {
1110 leaveRule();
1111}:
1112 (
1113 {
1114 newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0());
1115 }
1116 this_ComparisonExpression_0=ruleComparisonExpression
1117 {
1118 $current = $this_ComparisonExpression_0.current;
1119 afterParserOrEnumRuleCall();
1120 }
1121 (
1122 (
1123 {
1124 $current = forceCreateModelElementAndAdd(
1125 grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0(),
1126 $current);
1127 }
1128 )
1129 (
1130 otherlv_2=','
1131 {
1132 newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0());
1133 }
1134 (
1135 (
1136 {
1137 newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0());
1138 }
1139 lv_children_3_0=ruleComparisonExpression
1140 {
1141 if ($current==null) {
1142 $current = createModelElementForParent(grammarAccess.getConjunctiveExpressionRule());
1143 }
1144 add(
1145 $current,
1146 "children",
1147 lv_children_3_0,
1148 "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression");
1149 afterParserOrEnumRuleCall();
1150 }
1151 )
1152 )
1153 )+
1154 )?
1155 )
1156;
1157
1158// Entry rule entryRuleComparisonExpression
1159entryRuleComparisonExpression returns [EObject current=null]:
1160 { newCompositeNode(grammarAccess.getComparisonExpressionRule()); }
1161 iv_ruleComparisonExpression=ruleComparisonExpression
1162 { $current=$iv_ruleComparisonExpression.current; }
1163 EOF;
1164
1165// Rule ComparisonExpression
1166ruleComparisonExpression returns [EObject current=null]
1167@init {
1168 enterRule();
1169}
1170@after {
1171 leaveRule();
1172}:
1173 (
1174 {
1175 newCompositeNode(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0());
1176 }
1177 this_AdditiveExpression_0=ruleAdditiveExpression
1178 {
1179 $current = $this_AdditiveExpression_0.current;
1180 afterParserOrEnumRuleCall();
1181 }
1182 (
1183 (
1184 {
1185 $current = forceCreateModelElementAndSet(
1186 grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(),
1187 $current);
1188 }
1189 )
1190 (
1191 (
1192 {
1193 newCompositeNode(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0());
1194 }
1195 lv_op_2_0=ruleComparisonOperator
1196 {
1197 if ($current==null) {
1198 $current = createModelElementForParent(grammarAccess.getComparisonExpressionRule());
1199 }
1200 set(
1201 $current,
1202 "op",
1203 lv_op_2_0,
1204 "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator");
1205 afterParserOrEnumRuleCall();
1206 }
1207 )
1208 )
1209 (
1210 (
1211 {
1212 newCompositeNode(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0());
1213 }
1214 lv_right_3_0=ruleAdditiveExpression
1215 {
1216 if ($current==null) {
1217 $current = createModelElementForParent(grammarAccess.getComparisonExpressionRule());
1218 }
1219 set(
1220 $current,
1221 "right",
1222 lv_right_3_0,
1223 "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression");
1224 afterParserOrEnumRuleCall();
1225 }
1226 )
1227 )
1228 )?
1229 )
1230;
1231
1232// Entry rule entryRuleAdditiveExpression
1233entryRuleAdditiveExpression returns [EObject current=null]:
1234 { newCompositeNode(grammarAccess.getAdditiveExpressionRule()); }
1235 iv_ruleAdditiveExpression=ruleAdditiveExpression
1236 { $current=$iv_ruleAdditiveExpression.current; }
1237 EOF;
1238
1239// Rule AdditiveExpression
1240ruleAdditiveExpression returns [EObject current=null]
1241@init {
1242 enterRule();
1243}
1244@after {
1245 leaveRule();
1246}:
1247 (
1248 {
1249 newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0());
1250 }
1251 this_MultiplicativeExpression_0=ruleMultiplicativeExpression
1252 {
1253 $current = $this_MultiplicativeExpression_0.current;
1254 afterParserOrEnumRuleCall();
1255 }
1256 (
1257 (
1258 {
1259 $current = forceCreateModelElementAndSet(
1260 grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(),
1261 $current);
1262 }
1263 )
1264 (
1265 (
1266 {
1267 newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0());
1268 }
1269 lv_op_2_0=ruleAdditiveBinaryOperator
1270 {
1271 if ($current==null) {
1272 $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule());
1273 }
1274 set(
1275 $current,
1276 "op",
1277 lv_op_2_0,
1278 "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator");
1279 afterParserOrEnumRuleCall();
1280 }
1281 )
1282 )
1283 (
1284 (
1285 {
1286 newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0());
1287 }
1288 lv_right_3_0=ruleMultiplicativeExpression
1289 {
1290 if ($current==null) {
1291 $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule());
1292 }
1293 set(
1294 $current,
1295 "right",
1296 lv_right_3_0,
1297 "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression");
1298 afterParserOrEnumRuleCall();
1299 }
1300 )
1301 )
1302 )*
1303 )
1304;
1305
1306// Entry rule entryRuleMultiplicativeExpression
1307entryRuleMultiplicativeExpression returns [EObject current=null]:
1308 { newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); }
1309 iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression
1310 { $current=$iv_ruleMultiplicativeExpression.current; }
1311 EOF;
1312
1313// Rule MultiplicativeExpression
1314ruleMultiplicativeExpression returns [EObject current=null]
1315@init {
1316 enterRule();
1317}
1318@after {
1319 leaveRule();
1320}:
1321 (
1322 {
1323 newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0());
1324 }
1325 this_ExponentialExpression_0=ruleExponentialExpression
1326 {
1327 $current = $this_ExponentialExpression_0.current;
1328 afterParserOrEnumRuleCall();
1329 }
1330 (
1331 (
1332 {
1333 $current = forceCreateModelElementAndSet(
1334 grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(),
1335 $current);
1336 }
1337 )
1338 (
1339 (
1340 {
1341 newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0());
1342 }
1343 lv_op_2_0=ruleMultiplicativeBinaryOperator
1344 {
1345 if ($current==null) {
1346 $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule());
1347 }
1348 set(
1349 $current,
1350 "op",
1351 lv_op_2_0,
1352 "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator");
1353 afterParserOrEnumRuleCall();
1354 }
1355 )
1356 )
1357 (
1358 (
1359 {
1360 newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0());
1361 }
1362 lv_right_3_0=ruleExponentialExpression
1363 {
1364 if ($current==null) {
1365 $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule());
1366 }
1367 set(
1368 $current,
1369 "right",
1370 lv_right_3_0,
1371 "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression");
1372 afterParserOrEnumRuleCall();
1373 }
1374 )
1375 )
1376 )*
1377 )
1378;
1379
1380// Entry rule entryRuleExponentialExpression
1381entryRuleExponentialExpression returns [EObject current=null]:
1382 { newCompositeNode(grammarAccess.getExponentialExpressionRule()); }
1383 iv_ruleExponentialExpression=ruleExponentialExpression
1384 { $current=$iv_ruleExponentialExpression.current; }
1385 EOF;
1386
1387// Rule ExponentialExpression
1388ruleExponentialExpression returns [EObject current=null]
1389@init {
1390 enterRule();
1391}
1392@after {
1393 leaveRule();
1394}:
1395 (
1396 {
1397 newCompositeNode(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0());
1398 }
1399 this_UnaryExpression_0=ruleUnaryExpression
1400 {
1401 $current = $this_UnaryExpression_0.current;
1402 afterParserOrEnumRuleCall();
1403 }
1404 (
1405 (
1406 {
1407 $current = forceCreateModelElementAndSet(
1408 grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0(),
1409 $current);
1410 }
1411 )
1412 (
1413 (
1414 {
1415 newCompositeNode(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0());
1416 }
1417 lv_op_2_0=ruleExponentialOp
1418 {
1419 if ($current==null) {
1420 $current = createModelElementForParent(grammarAccess.getExponentialExpressionRule());
1421 }
1422 set(
1423 $current,
1424 "op",
1425 lv_op_2_0,
1426 "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp");
1427 afterParserOrEnumRuleCall();
1428 }
1429 )
1430 )
1431 (
1432 (
1433 {
1434 newCompositeNode(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0());
1435 }
1436 lv_right_3_0=ruleExponentialExpression
1437 {
1438 if ($current==null) {
1439 $current = createModelElementForParent(grammarAccess.getExponentialExpressionRule());
1440 }
1441 set(
1442 $current,
1443 "right",
1444 lv_right_3_0,
1445 "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression");
1446 afterParserOrEnumRuleCall();
1447 }
1448 )
1449 )
1450 )?
1451 )
1452;
1453
1454// Entry rule entryRuleUnaryExpression
1455entryRuleUnaryExpression returns [EObject current=null]:
1456 { newCompositeNode(grammarAccess.getUnaryExpressionRule()); }
1457 iv_ruleUnaryExpression=ruleUnaryExpression
1458 { $current=$iv_ruleUnaryExpression.current; }
1459 EOF;
1460
1461// Rule UnaryExpression
1462ruleUnaryExpression returns [EObject current=null]
1463@init {
1464 enterRule();
1465}
1466@after {
1467 leaveRule();
1468}:
1469 (
1470 {
1471 newCompositeNode(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0());
1472 }
1473 this_AggregationExpression_0=ruleAggregationExpression
1474 {
1475 $current = $this_AggregationExpression_0.current;
1476 afterParserOrEnumRuleCall();
1477 }
1478 |
1479 (
1480 (
1481 {
1482 $current = forceCreateModelElement(
1483 grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0(),
1484 $current);
1485 }
1486 )
1487 (
1488 (
1489 {
1490 newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0());
1491 }
1492 lv_op_2_0=ruleUnaryOp
1493 {
1494 if ($current==null) {
1495 $current = createModelElementForParent(grammarAccess.getUnaryExpressionRule());
1496 }
1497 set(
1498 $current,
1499 "op",
1500 lv_op_2_0,
1501 "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOp");
1502 afterParserOrEnumRuleCall();
1503 }
1504 )
1505 )
1506 (
1507 (
1508 {
1509 newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0());
1510 }
1511 lv_body_3_0=ruleAggregationExpression
1512 {
1513 if ($current==null) {
1514 $current = createModelElementForParent(grammarAccess.getUnaryExpressionRule());
1515 }
1516 set(
1517 $current,
1518 "body",
1519 lv_body_3_0,
1520 "org.eclipse.viatra.solver.language.SolverLanguage.AggregationExpression");
1521 afterParserOrEnumRuleCall();
1522 }
1523 )
1524 )
1525 )
1526 )
1527;
1528
1529// Entry rule entryRuleAggregationExpression
1530entryRuleAggregationExpression returns [EObject current=null]:
1531 { newCompositeNode(grammarAccess.getAggregationExpressionRule()); }
1532 iv_ruleAggregationExpression=ruleAggregationExpression
1533 { $current=$iv_ruleAggregationExpression.current; }
1534 EOF;
1535
1536// Rule AggregationExpression
1537ruleAggregationExpression returns [EObject current=null]
1538@init {
1539 enterRule();
1540}
1541@after {
1542 leaveRule();
1543}:
1544 (
1545 {
1546 newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0());
1547 }
1548 this_AtomicExpression_0=ruleAtomicExpression
1549 {
1550 $current = $this_AtomicExpression_0.current;
1551 afterParserOrEnumRuleCall();
1552 }
1553 |
1554 {
1555 newCompositeNode(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1());
1556 }
1557 this_Count_1=ruleCount
1558 {
1559 $current = $this_Count_1.current;
1560 afterParserOrEnumRuleCall();
1561 }
1562 |
1563 {
1564 newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2());
1565 }
1566 this_Aggregation_2=ruleAggregation
1567 {
1568 $current = $this_Aggregation_2.current;
1569 afterParserOrEnumRuleCall();
1570 }
1571 )
1572;
1573
1574// Entry rule entryRuleCount
1575entryRuleCount returns [EObject current=null]:
1576 { newCompositeNode(grammarAccess.getCountRule()); }
1577 iv_ruleCount=ruleCount
1578 { $current=$iv_ruleCount.current; }
1579 EOF;
1580
1581// Rule Count
1582ruleCount returns [EObject current=null]
1583@init {
1584 enterRule();
1585}
1586@after {
1587 leaveRule();
1588}:
1589 (
1590 otherlv_0='count'
1591 {
1592 newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0());
1593 }
1594 otherlv_1='{'
1595 {
1596 newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1());
1597 }
1598 (
1599 (
1600 {
1601 newCompositeNode(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0());
1602 }
1603 lv_body_2_0=ruleExpression
1604 {
1605 if ($current==null) {
1606 $current = createModelElementForParent(grammarAccess.getCountRule());
1607 }
1608 set(
1609 $current,
1610 "body",
1611 lv_body_2_0,
1612 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
1613 afterParserOrEnumRuleCall();
1614 }
1615 )
1616 )
1617 otherlv_3='}'
1618 {
1619 newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3());
1620 }
1621 )
1622;
1623
1624// Entry rule entryRuleAggregation
1625entryRuleAggregation returns [EObject current=null]:
1626 { newCompositeNode(grammarAccess.getAggregationRule()); }
1627 iv_ruleAggregation=ruleAggregation
1628 { $current=$iv_ruleAggregation.current; }
1629 EOF;
1630
1631// Rule Aggregation
1632ruleAggregation returns [EObject current=null]
1633@init {
1634 enterRule();
1635}
1636@after {
1637 leaveRule();
1638}:
1639 (
1640 (
1641 (
1642 {
1643 newCompositeNode(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0());
1644 }
1645 lv_op_0_0=ruleAggregationOp
1646 {
1647 if ($current==null) {
1648 $current = createModelElementForParent(grammarAccess.getAggregationRule());
1649 }
1650 set(
1651 $current,
1652 "op",
1653 lv_op_0_0,
1654 "org.eclipse.viatra.solver.language.SolverLanguage.AggregationOp");
1655 afterParserOrEnumRuleCall();
1656 }
1657 )
1658 )
1659 otherlv_1='{'
1660 {
1661 newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1());
1662 }
1663 (
1664 (
1665 {
1666 newCompositeNode(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0());
1667 }
1668 lv_body_2_0=ruleExpression
1669 {
1670 if ($current==null) {
1671 $current = createModelElementForParent(grammarAccess.getAggregationRule());
1672 }
1673 set(
1674 $current,
1675 "body",
1676 lv_body_2_0,
1677 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
1678 afterParserOrEnumRuleCall();
1679 }
1680 )
1681 )
1682 otherlv_3='|'
1683 {
1684 newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3());
1685 }
1686 (
1687 (
1688 {
1689 newCompositeNode(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0());
1690 }
1691 lv_condition_4_0=ruleExpression
1692 {
1693 if ($current==null) {
1694 $current = createModelElementForParent(grammarAccess.getAggregationRule());
1695 }
1696 set(
1697 $current,
1698 "condition",
1699 lv_condition_4_0,
1700 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
1701 afterParserOrEnumRuleCall();
1702 }
1703 )
1704 )
1705 otherlv_5='}'
1706 {
1707 newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5());
1708 }
1709 )
1710;
1711
1712// Entry rule entryRuleAtomicExpression
1713entryRuleAtomicExpression returns [EObject current=null]:
1714 { newCompositeNode(grammarAccess.getAtomicExpressionRule()); }
1715 iv_ruleAtomicExpression=ruleAtomicExpression
1716 { $current=$iv_ruleAtomicExpression.current; }
1717 EOF;
1718
1719// Rule AtomicExpression
1720ruleAtomicExpression returns [EObject current=null]
1721@init {
1722 enterRule();
1723}
1724@after {
1725 leaveRule();
1726}:
1727 (
1728 (
1729 {
1730 newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0());
1731 }
1732 this_Reference_0=ruleReference
1733 {
1734 $current = $this_Reference_0.current;
1735 afterParserOrEnumRuleCall();
1736 }
1737 (
1738 (
1739 {
1740 $current = forceCreateModelElementAndSet(
1741 grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0(),
1742 $current);
1743 }
1744 )
1745 (
1746 ('(')=>
1747 (
1748 {
1749 newCompositeNode(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0());
1750 }
1751 lv_argumentList_2_0=ruleArgumentList
1752 {
1753 if ($current==null) {
1754 $current = createModelElementForParent(grammarAccess.getAtomicExpressionRule());
1755 }
1756 set(
1757 $current,
1758 "argumentList",
1759 lv_argumentList_2_0,
1760 "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList");
1761 afterParserOrEnumRuleCall();
1762 }
1763 )
1764 )
1765 )?
1766 )
1767 |
1768 {
1769 newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1());
1770 }
1771 this_Interval_3=ruleInterval
1772 {
1773 $current = $this_Interval_3.current;
1774 afterParserOrEnumRuleCall();
1775 }
1776 |
1777 {
1778 newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2());
1779 }
1780 this_Literal_4=ruleLiteral
1781 {
1782 $current = $this_Literal_4.current;
1783 afterParserOrEnumRuleCall();
1784 }
1785 |
1786 (
1787 otherlv_5='('
1788 {
1789 newLeafNode(otherlv_5, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0());
1790 }
1791 {
1792 newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1());
1793 }
1794 this_Expression_6=ruleExpression
1795 {
1796 $current = $this_Expression_6.current;
1797 afterParserOrEnumRuleCall();
1798 }
1799 otherlv_7=')'
1800 {
1801 newLeafNode(otherlv_7, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2());
1802 }
1803 )
1804 )
1805;
1806
1807// Entry rule entryRuleCall
1808entryRuleCall returns [EObject current=null]:
1809 { newCompositeNode(grammarAccess.getCallRule()); }
1810 iv_ruleCall=ruleCall
1811 { $current=$iv_ruleCall.current; }
1812 EOF;
1813
1814// Rule Call
1815ruleCall returns [EObject current=null]
1816@init {
1817 enterRule();
1818}
1819@after {
1820 leaveRule();
1821}:
1822 (
1823 (
1824 (
1825 {
1826 newCompositeNode(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0());
1827 }
1828 lv_functor_0_0=ruleReference
1829 {
1830 if ($current==null) {
1831 $current = createModelElementForParent(grammarAccess.getCallRule());
1832 }
1833 set(
1834 $current,
1835 "functor",
1836 lv_functor_0_0,
1837 "org.eclipse.viatra.solver.language.SolverLanguage.Reference");
1838 afterParserOrEnumRuleCall();
1839 }
1840 )
1841 )
1842 (
1843 (
1844 (
1845 lv_transitiveClosure_1_0=RULE_STAR
1846 {
1847 newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0());
1848 }
1849 {
1850 if ($current==null) {
1851 $current = createModelElement(grammarAccess.getCallRule());
1852 }
1853 setWithLastConsumed(
1854 $current,
1855 "transitiveClosure",
1856 true,
1857 "org.eclipse.viatra.solver.language.SolverLanguage.STAR");
1858 }
1859 )
1860 )
1861 |
1862 (
1863 (
1864 lv_reflexiveTransitiveClosure_2_0=RULE_PLUS
1865 {
1866 newLeafNode(lv_reflexiveTransitiveClosure_2_0, grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0());
1867 }
1868 {
1869 if ($current==null) {
1870 $current = createModelElement(grammarAccess.getCallRule());
1871 }
1872 setWithLastConsumed(
1873 $current,
1874 "reflexiveTransitiveClosure",
1875 true,
1876 "org.eclipse.viatra.solver.language.SolverLanguage.PLUS");
1877 }
1878 )
1879 )
1880 )?
1881 (
1882 (
1883 {
1884 newCompositeNode(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0());
1885 }
1886 lv_argumentList_3_0=ruleArgumentList
1887 {
1888 if ($current==null) {
1889 $current = createModelElementForParent(grammarAccess.getCallRule());
1890 }
1891 set(
1892 $current,
1893 "argumentList",
1894 lv_argumentList_3_0,
1895 "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList");
1896 afterParserOrEnumRuleCall();
1897 }
1898 )
1899 )
1900 )
1901;
1902
1903// Entry rule entryRuleArgumentList
1904entryRuleArgumentList returns [EObject current=null]:
1905 { newCompositeNode(grammarAccess.getArgumentListRule()); }
1906 iv_ruleArgumentList=ruleArgumentList
1907 { $current=$iv_ruleArgumentList.current; }
1908 EOF;
1909
1910// Rule ArgumentList
1911ruleArgumentList returns [EObject current=null]
1912@init {
1913 enterRule();
1914}
1915@after {
1916 leaveRule();
1917}:
1918 (
1919 (
1920 {
1921 $current = forceCreateModelElement(
1922 grammarAccess.getArgumentListAccess().getArgumentListAction_0(),
1923 $current);
1924 }
1925 )
1926 otherlv_1='('
1927 {
1928 newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1());
1929 }
1930 (
1931 (
1932 (
1933 {
1934 newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0());
1935 }
1936 lv_arguments_2_0=ruleArgument
1937 {
1938 if ($current==null) {
1939 $current = createModelElementForParent(grammarAccess.getArgumentListRule());
1940 }
1941 add(
1942 $current,
1943 "arguments",
1944 lv_arguments_2_0,
1945 "org.eclipse.viatra.solver.language.SolverLanguage.Argument");
1946 afterParserOrEnumRuleCall();
1947 }
1948 )
1949 )
1950 (
1951 otherlv_3=','
1952 {
1953 newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0());
1954 }
1955 (
1956 (
1957 {
1958 newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0());
1959 }
1960 lv_arguments_4_0=ruleArgument
1961 {
1962 if ($current==null) {
1963 $current = createModelElementForParent(grammarAccess.getArgumentListRule());
1964 }
1965 add(
1966 $current,
1967 "arguments",
1968 lv_arguments_4_0,
1969 "org.eclipse.viatra.solver.language.SolverLanguage.Argument");
1970 afterParserOrEnumRuleCall();
1971 }
1972 )
1973 )
1974 )*
1975 )?
1976 otherlv_5=')'
1977 {
1978 newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3());
1979 }
1980 )
1981;
1982
1983// Entry rule entryRuleArgument
1984entryRuleArgument returns [EObject current=null]:
1985 { newCompositeNode(grammarAccess.getArgumentRule()); }
1986 iv_ruleArgument=ruleArgument
1987 { $current=$iv_ruleArgument.current; }
1988 EOF;
1989
1990// Rule Argument
1991ruleArgument returns [EObject current=null]
1992@init {
1993 enterRule();
1994}
1995@after {
1996 leaveRule();
1997}:
1998 (
1999 {
2000 newCompositeNode(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0());
2001 }
2002 this_ExpressionArgument_0=ruleExpressionArgument
2003 {
2004 $current = $this_ExpressionArgument_0.current;
2005 afterParserOrEnumRuleCall();
2006 }
2007 |
2008 {
2009 newCompositeNode(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1());
2010 }
2011 this_StarArgument_1=ruleStarArgument
2012 {
2013 $current = $this_StarArgument_1.current;
2014 afterParserOrEnumRuleCall();
2015 }
2016 |
2017 {
2018 newCompositeNode(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2());
2019 }
2020 this_TypedArgument_2=ruleTypedArgument
2021 {
2022 $current = $this_TypedArgument_2.current;
2023 afterParserOrEnumRuleCall();
2024 }
2025 |
2026 {
2027 newCompositeNode(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3());
2028 }
2029 this_TypedStarArgument_3=ruleTypedStarArgument
2030 {
2031 $current = $this_TypedStarArgument_3.current;
2032 afterParserOrEnumRuleCall();
2033 }
2034 )
2035;
2036
2037// Entry rule entryRuleExpressionArgument
2038entryRuleExpressionArgument returns [EObject current=null]:
2039 { newCompositeNode(grammarAccess.getExpressionArgumentRule()); }
2040 iv_ruleExpressionArgument=ruleExpressionArgument
2041 { $current=$iv_ruleExpressionArgument.current; }
2042 EOF;
2043
2044// Rule ExpressionArgument
2045ruleExpressionArgument returns [EObject current=null]
2046@init {
2047 enterRule();
2048}
2049@after {
2050 leaveRule();
2051}:
2052 (
2053 (
2054 {
2055 newCompositeNode(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0());
2056 }
2057 lv_body_0_0=ruleComparisonExpression
2058 {
2059 if ($current==null) {
2060 $current = createModelElementForParent(grammarAccess.getExpressionArgumentRule());
2061 }
2062 set(
2063 $current,
2064 "body",
2065 lv_body_0_0,
2066 "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression");
2067 afterParserOrEnumRuleCall();
2068 }
2069 )
2070 )
2071;
2072
2073// Entry rule entryRuleStarArgument
2074entryRuleStarArgument returns [EObject current=null]:
2075 { newCompositeNode(grammarAccess.getStarArgumentRule()); }
2076 iv_ruleStarArgument=ruleStarArgument
2077 { $current=$iv_ruleStarArgument.current; }
2078 EOF;
2079
2080// Rule StarArgument
2081ruleStarArgument returns [EObject current=null]
2082@init {
2083 enterRule();
2084}
2085@after {
2086 leaveRule();
2087}:
2088 (
2089 (
2090 {
2091 $current = forceCreateModelElement(
2092 grammarAccess.getStarArgumentAccess().getStarArgumentAction_0(),
2093 $current);
2094 }
2095 )
2096 otherlv_1='*'
2097 {
2098 newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1());
2099 }
2100 )
2101;
2102
2103// Entry rule entryRuleTypedArgument
2104entryRuleTypedArgument returns [EObject current=null]:
2105 { newCompositeNode(grammarAccess.getTypedArgumentRule()); }
2106 iv_ruleTypedArgument=ruleTypedArgument
2107 { $current=$iv_ruleTypedArgument.current; }
2108 EOF;
2109
2110// Rule TypedArgument
2111ruleTypedArgument returns [EObject current=null]
2112@init {
2113 enterRule();
2114}
2115@after {
2116 leaveRule();
2117}:
2118 (
2119 (
2120 (
2121 {
2122 if ($current==null) {
2123 $current = createModelElement(grammarAccess.getTypedArgumentRule());
2124 }
2125 }
2126 {
2127 newCompositeNode(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0());
2128 }
2129 ruleQualifiedName
2130 {
2131 afterParserOrEnumRuleCall();
2132 }
2133 )
2134 )
2135 (
2136 (
2137 {
2138 if ($current==null) {
2139 $current = createModelElement(grammarAccess.getTypedArgumentRule());
2140 }
2141 }
2142 {
2143 newCompositeNode(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0());
2144 }
2145 ruleQualifiedName
2146 {
2147 afterParserOrEnumRuleCall();
2148 }
2149 )
2150 )
2151 )
2152;
2153
2154// Entry rule entryRuleTypedStarArgument
2155entryRuleTypedStarArgument returns [EObject current=null]:
2156 { newCompositeNode(grammarAccess.getTypedStarArgumentRule()); }
2157 iv_ruleTypedStarArgument=ruleTypedStarArgument
2158 { $current=$iv_ruleTypedStarArgument.current; }
2159 EOF;
2160
2161// Rule TypedStarArgument
2162ruleTypedStarArgument returns [EObject current=null]
2163@init {
2164 enterRule();
2165}
2166@after {
2167 leaveRule();
2168}:
2169 (
2170 (
2171 (
2172 {
2173 if ($current==null) {
2174 $current = createModelElement(grammarAccess.getTypedStarArgumentRule());
2175 }
2176 }
2177 {
2178 newCompositeNode(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0());
2179 }
2180 ruleQualifiedName
2181 {
2182 afterParserOrEnumRuleCall();
2183 }
2184 )
2185 )
2186 otherlv_1='*'
2187 {
2188 newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1());
2189 }
2190 )
2191;
2192
2193// Entry rule entryRuleReference
2194entryRuleReference returns [EObject current=null]:
2195 { newCompositeNode(grammarAccess.getReferenceRule()); }
2196 iv_ruleReference=ruleReference
2197 { $current=$iv_ruleReference.current; }
2198 EOF;
2199
2200// Rule Reference
2201ruleReference returns [EObject current=null]
2202@init {
2203 enterRule();
2204}
2205@after {
2206 leaveRule();
2207}:
2208 (
2209 (
2210 {
2211 if ($current==null) {
2212 $current = createModelElement(grammarAccess.getReferenceRule());
2213 }
2214 }
2215 {
2216 newCompositeNode(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0());
2217 }
2218 ruleQualifiedName
2219 {
2220 afterParserOrEnumRuleCall();
2221 }
2222 )
2223 )
2224;
2225
2226// Entry rule entryRuleInterval
2227entryRuleInterval returns [EObject current=null]:
2228 { newCompositeNode(grammarAccess.getIntervalRule()); }
2229 iv_ruleInterval=ruleInterval
2230 { $current=$iv_ruleInterval.current; }
2231 EOF;
2232
2233// Rule Interval
2234ruleInterval returns [EObject current=null]
2235@init {
2236 enterRule();
2237}
2238@after {
2239 leaveRule();
2240}:
2241 (
2242 otherlv_0='['
2243 {
2244 newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0());
2245 }
2246 (
2247 (
2248 {
2249 newCompositeNode(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0());
2250 }
2251 lv_lowerBound_1_0=ruleExpression
2252 {
2253 if ($current==null) {
2254 $current = createModelElementForParent(grammarAccess.getIntervalRule());
2255 }
2256 set(
2257 $current,
2258 "lowerBound",
2259 lv_lowerBound_1_0,
2260 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
2261 afterParserOrEnumRuleCall();
2262 }
2263 )
2264 )
2265 otherlv_2='..'
2266 {
2267 newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2());
2268 }
2269 (
2270 (
2271 {
2272 newCompositeNode(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0());
2273 }
2274 lv_upperBound_3_0=ruleExpression
2275 {
2276 if ($current==null) {
2277 $current = createModelElementForParent(grammarAccess.getIntervalRule());
2278 }
2279 set(
2280 $current,
2281 "upperBound",
2282 lv_upperBound_3_0,
2283 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
2284 afterParserOrEnumRuleCall();
2285 }
2286 )
2287 )
2288 otherlv_4=']'
2289 {
2290 newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4());
2291 }
2292 )
2293;
2294
2295// Entry rule entryRuleLiteral
2296entryRuleLiteral returns [EObject current=null]:
2297 { newCompositeNode(grammarAccess.getLiteralRule()); }
2298 iv_ruleLiteral=ruleLiteral
2299 { $current=$iv_ruleLiteral.current; }
2300 EOF;
2301
2302// Rule Literal
2303ruleLiteral returns [EObject current=null]
2304@init {
2305 enterRule();
2306}
2307@after {
2308 leaveRule();
2309}:
2310 (
2311 {
2312 newCompositeNode(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0());
2313 }
2314 this_LogicLiteral_0=ruleLogicLiteral
2315 {
2316 $current = $this_LogicLiteral_0.current;
2317 afterParserOrEnumRuleCall();
2318 }
2319 |
2320 {
2321 newCompositeNode(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1());
2322 }
2323 this_NumericLiteral_1=ruleNumericLiteral
2324 {
2325 $current = $this_NumericLiteral_1.current;
2326 afterParserOrEnumRuleCall();
2327 }
2328 |
2329 {
2330 newCompositeNode(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2());
2331 }
2332 this_InfinityLiteral_2=ruleInfinityLiteral
2333 {
2334 $current = $this_InfinityLiteral_2.current;
2335 afterParserOrEnumRuleCall();
2336 }
2337 |
2338 {
2339 newCompositeNode(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3());
2340 }
2341 this_EmptyIntervalLiteral_3=ruleEmptyIntervalLiteral
2342 {
2343 $current = $this_EmptyIntervalLiteral_3.current;
2344 afterParserOrEnumRuleCall();
2345 }
2346 |
2347 {
2348 newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4());
2349 }
2350 this_StringLiteral_4=ruleStringLiteral
2351 {
2352 $current = $this_StringLiteral_4.current;
2353 afterParserOrEnumRuleCall();
2354 }
2355 )
2356;
2357
2358// Entry rule entryRuleLogicLiteral
2359entryRuleLogicLiteral returns [EObject current=null]:
2360 { newCompositeNode(grammarAccess.getLogicLiteralRule()); }
2361 iv_ruleLogicLiteral=ruleLogicLiteral
2362 { $current=$iv_ruleLogicLiteral.current; }
2363 EOF;
2364
2365// Rule LogicLiteral
2366ruleLogicLiteral returns [EObject current=null]
2367@init {
2368 enterRule();
2369}
2370@after {
2371 leaveRule();
2372}:
2373 (
2374 (
2375 {
2376 newCompositeNode(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0());
2377 }
2378 lv_value_0_0=ruleLogicValue
2379 {
2380 if ($current==null) {
2381 $current = createModelElementForParent(grammarAccess.getLogicLiteralRule());
2382 }
2383 set(
2384 $current,
2385 "value",
2386 lv_value_0_0,
2387 "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue");
2388 afterParserOrEnumRuleCall();
2389 }
2390 )
2391 )
2392;
2393
2394// Entry rule entryRuleNumericLiteral
2395entryRuleNumericLiteral returns [EObject current=null]:
2396 { newCompositeNode(grammarAccess.getNumericLiteralRule()); }
2397 iv_ruleNumericLiteral=ruleNumericLiteral
2398 { $current=$iv_ruleNumericLiteral.current; }
2399 EOF;
2400
2401// Rule NumericLiteral
2402ruleNumericLiteral returns [EObject current=null]
2403@init {
2404 enterRule();
2405}
2406@after {
2407 leaveRule();
2408}:
2409 (
2410 (
2411 {
2412 newCompositeNode(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0());
2413 }
2414 lv_value_0_0=ruleReal
2415 {
2416 if ($current==null) {
2417 $current = createModelElementForParent(grammarAccess.getNumericLiteralRule());
2418 }
2419 set(
2420 $current,
2421 "value",
2422 lv_value_0_0,
2423 "org.eclipse.viatra.solver.language.SolverLanguage.Real");
2424 afterParserOrEnumRuleCall();
2425 }
2426 )
2427 )
2428;
2429
2430// Entry rule entryRuleInfinityLiteral
2431entryRuleInfinityLiteral returns [EObject current=null]:
2432 { newCompositeNode(grammarAccess.getInfinityLiteralRule()); }
2433 iv_ruleInfinityLiteral=ruleInfinityLiteral
2434 { $current=$iv_ruleInfinityLiteral.current; }
2435 EOF;
2436
2437// Rule InfinityLiteral
2438ruleInfinityLiteral returns [EObject current=null]
2439@init {
2440 enterRule();
2441}
2442@after {
2443 leaveRule();
2444}:
2445 (
2446 (
2447 {
2448 $current = forceCreateModelElement(
2449 grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0(),
2450 $current);
2451 }
2452 )
2453 otherlv_1='inf'
2454 {
2455 newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1());
2456 }
2457 )
2458;
2459
2460// Entry rule entryRuleEmptyIntervalLiteral
2461entryRuleEmptyIntervalLiteral returns [EObject current=null]:
2462 { newCompositeNode(grammarAccess.getEmptyIntervalLiteralRule()); }
2463 iv_ruleEmptyIntervalLiteral=ruleEmptyIntervalLiteral
2464 { $current=$iv_ruleEmptyIntervalLiteral.current; }
2465 EOF;
2466
2467// Rule EmptyIntervalLiteral
2468ruleEmptyIntervalLiteral returns [EObject current=null]
2469@init {
2470 enterRule();
2471}
2472@after {
2473 leaveRule();
2474}:
2475 (
2476 (
2477 {
2478 $current = forceCreateModelElement(
2479 grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0(),
2480 $current);
2481 }
2482 )
2483 otherlv_1='empty'
2484 {
2485 newLeafNode(otherlv_1, grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1());
2486 }
2487 )
2488;
2489
2490// Entry rule entryRuleStringLiteral
2491entryRuleStringLiteral returns [EObject current=null]:
2492 { newCompositeNode(grammarAccess.getStringLiteralRule()); }
2493 iv_ruleStringLiteral=ruleStringLiteral
2494 { $current=$iv_ruleStringLiteral.current; }
2495 EOF;
2496
2497// Rule StringLiteral
2498ruleStringLiteral returns [EObject current=null]
2499@init {
2500 enterRule();
2501}
2502@after {
2503 leaveRule();
2504}:
2505 (
2506 (
2507 lv_value_0_0=RULE_STRING
2508 {
2509 newLeafNode(lv_value_0_0, grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0());
2510 }
2511 {
2512 if ($current==null) {
2513 $current = createModelElement(grammarAccess.getStringLiteralRule());
2514 }
2515 setWithLastConsumed(
2516 $current,
2517 "value",
2518 lv_value_0_0,
2519 "org.eclipse.viatra.solver.language.SolverLanguage.STRING");
2520 }
2521 )
2522 )
2523;
2524
2525// Entry rule entryRuleClassDefinition
2526entryRuleClassDefinition returns [EObject current=null]:
2527 { newCompositeNode(grammarAccess.getClassDefinitionRule()); }
2528 iv_ruleClassDefinition=ruleClassDefinition
2529 { $current=$iv_ruleClassDefinition.current; }
2530 EOF;
2531
2532// Rule ClassDefinition
2533ruleClassDefinition returns [EObject current=null]
2534@init {
2535 enterRule();
2536}
2537@after {
2538 leaveRule();
2539}:
2540 (
2541 (
2542 (
2543 lv_abstract_0_0='abstract'
2544 {
2545 newLeafNode(lv_abstract_0_0, grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0());
2546 }
2547 {
2548 if ($current==null) {
2549 $current = createModelElement(grammarAccess.getClassDefinitionRule());
2550 }
2551 setWithLastConsumed($current, "abstract", true, "abstract");
2552 }
2553 )
2554 )?
2555 otherlv_1='class'
2556 {
2557 newLeafNode(otherlv_1, grammarAccess.getClassDefinitionAccess().getClassKeyword_1());
2558 }
2559 (
2560 (
2561 lv_name_2_0=RULE_ID
2562 {
2563 newLeafNode(lv_name_2_0, grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0());
2564 }
2565 {
2566 if ($current==null) {
2567 $current = createModelElement(grammarAccess.getClassDefinitionRule());
2568 }
2569 setWithLastConsumed(
2570 $current,
2571 "name",
2572 lv_name_2_0,
2573 "org.eclipse.xtext.common.Terminals.ID");
2574 }
2575 )
2576 )
2577 (
2578 otherlv_3='extends'
2579 {
2580 newLeafNode(otherlv_3, grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0());
2581 }
2582 (
2583 (
2584 {
2585 if ($current==null) {
2586 $current = createModelElement(grammarAccess.getClassDefinitionRule());
2587 }
2588 }
2589 {
2590 newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0());
2591 }
2592 ruleQualifiedName
2593 {
2594 afterParserOrEnumRuleCall();
2595 }
2596 )
2597 )
2598 (
2599 otherlv_5=','
2600 {
2601 newLeafNode(otherlv_5, grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0());
2602 }
2603 (
2604 (
2605 {
2606 if ($current==null) {
2607 $current = createModelElement(grammarAccess.getClassDefinitionRule());
2608 }
2609 }
2610 {
2611 newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0());
2612 }
2613 ruleQualifiedName
2614 {
2615 afterParserOrEnumRuleCall();
2616 }
2617 )
2618 )
2619 )*
2620 )?
2621 otherlv_7='{'
2622 {
2623 newLeafNode(otherlv_7, grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4());
2624 }
2625 (
2626 (
2627 {
2628 newCompositeNode(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0());
2629 }
2630 lv_members_8_0=ruleMemberDefinition
2631 {
2632 if ($current==null) {
2633 $current = createModelElementForParent(grammarAccess.getClassDefinitionRule());
2634 }
2635 add(
2636 $current,
2637 "members",
2638 lv_members_8_0,
2639 "org.eclipse.viatra.solver.language.SolverLanguage.MemberDefinition");
2640 afterParserOrEnumRuleCall();
2641 }
2642 )
2643 )*
2644 otherlv_9='}'
2645 {
2646 newLeafNode(otherlv_9, grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6());
2647 }
2648 )
2649;
2650
2651// Entry rule entryRuleMemberDefinition
2652entryRuleMemberDefinition returns [EObject current=null]:
2653 { newCompositeNode(grammarAccess.getMemberDefinitionRule()); }
2654 iv_ruleMemberDefinition=ruleMemberDefinition
2655 { $current=$iv_ruleMemberDefinition.current; }
2656 EOF;
2657
2658// Rule MemberDefinition
2659ruleMemberDefinition returns [EObject current=null]
2660@init {
2661 enterRule();
2662}
2663@after {
2664 leaveRule();
2665}:
2666 (
2667 (
2668 (
2669 lv_containment_0_0='contains'
2670 {
2671 newLeafNode(lv_containment_0_0, grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0());
2672 }
2673 {
2674 if ($current==null) {
2675 $current = createModelElement(grammarAccess.getMemberDefinitionRule());
2676 }
2677 setWithLastConsumed($current, "containment", true, "contains");
2678 }
2679 )
2680 )?
2681 (
2682 (
2683 {
2684 if ($current==null) {
2685 $current = createModelElement(grammarAccess.getMemberDefinitionRule());
2686 }
2687 }
2688 {
2689 newCompositeNode(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0());
2690 }
2691 ruleQualifiedName
2692 {
2693 afterParserOrEnumRuleCall();
2694 }
2695 )
2696 )
2697 (
2698 (
2699 {
2700 newCompositeNode(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0());
2701 }
2702 lv_multiplicity_2_0=ruleMultiplicity
2703 {
2704 if ($current==null) {
2705 $current = createModelElementForParent(grammarAccess.getMemberDefinitionRule());
2706 }
2707 set(
2708 $current,
2709 "multiplicity",
2710 lv_multiplicity_2_0,
2711 "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity");
2712 afterParserOrEnumRuleCall();
2713 }
2714 )
2715 )?
2716 (
2717 (
2718 lv_name_3_0=RULE_ID
2719 {
2720 newLeafNode(lv_name_3_0, grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0());
2721 }
2722 {
2723 if ($current==null) {
2724 $current = createModelElement(grammarAccess.getMemberDefinitionRule());
2725 }
2726 setWithLastConsumed(
2727 $current,
2728 "name",
2729 lv_name_3_0,
2730 "org.eclipse.xtext.common.Terminals.ID");
2731 }
2732 )
2733 )
2734 (
2735 otherlv_4='opposite'
2736 {
2737 newLeafNode(otherlv_4, grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0());
2738 }
2739 (
2740 (
2741 {
2742 if ($current==null) {
2743 $current = createModelElement(grammarAccess.getMemberDefinitionRule());
2744 }
2745 }
2746 {
2747 newCompositeNode(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0());
2748 }
2749 ruleQualifiedName
2750 {
2751 afterParserOrEnumRuleCall();
2752 }
2753 )
2754 )
2755 )?
2756 (
2757 otherlv_6=';'
2758 {
2759 newLeafNode(otherlv_6, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5());
2760 }
2761 )?
2762 )
2763;
2764
2765// Entry rule entryRuleMultiplicity
2766entryRuleMultiplicity returns [EObject current=null]:
2767 { newCompositeNode(grammarAccess.getMultiplicityRule()); }
2768 iv_ruleMultiplicity=ruleMultiplicity
2769 { $current=$iv_ruleMultiplicity.current; }
2770 EOF;
2771
2772// Rule Multiplicity
2773ruleMultiplicity returns [EObject current=null]
2774@init {
2775 enterRule();
2776}
2777@after {
2778 leaveRule();
2779}:
2780 (
2781 {
2782 newCompositeNode(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0());
2783 }
2784 this_ManyMultiplicity_0=ruleManyMultiplicity
2785 {
2786 $current = $this_ManyMultiplicity_0.current;
2787 afterParserOrEnumRuleCall();
2788 }
2789 |
2790 {
2791 newCompositeNode(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1());
2792 }
2793 this_ExactMultiplicity_1=ruleExactMultiplicity
2794 {
2795 $current = $this_ExactMultiplicity_1.current;
2796 afterParserOrEnumRuleCall();
2797 }
2798 |
2799 {
2800 newCompositeNode(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2());
2801 }
2802 this_BoundedMultiplicity_2=ruleBoundedMultiplicity
2803 {
2804 $current = $this_BoundedMultiplicity_2.current;
2805 afterParserOrEnumRuleCall();
2806 }
2807 )
2808;
2809
2810// Entry rule entryRuleManyMultiplicity
2811entryRuleManyMultiplicity returns [EObject current=null]:
2812 { newCompositeNode(grammarAccess.getManyMultiplicityRule()); }
2813 iv_ruleManyMultiplicity=ruleManyMultiplicity
2814 { $current=$iv_ruleManyMultiplicity.current; }
2815 EOF;
2816
2817// Rule ManyMultiplicity
2818ruleManyMultiplicity returns [EObject current=null]
2819@init {
2820 enterRule();
2821}
2822@after {
2823 leaveRule();
2824}:
2825 (
2826 (
2827 {
2828 $current = forceCreateModelElement(
2829 grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0(),
2830 $current);
2831 }
2832 )
2833 otherlv_1='['
2834 {
2835 newLeafNode(otherlv_1, grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1());
2836 }
2837 otherlv_2=']'
2838 {
2839 newLeafNode(otherlv_2, grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2());
2840 }
2841 )
2842;
2843
2844// Entry rule entryRuleExactMultiplicity
2845entryRuleExactMultiplicity returns [EObject current=null]:
2846 { newCompositeNode(grammarAccess.getExactMultiplicityRule()); }
2847 iv_ruleExactMultiplicity=ruleExactMultiplicity
2848 { $current=$iv_ruleExactMultiplicity.current; }
2849 EOF;
2850
2851// Rule ExactMultiplicity
2852ruleExactMultiplicity returns [EObject current=null]
2853@init {
2854 enterRule();
2855}
2856@after {
2857 leaveRule();
2858}:
2859 (
2860 otherlv_0='['
2861 {
2862 newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0());
2863 }
2864 (
2865 (
2866 {
2867 newCompositeNode(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0());
2868 }
2869 lv_multiplicity_1_0=ruleUpperMultiplicty
2870 {
2871 if ($current==null) {
2872 $current = createModelElementForParent(grammarAccess.getExactMultiplicityRule());
2873 }
2874 set(
2875 $current,
2876 "multiplicity",
2877 lv_multiplicity_1_0,
2878 "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty");
2879 afterParserOrEnumRuleCall();
2880 }
2881 )
2882 )
2883 otherlv_2=']'
2884 {
2885 newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2());
2886 }
2887 )
2888;
2889
2890// Entry rule entryRuleBoundedMultiplicity
2891entryRuleBoundedMultiplicity returns [EObject current=null]:
2892 { newCompositeNode(grammarAccess.getBoundedMultiplicityRule()); }
2893 iv_ruleBoundedMultiplicity=ruleBoundedMultiplicity
2894 { $current=$iv_ruleBoundedMultiplicity.current; }
2895 EOF;
2896
2897// Rule BoundedMultiplicity
2898ruleBoundedMultiplicity returns [EObject current=null]
2899@init {
2900 enterRule();
2901}
2902@after {
2903 leaveRule();
2904}:
2905 (
2906 otherlv_0='['
2907 {
2908 newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0());
2909 }
2910 (
2911 (
2912 lv_lowerBound_1_0=RULE_INT
2913 {
2914 newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0());
2915 }
2916 {
2917 if ($current==null) {
2918 $current = createModelElement(grammarAccess.getBoundedMultiplicityRule());
2919 }
2920 setWithLastConsumed(
2921 $current,
2922 "lowerBound",
2923 lv_lowerBound_1_0,
2924 "org.eclipse.xtext.common.Terminals.INT");
2925 }
2926 )
2927 )
2928 otherlv_2='..'
2929 {
2930 newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2());
2931 }
2932 (
2933 (
2934 {
2935 newCompositeNode(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0());
2936 }
2937 lv_upperBound_3_0=ruleUpperMultiplicty
2938 {
2939 if ($current==null) {
2940 $current = createModelElementForParent(grammarAccess.getBoundedMultiplicityRule());
2941 }
2942 set(
2943 $current,
2944 "upperBound",
2945 lv_upperBound_3_0,
2946 "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty");
2947 afterParserOrEnumRuleCall();
2948 }
2949 )
2950 )
2951 otherlv_4=']'
2952 {
2953 newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4());
2954 }
2955 )
2956;
2957
2958// Entry rule entryRuleScopeDefinition
2959entryRuleScopeDefinition returns [EObject current=null]:
2960 { newCompositeNode(grammarAccess.getScopeDefinitionRule()); }
2961 iv_ruleScopeDefinition=ruleScopeDefinition
2962 { $current=$iv_ruleScopeDefinition.current; }
2963 EOF;
2964
2965// Rule ScopeDefinition
2966ruleScopeDefinition returns [EObject current=null]
2967@init {
2968 enterRule();
2969}
2970@after {
2971 leaveRule();
2972}:
2973 (
2974 {
2975 newCompositeNode(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0());
2976 }
2977 this_ExactScopeDefinition_0=ruleExactScopeDefinition
2978 {
2979 $current = $this_ExactScopeDefinition_0.current;
2980 afterParserOrEnumRuleCall();
2981 }
2982 |
2983 {
2984 newCompositeNode(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1());
2985 }
2986 this_BoundedScopeDefinition_1=ruleBoundedScopeDefinition
2987 {
2988 $current = $this_BoundedScopeDefinition_1.current;
2989 afterParserOrEnumRuleCall();
2990 }
2991 |
2992 {
2993 newCompositeNode(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2());
2994 }
2995 this_LowerBoundedScopeDefinition_2=ruleLowerBoundedScopeDefinition
2996 {
2997 $current = $this_LowerBoundedScopeDefinition_2.current;
2998 afterParserOrEnumRuleCall();
2999 }
3000 )
3001;
3002
3003// Entry rule entryRuleExactScopeDefinition
3004entryRuleExactScopeDefinition returns [EObject current=null]:
3005 { newCompositeNode(grammarAccess.getExactScopeDefinitionRule()); }
3006 iv_ruleExactScopeDefinition=ruleExactScopeDefinition
3007 { $current=$iv_ruleExactScopeDefinition.current; }
3008 EOF;
3009
3010// Rule ExactScopeDefinition
3011ruleExactScopeDefinition returns [EObject current=null]
3012@init {
3013 enterRule();
3014}
3015@after {
3016 leaveRule();
3017}:
3018 (
3019 otherlv_0='scope'
3020 {
3021 newLeafNode(otherlv_0, grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0());
3022 }
3023 (
3024 (
3025 {
3026 if ($current==null) {
3027 $current = createModelElement(grammarAccess.getExactScopeDefinitionRule());
3028 }
3029 }
3030 {
3031 newCompositeNode(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0());
3032 }
3033 ruleQualifiedName
3034 {
3035 afterParserOrEnumRuleCall();
3036 }
3037 )
3038 )
3039 otherlv_2='=='
3040 {
3041 newLeafNode(otherlv_2, grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2());
3042 }
3043 (
3044 (
3045 lv_exactScope_3_0=RULE_INT
3046 {
3047 newLeafNode(lv_exactScope_3_0, grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0());
3048 }
3049 {
3050 if ($current==null) {
3051 $current = createModelElement(grammarAccess.getExactScopeDefinitionRule());
3052 }
3053 setWithLastConsumed(
3054 $current,
3055 "exactScope",
3056 lv_exactScope_3_0,
3057 "org.eclipse.xtext.common.Terminals.INT");
3058 }
3059 )
3060 )
3061 )
3062;
3063
3064// Entry rule entryRuleBoundedScopeDefinition
3065entryRuleBoundedScopeDefinition returns [EObject current=null]:
3066 { newCompositeNode(grammarAccess.getBoundedScopeDefinitionRule()); }
3067 iv_ruleBoundedScopeDefinition=ruleBoundedScopeDefinition
3068 { $current=$iv_ruleBoundedScopeDefinition.current; }
3069 EOF;
3070
3071// Rule BoundedScopeDefinition
3072ruleBoundedScopeDefinition returns [EObject current=null]
3073@init {
3074 enterRule();
3075}
3076@after {
3077 leaveRule();
3078}:
3079 (
3080 otherlv_0='scope'
3081 {
3082 newLeafNode(otherlv_0, grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0());
3083 }
3084 (
3085 (
3086 (
3087 (
3088 (
3089 lv_lowerBound_1_0=RULE_INT
3090 {
3091 newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0());
3092 }
3093 {
3094 if ($current==null) {
3095 $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule());
3096 }
3097 setWithLastConsumed(
3098 $current,
3099 "lowerBound",
3100 lv_lowerBound_1_0,
3101 "org.eclipse.xtext.common.Terminals.INT");
3102 }
3103 )
3104 )
3105 otherlv_2='<='
3106 {
3107 newLeafNode(otherlv_2, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1());
3108 }
3109 )?
3110 (
3111 (
3112 {
3113 if ($current==null) {
3114 $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule());
3115 }
3116 }
3117 {
3118 newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0());
3119 }
3120 ruleQualifiedName
3121 {
3122 afterParserOrEnumRuleCall();
3123 }
3124 )
3125 )
3126 otherlv_4='<='
3127 {
3128 newLeafNode(otherlv_4, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2());
3129 }
3130 (
3131 (
3132 lv_upperBound_5_0=RULE_INT
3133 {
3134 newLeafNode(lv_upperBound_5_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0());
3135 }
3136 {
3137 if ($current==null) {
3138 $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule());
3139 }
3140 setWithLastConsumed(
3141 $current,
3142 "upperBound",
3143 lv_upperBound_5_0,
3144 "org.eclipse.xtext.common.Terminals.INT");
3145 }
3146 )
3147 )
3148 )
3149 |
3150 (
3151 (
3152 (
3153 lv_upperBound_6_0=RULE_INT
3154 {
3155 newLeafNode(lv_upperBound_6_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0());
3156 }
3157 {
3158 if ($current==null) {
3159 $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule());
3160 }
3161 setWithLastConsumed(
3162 $current,
3163 "upperBound",
3164 lv_upperBound_6_0,
3165 "org.eclipse.xtext.common.Terminals.INT");
3166 }
3167 )
3168 )
3169 otherlv_7='>='
3170 {
3171 newLeafNode(otherlv_7, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1());
3172 }
3173 (
3174 (
3175 {
3176 if ($current==null) {
3177 $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule());
3178 }
3179 }
3180 {
3181 newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0());
3182 }
3183 ruleQualifiedName
3184 {
3185 afterParserOrEnumRuleCall();
3186 }
3187 )
3188 )
3189 (
3190 otherlv_9='>='
3191 {
3192 newLeafNode(otherlv_9, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0());
3193 }
3194 (
3195 (
3196 lv_lowerBound_10_0=RULE_INT
3197 {
3198 newLeafNode(lv_lowerBound_10_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0());
3199 }
3200 {
3201 if ($current==null) {
3202 $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule());
3203 }
3204 setWithLastConsumed(
3205 $current,
3206 "lowerBound",
3207 lv_lowerBound_10_0,
3208 "org.eclipse.xtext.common.Terminals.INT");
3209 }
3210 )
3211 )
3212 )?
3213 )
3214 )
3215 otherlv_11='.'
3216 {
3217 newLeafNode(otherlv_11, grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2());
3218 }
3219 )
3220;
3221
3222// Entry rule entryRuleLowerBoundedScopeDefinition
3223entryRuleLowerBoundedScopeDefinition returns [EObject current=null]:
3224 { newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionRule()); }
3225 iv_ruleLowerBoundedScopeDefinition=ruleLowerBoundedScopeDefinition
3226 { $current=$iv_ruleLowerBoundedScopeDefinition.current; }
3227 EOF;
3228
3229// Rule LowerBoundedScopeDefinition
3230ruleLowerBoundedScopeDefinition returns [EObject current=null]
3231@init {
3232 enterRule();
3233}
3234@after {
3235 leaveRule();
3236}:
3237 (
3238 otherlv_0='scope'
3239 {
3240 newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0());
3241 }
3242 (
3243 (
3244 (
3245 (
3246 lv_lowerBound_1_0=RULE_INT
3247 {
3248 newLeafNode(lv_lowerBound_1_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0());
3249 }
3250 {
3251 if ($current==null) {
3252 $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule());
3253 }
3254 setWithLastConsumed(
3255 $current,
3256 "lowerBound",
3257 lv_lowerBound_1_0,
3258 "org.eclipse.xtext.common.Terminals.INT");
3259 }
3260 )
3261 )
3262 otherlv_2='<='
3263 {
3264 newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1());
3265 }
3266 (
3267 (
3268 {
3269 if ($current==null) {
3270 $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule());
3271 }
3272 }
3273 {
3274 newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0());
3275 }
3276 ruleQualifiedName
3277 {
3278 afterParserOrEnumRuleCall();
3279 }
3280 )
3281 )
3282 )
3283 |
3284 (
3285 (
3286 (
3287 {
3288 if ($current==null) {
3289 $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule());
3290 }
3291 }
3292 {
3293 newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0());
3294 }
3295 ruleQualifiedName
3296 {
3297 afterParserOrEnumRuleCall();
3298 }
3299 )
3300 )
3301 otherlv_5='>='
3302 {
3303 newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1());
3304 }
3305 (
3306 (
3307 lv_lowerBound_6_0=RULE_INT
3308 {
3309 newLeafNode(lv_lowerBound_6_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0());
3310 }
3311 {
3312 if ($current==null) {
3313 $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule());
3314 }
3315 setWithLastConsumed(
3316 $current,
3317 "lowerBound",
3318 lv_lowerBound_6_0,
3319 "org.eclipse.xtext.common.Terminals.INT");
3320 }
3321 )
3322 )
3323 )
3324 )
3325 otherlv_7='.'
3326 {
3327 newLeafNode(otherlv_7, grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2());
3328 }
3329 )
3330;
3331
3332// Entry rule entryRuleObjectiveDefinition
3333entryRuleObjectiveDefinition returns [EObject current=null]:
3334 { newCompositeNode(grammarAccess.getObjectiveDefinitionRule()); }
3335 iv_ruleObjectiveDefinition=ruleObjectiveDefinition
3336 { $current=$iv_ruleObjectiveDefinition.current; }
3337 EOF;
3338
3339// Rule ObjectiveDefinition
3340ruleObjectiveDefinition returns [EObject current=null]
3341@init {
3342 enterRule();
3343}
3344@after {
3345 leaveRule();
3346}:
3347 (
3348 (
3349 (
3350 {
3351 newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0());
3352 }
3353 lv_kind_0_0=ruleObjectiveKind
3354 {
3355 if ($current==null) {
3356 $current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule());
3357 }
3358 set(
3359 $current,
3360 "kind",
3361 lv_kind_0_0,
3362 "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind");
3363 afterParserOrEnumRuleCall();
3364 }
3365 )
3366 )
3367 (
3368 (
3369 {
3370 newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0());
3371 }
3372 lv_objective_1_0=ruleExpression
3373 {
3374 if ($current==null) {
3375 $current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule());
3376 }
3377 set(
3378 $current,
3379 "objective",
3380 lv_objective_1_0,
3381 "org.eclipse.viatra.solver.language.SolverLanguage.Expression");
3382 afterParserOrEnumRuleCall();
3383 }
3384 )
3385 )
3386 )
3387;
3388
3389// Entry rule entryRuleUpperMultiplicty
3390entryRuleUpperMultiplicty returns [String current=null]:
3391 { newCompositeNode(grammarAccess.getUpperMultiplictyRule()); }
3392 iv_ruleUpperMultiplicty=ruleUpperMultiplicty
3393 { $current=$iv_ruleUpperMultiplicty.current.getText(); }
3394 EOF;
3395
3396// Rule UpperMultiplicty
3397ruleUpperMultiplicty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
3398@init {
3399 enterRule();
3400}
3401@after {
3402 leaveRule();
3403}:
3404 (
3405 this_INT_0=RULE_INT
3406 {
3407 $current.merge(this_INT_0);
3408 }
3409 {
3410 newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0());
3411 }
3412 |
3413 kw='*'
3414 {
3415 $current.merge(kw);
3416 newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1());
3417 }
3418 )
3419;
3420
3421// Entry rule entryRuleReal
3422entryRuleReal returns [String current=null]@init {
3423 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
3424}:
3425 { newCompositeNode(grammarAccess.getRealRule()); }
3426 iv_ruleReal=ruleReal
3427 { $current=$iv_ruleReal.current.getText(); }
3428 EOF;
3429finally {
3430 myHiddenTokenState.restore();
3431}
3432
3433// Rule Real
3434ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
3435@init {
3436 enterRule();
3437 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
3438}
3439@after {
3440 leaveRule();
3441}:
3442 (
3443 this_INT_0=RULE_INT
3444 {
3445 $current.merge(this_INT_0);
3446 }
3447 {
3448 newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0());
3449 }
3450 (
3451 kw='.'
3452 {
3453 $current.merge(kw);
3454 newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1_0());
3455 }
3456 this_INT_2=RULE_INT
3457 {
3458 $current.merge(this_INT_2);
3459 }
3460 {
3461 newLeafNode(this_INT_2, grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1());
3462 }
3463 )?
3464 )
3465;
3466finally {
3467 myHiddenTokenState.restore();
3468}
3469
3470// Entry rule entryRuleQualifiedName
3471entryRuleQualifiedName returns [String current=null]@init {
3472 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
3473}:
3474 { newCompositeNode(grammarAccess.getQualifiedNameRule()); }
3475 iv_ruleQualifiedName=ruleQualifiedName
3476 { $current=$iv_ruleQualifiedName.current.getText(); }
3477 EOF;
3478finally {
3479 myHiddenTokenState.restore();
3480}
3481
3482// Rule QualifiedName
3483ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
3484@init {
3485 enterRule();
3486 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
3487}
3488@after {
3489 leaveRule();
3490}:
3491 (
3492 (
3493 this_ID_0=RULE_ID
3494 {
3495 $current.merge(this_ID_0);
3496 }
3497 {
3498 newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0());
3499 }
3500 (
3501 kw='.'
3502 {
3503 $current.merge(kw);
3504 newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0());
3505 }
3506 this_ID_2=RULE_ID
3507 {
3508 $current.merge(this_ID_2);
3509 }
3510 {
3511 newLeafNode(this_ID_2, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1());
3512 }
3513 )*
3514 )
3515 |
3516 this_QUOTED_ID_3=RULE_QUOTED_ID
3517 {
3518 $current.merge(this_QUOTED_ID_3);
3519 }
3520 {
3521 newLeafNode(this_QUOTED_ID_3, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1());
3522 }
3523 )
3524;
3525finally {
3526 myHiddenTokenState.restore();
3527}
3528
3529// Rule MetricType
3530ruleMetricType returns [Enumerator current=null]
3531@init {
3532 enterRule();
3533}
3534@after {
3535 leaveRule();
3536}:
3537 (
3538 (
3539 enumLiteral_0='int'
3540 {
3541 $current = grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
3542 newLeafNode(enumLiteral_0, grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0());
3543 }
3544 )
3545 |
3546 (
3547 enumLiteral_1='real'
3548 {
3549 $current = grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
3550 newLeafNode(enumLiteral_1, grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1());
3551 }
3552 )
3553 )
3554;
3555
3556// Rule ComparisonOperator
3557ruleComparisonOperator returns [Enumerator current=null]
3558@init {
3559 enterRule();
3560}
3561@after {
3562 leaveRule();
3563}:
3564 (
3565 (
3566 enumLiteral_0='=='
3567 {
3568 $current = grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
3569 newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0());
3570 }
3571 )
3572 |
3573 (
3574 enumLiteral_1='!='
3575 {
3576 $current = grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
3577 newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1());
3578 }
3579 )
3580 |
3581 (
3582 enumLiteral_2='<'
3583 {
3584 $current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance();
3585 newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2());
3586 }
3587 )
3588 |
3589 (
3590 enumLiteral_3='<='
3591 {
3592 $current = grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3().getEnumLiteral().getInstance();
3593 newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3());
3594 }
3595 )
3596 |
3597 (
3598 enumLiteral_4='>'
3599 {
3600 $current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance();
3601 newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4());
3602 }
3603 )
3604 |
3605 (
3606 enumLiteral_5='>='
3607 {
3608 $current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5().getEnumLiteral().getInstance();
3609 newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5());
3610 }
3611 )
3612 |
3613 (
3614 enumLiteral_6='in'
3615 {
3616 $current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance();
3617 newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6());
3618 }
3619 )
3620 )
3621;
3622
3623// Rule AdditiveBinaryOperator
3624ruleAdditiveBinaryOperator returns [Enumerator current=null]
3625@init {
3626 enterRule();
3627}
3628@after {
3629 leaveRule();
3630}:
3631 (
3632 (
3633 enumLiteral_0='+'
3634 {
3635 $current = grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
3636 newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0());
3637 }
3638 )
3639 |
3640 (
3641 enumLiteral_1='-'
3642 {
3643 $current = grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
3644 newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1());
3645 }
3646 )
3647 )
3648;
3649
3650// Rule MultiplicativeBinaryOperator
3651ruleMultiplicativeBinaryOperator returns [Enumerator current=null]
3652@init {
3653 enterRule();
3654}
3655@after {
3656 leaveRule();
3657}:
3658 (
3659 (
3660 enumLiteral_0='*'
3661 {
3662 $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
3663 newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0());
3664 }
3665 )
3666 |
3667 (
3668 enumLiteral_1='/'
3669 {
3670 $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
3671 newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1());
3672 }
3673 )
3674 )
3675;
3676
3677// Rule ExponentialOp
3678ruleExponentialOp returns [Enumerator current=null]
3679@init {
3680 enterRule();
3681}
3682@after {
3683 leaveRule();
3684}:
3685 (
3686 enumLiteral_0='^'
3687 {
3688 $current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance();
3689 newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration());
3690 }
3691 )
3692;
3693
3694// Rule UnaryOp
3695ruleUnaryOp returns [Enumerator current=null]
3696@init {
3697 enterRule();
3698}
3699@after {
3700 leaveRule();
3701}:
3702 (
3703 (
3704 enumLiteral_0='!'
3705 {
3706 $current = grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
3707 newLeafNode(enumLiteral_0, grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0());
3708 }
3709 )
3710 |
3711 (
3712 enumLiteral_1='+'
3713 {
3714 $current = grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
3715 newLeafNode(enumLiteral_1, grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1());
3716 }
3717 )
3718 |
3719 (
3720 enumLiteral_2='-'
3721 {
3722 $current = grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance();
3723 newLeafNode(enumLiteral_2, grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2());
3724 }
3725 )
3726 |
3727 (
3728 enumLiteral_3='may'
3729 {
3730 $current = grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3().getEnumLiteral().getInstance();
3731 newLeafNode(enumLiteral_3, grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3());
3732 }
3733 )
3734 |
3735 (
3736 enumLiteral_4='must'
3737 {
3738 $current = grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4().getEnumLiteral().getInstance();
3739 newLeafNode(enumLiteral_4, grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4());
3740 }
3741 )
3742 |
3743 (
3744 enumLiteral_5='current'
3745 {
3746 $current = grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5().getEnumLiteral().getInstance();
3747 newLeafNode(enumLiteral_5, grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5());
3748 }
3749 )
3750 )
3751;
3752
3753// Rule AggregationOp
3754ruleAggregationOp returns [Enumerator current=null]
3755@init {
3756 enterRule();
3757}
3758@after {
3759 leaveRule();
3760}:
3761 (
3762 (
3763 enumLiteral_0='only'
3764 {
3765 $current = grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
3766 newLeafNode(enumLiteral_0, grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0());
3767 }
3768 )
3769 |
3770 (
3771 enumLiteral_1='sum'
3772 {
3773 $current = grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
3774 newLeafNode(enumLiteral_1, grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1());
3775 }
3776 )
3777 |
3778 (
3779 enumLiteral_2='prod'
3780 {
3781 $current = grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2().getEnumLiteral().getInstance();
3782 newLeafNode(enumLiteral_2, grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2());
3783 }
3784 )
3785 |
3786 (
3787 enumLiteral_3='avg'
3788 {
3789 $current = grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3().getEnumLiteral().getInstance();
3790 newLeafNode(enumLiteral_3, grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3());
3791 }
3792 )
3793 |
3794 (
3795 enumLiteral_4='min'
3796 {
3797 $current = grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4().getEnumLiteral().getInstance();
3798 newLeafNode(enumLiteral_4, grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4());
3799 }
3800 )
3801 |
3802 (
3803 enumLiteral_5='max'
3804 {
3805 $current = grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5().getEnumLiteral().getInstance();
3806 newLeafNode(enumLiteral_5, grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5());
3807 }
3808 )
3809 )
3810;
3811
3812// Rule LogicValue
3813ruleLogicValue returns [Enumerator current=null]
3814@init {
3815 enterRule();
3816}
3817@after {
3818 leaveRule();
3819}:
3820 (
3821 (
3822 enumLiteral_0='true'
3823 {
3824 $current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
3825 newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0());
3826 }
3827 )
3828 |
3829 (
3830 enumLiteral_1='false'
3831 {
3832 $current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
3833 newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1());
3834 }
3835 )
3836 |
3837 (
3838 enumLiteral_2='unknown'
3839 {
3840 $current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance();
3841 newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2());
3842 }
3843 )
3844 |
3845 (
3846 enumLiteral_3='error'
3847 {
3848 $current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance();
3849 newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3());
3850 }
3851 )
3852 )
3853;
3854
3855// Rule ObjectiveKind
3856ruleObjectiveKind returns [Enumerator current=null]
3857@init {
3858 enterRule();
3859}
3860@after {
3861 leaveRule();
3862}:
3863 (
3864 (
3865 enumLiteral_0='minimize'
3866 {
3867 $current = grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
3868 newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0());
3869 }
3870 )
3871 |
3872 (
3873 enumLiteral_1='maximize'
3874 {
3875 $current = grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
3876 newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1());
3877 }
3878 )
3879 )
3880;
3881
3882RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"';
3883
3884RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\'';
3885
3886RULE_PLUS : 'synthetic::plus';
3887
3888RULE_STAR : 'synthetic::star';
3889
3890RULE_DOT : 'synthetic::dot';
3891
3892RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
3893
3894RULE_INT : ('0'..'9')+;
3895
3896RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
3897
3898RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
3899
3900RULE_WS : (' '|'\t'|'\r'|'\n')+;
3901
3902RULE_ANY_OTHER : .;
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-09-03 14:11:06 +0000