aboutsummaryrefslogtreecommitdiffstats
path: root/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java
diff options
context:
space:
mode:
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java')
-rw-r--r--Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java7214
1 files changed, 7214 insertions, 0 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java
new file mode 100644
index 00000000..c1c632f3
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java
@@ -0,0 +1,7214 @@
1package org.eclipse.viatra.solver.language.parser.antlr.internal;
2
3import org.eclipse.xtext.*;
4import org.eclipse.xtext.parser.*;
5import org.eclipse.xtext.parser.impl.*;
6import org.eclipse.emf.ecore.util.EcoreUtil;
7import org.eclipse.emf.ecore.EObject;
8import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
9import org.eclipse.xtext.parser.antlr.XtextTokenStream;
10import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
11import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
12import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
13
14
15
16import org.antlr.runtime.*;
17import java.util.Stack;
18import java.util.List;
19import java.util.ArrayList;
20
21@SuppressWarnings("all")
22public class InternalSolverLanguageParser extends AbstractInternalAntlrParser {
23 public static final String[] tokenNames = new String[] {
24 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_INT", "RULE_ID", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'-'", "'.'", "'true'", "'false'", "'unknown'", "'error'", "'('", "')'", "':'", "'exists'", "'equals'", "'bool'", "'int'", "'real'", "'string'", "'\\''", "'predicate'", "'|'", "'+'", "'*'", "'default'", "'abstract'", "'class'", "'extends'", "'{'", "'}'", "'enum'", "'containment'", "'relation'", "'..'"
25 };
26 public static final int RULE_STRING=6;
27 public static final int RULE_SL_COMMENT=8;
28 public static final int T__19=19;
29 public static final int T__15=15;
30 public static final int T__37=37;
31 public static final int T__16=16;
32 public static final int T__38=38;
33 public static final int T__17=17;
34 public static final int T__39=39;
35 public static final int T__18=18;
36 public static final int T__11=11;
37 public static final int T__33=33;
38 public static final int T__12=12;
39 public static final int T__34=34;
40 public static final int T__13=13;
41 public static final int T__35=35;
42 public static final int T__14=14;
43 public static final int T__36=36;
44 public static final int EOF=-1;
45 public static final int T__30=30;
46 public static final int T__31=31;
47 public static final int T__32=32;
48 public static final int RULE_ID=5;
49 public static final int RULE_WS=9;
50 public static final int RULE_ANY_OTHER=10;
51 public static final int T__26=26;
52 public static final int T__27=27;
53 public static final int T__28=28;
54 public static final int RULE_INT=4;
55 public static final int T__29=29;
56 public static final int T__22=22;
57 public static final int RULE_ML_COMMENT=7;
58 public static final int T__23=23;
59 public static final int T__24=24;
60 public static final int T__25=25;
61 public static final int T__40=40;
62 public static final int T__20=20;
63 public static final int T__21=21;
64
65 // delegates
66 // delegators
67
68
69 public InternalSolverLanguageParser(TokenStream input) {
70 this(input, new RecognizerSharedState());
71 }
72 public InternalSolverLanguageParser(TokenStream input, RecognizerSharedState state) {
73 super(input, state);
74
75 }
76
77
78 public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; }
79 public String getGrammarFileName() { return "InternalSolverLanguage.g"; }
80
81
82
83 private SolverLanguageGrammarAccess grammarAccess;
84
85 public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) {
86 this(input);
87 this.grammarAccess = grammarAccess;
88 registerRules(grammarAccess.getGrammar());
89 }
90
91 @Override
92 protected String getFirstRuleName() {
93 return "Problem";
94 }
95
96 @Override
97 protected SolverLanguageGrammarAccess getGrammarAccess() {
98 return grammarAccess;
99 }
100
101
102
103
104 // $ANTLR start "entryRuleProblem"
105 // InternalSolverLanguage.g:64:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ;
106 public final EObject entryRuleProblem() throws RecognitionException {
107 EObject current = null;
108
109 EObject iv_ruleProblem = null;
110
111
112 try {
113 // InternalSolverLanguage.g:64:48: (iv_ruleProblem= ruleProblem EOF )
114 // InternalSolverLanguage.g:65:2: iv_ruleProblem= ruleProblem EOF
115 {
116 newCompositeNode(grammarAccess.getProblemRule());
117 pushFollow(FOLLOW_1);
118 iv_ruleProblem=ruleProblem();
119
120 state._fsp--;
121
122 current =iv_ruleProblem;
123 match(input,EOF,FOLLOW_2);
124
125 }
126
127 }
128
129 catch (RecognitionException re) {
130 recover(input,re);
131 appendSkippedTokens();
132 }
133 finally {
134 }
135 return current;
136 }
137 // $ANTLR end "entryRuleProblem"
138
139
140 // $ANTLR start "ruleProblem"
141 // InternalSolverLanguage.g:71:1: ruleProblem returns [EObject current=null] : ( (lv_statements_0_0= ruleStatement ) )* ;
142 public final EObject ruleProblem() throws RecognitionException {
143 EObject current = null;
144
145 EObject lv_statements_0_0 = null;
146
147
148
149 enterRule();
150
151 try {
152 // InternalSolverLanguage.g:77:2: ( ( (lv_statements_0_0= ruleStatement ) )* )
153 // InternalSolverLanguage.g:78:2: ( (lv_statements_0_0= ruleStatement ) )*
154 {
155 // InternalSolverLanguage.g:78:2: ( (lv_statements_0_0= ruleStatement ) )*
156 loop1:
157 do {
158 int alt1=2;
159 int LA1_0 = input.LA(1);
160
161 if ( (LA1_0==RULE_ID||LA1_0==16||(LA1_0>=20 && LA1_0<=25)||LA1_0==27||(LA1_0>=31 && LA1_0<=32)||(LA1_0>=37 && LA1_0<=38)) ) {
162 alt1=1;
163 }
164
165
166 switch (alt1) {
167 case 1 :
168 // InternalSolverLanguage.g:79:3: (lv_statements_0_0= ruleStatement )
169 {
170 // InternalSolverLanguage.g:79:3: (lv_statements_0_0= ruleStatement )
171 // InternalSolverLanguage.g:80:4: lv_statements_0_0= ruleStatement
172 {
173
174 newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0());
175
176 pushFollow(FOLLOW_3);
177 lv_statements_0_0=ruleStatement();
178
179 state._fsp--;
180
181
182 if (current==null) {
183 current = createModelElementForParent(grammarAccess.getProblemRule());
184 }
185 add(
186 current,
187 "statements",
188 lv_statements_0_0,
189 "org.eclipse.viatra.solver.language.SolverLanguage.Statement");
190 afterParserOrEnumRuleCall();
191
192
193 }
194
195
196 }
197 break;
198
199 default :
200 break loop1;
201 }
202 } while (true);
203
204
205 }
206
207
208 leaveRule();
209
210 }
211
212 catch (RecognitionException re) {
213 recover(input,re);
214 appendSkippedTokens();
215 }
216 finally {
217 }
218 return current;
219 }
220 // $ANTLR end "ruleProblem"
221
222
223 // $ANTLR start "entryRuleStatement"
224 // InternalSolverLanguage.g:100:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ;
225 public final EObject entryRuleStatement() throws RecognitionException {
226 EObject current = null;
227
228 EObject iv_ruleStatement = null;
229
230
231 try {
232 // InternalSolverLanguage.g:100:50: (iv_ruleStatement= ruleStatement EOF )
233 // InternalSolverLanguage.g:101:2: iv_ruleStatement= ruleStatement EOF
234 {
235 newCompositeNode(grammarAccess.getStatementRule());
236 pushFollow(FOLLOW_1);
237 iv_ruleStatement=ruleStatement();
238
239 state._fsp--;
240
241 current =iv_ruleStatement;
242 match(input,EOF,FOLLOW_2);
243
244 }
245
246 }
247
248 catch (RecognitionException re) {
249 recover(input,re);
250 appendSkippedTokens();
251 }
252 finally {
253 }
254 return current;
255 }
256 // $ANTLR end "entryRuleStatement"
257
258
259 // $ANTLR start "ruleStatement"
260 // InternalSolverLanguage.g:107:1: ruleStatement returns [EObject current=null] : (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) ;
261 public final EObject ruleStatement() throws RecognitionException {
262 EObject current = null;
263
264 EObject this_Interpretation_0 = null;
265
266 EObject this_Predicate_1 = null;
267
268
269
270 enterRule();
271
272 try {
273 // InternalSolverLanguage.g:113:2: ( (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) )
274 // InternalSolverLanguage.g:114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate )
275 {
276 // InternalSolverLanguage.g:114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate )
277 int alt2=2;
278 int LA2_0 = input.LA(1);
279
280 if ( (LA2_0==RULE_ID||(LA2_0>=20 && LA2_0<=25)||(LA2_0>=31 && LA2_0<=32)||(LA2_0>=37 && LA2_0<=38)) ) {
281 alt2=1;
282 }
283 else if ( (LA2_0==16||LA2_0==27) ) {
284 alt2=2;
285 }
286 else {
287 NoViableAltException nvae =
288 new NoViableAltException("", 2, 0, input);
289
290 throw nvae;
291 }
292 switch (alt2) {
293 case 1 :
294 // InternalSolverLanguage.g:115:3: this_Interpretation_0= ruleInterpretation
295 {
296
297 newCompositeNode(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0());
298
299 pushFollow(FOLLOW_2);
300 this_Interpretation_0=ruleInterpretation();
301
302 state._fsp--;
303
304
305 current = this_Interpretation_0;
306 afterParserOrEnumRuleCall();
307
308
309 }
310 break;
311 case 2 :
312 // InternalSolverLanguage.g:124:3: this_Predicate_1= rulePredicate
313 {
314
315 newCompositeNode(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1());
316
317 pushFollow(FOLLOW_2);
318 this_Predicate_1=rulePredicate();
319
320 state._fsp--;
321
322
323 current = this_Predicate_1;
324 afterParserOrEnumRuleCall();
325
326
327 }
328 break;
329
330 }
331
332
333 }
334
335
336 leaveRule();
337
338 }
339
340 catch (RecognitionException re) {
341 recover(input,re);
342 appendSkippedTokens();
343 }
344 finally {
345 }
346 return current;
347 }
348 // $ANTLR end "ruleStatement"
349
350
351 // $ANTLR start "entryRuleREALLiteral"
352 // InternalSolverLanguage.g:136:1: entryRuleREALLiteral returns [String current=null] : iv_ruleREALLiteral= ruleREALLiteral EOF ;
353 public final String entryRuleREALLiteral() throws RecognitionException {
354 String current = null;
355
356 AntlrDatatypeRuleToken iv_ruleREALLiteral = null;
357
358
359 try {
360 // InternalSolverLanguage.g:136:51: (iv_ruleREALLiteral= ruleREALLiteral EOF )
361 // InternalSolverLanguage.g:137:2: iv_ruleREALLiteral= ruleREALLiteral EOF
362 {
363 newCompositeNode(grammarAccess.getREALLiteralRule());
364 pushFollow(FOLLOW_1);
365 iv_ruleREALLiteral=ruleREALLiteral();
366
367 state._fsp--;
368
369 current =iv_ruleREALLiteral.getText();
370 match(input,EOF,FOLLOW_2);
371
372 }
373
374 }
375
376 catch (RecognitionException re) {
377 recover(input,re);
378 appendSkippedTokens();
379 }
380 finally {
381 }
382 return current;
383 }
384 // $ANTLR end "entryRuleREALLiteral"
385
386
387 // $ANTLR start "ruleREALLiteral"
388 // InternalSolverLanguage.g:143:1: ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) ;
389 public final AntlrDatatypeRuleToken ruleREALLiteral() throws RecognitionException {
390 AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
391
392 Token kw=null;
393 Token this_INT_1=null;
394 Token this_INT_3=null;
395
396
397 enterRule();
398
399 try {
400 // InternalSolverLanguage.g:149:2: ( ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) )
401 // InternalSolverLanguage.g:150:2: ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT )
402 {
403 // InternalSolverLanguage.g:150:2: ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT )
404 // InternalSolverLanguage.g:151:3: (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT
405 {
406 // InternalSolverLanguage.g:151:3: (kw= '-' )?
407 int alt3=2;
408 int LA3_0 = input.LA(1);
409
410 if ( (LA3_0==11) ) {
411 alt3=1;
412 }
413 switch (alt3) {
414 case 1 :
415 // InternalSolverLanguage.g:152:4: kw= '-'
416 {
417 kw=(Token)match(input,11,FOLLOW_4);
418
419 current.merge(kw);
420 newLeafNode(kw, grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0());
421
422
423 }
424 break;
425
426 }
427
428 this_INT_1=(Token)match(input,RULE_INT,FOLLOW_5);
429
430 current.merge(this_INT_1);
431
432
433 newLeafNode(this_INT_1, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1());
434
435 kw=(Token)match(input,12,FOLLOW_4);
436
437 current.merge(kw);
438 newLeafNode(kw, grammarAccess.getREALLiteralAccess().getFullStopKeyword_2());
439
440 this_INT_3=(Token)match(input,RULE_INT,FOLLOW_2);
441
442 current.merge(this_INT_3);
443
444
445 newLeafNode(this_INT_3, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3());
446
447
448 }
449
450
451 }
452
453
454 leaveRule();
455
456 }
457
458 catch (RecognitionException re) {
459 recover(input,re);
460 appendSkippedTokens();
461 }
462 finally {
463 }
464 return current;
465 }
466 // $ANTLR end "ruleREALLiteral"
467
468
469 // $ANTLR start "entryRuleINTLiteral"
470 // InternalSolverLanguage.g:181:1: entryRuleINTLiteral returns [String current=null] : iv_ruleINTLiteral= ruleINTLiteral EOF ;
471 public final String entryRuleINTLiteral() throws RecognitionException {
472 String current = null;
473
474 AntlrDatatypeRuleToken iv_ruleINTLiteral = null;
475
476
477 try {
478 // InternalSolverLanguage.g:181:50: (iv_ruleINTLiteral= ruleINTLiteral EOF )
479 // InternalSolverLanguage.g:182:2: iv_ruleINTLiteral= ruleINTLiteral EOF
480 {
481 newCompositeNode(grammarAccess.getINTLiteralRule());
482 pushFollow(FOLLOW_1);
483 iv_ruleINTLiteral=ruleINTLiteral();
484
485 state._fsp--;
486
487 current =iv_ruleINTLiteral.getText();
488 match(input,EOF,FOLLOW_2);
489
490 }
491
492 }
493
494 catch (RecognitionException re) {
495 recover(input,re);
496 appendSkippedTokens();
497 }
498 finally {
499 }
500 return current;
501 }
502 // $ANTLR end "entryRuleINTLiteral"
503
504
505 // $ANTLR start "ruleINTLiteral"
506 // InternalSolverLanguage.g:188:1: ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT ) ;
507 public final AntlrDatatypeRuleToken ruleINTLiteral() throws RecognitionException {
508 AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
509
510 Token kw=null;
511 Token this_INT_1=null;
512
513
514 enterRule();
515
516 try {
517 // InternalSolverLanguage.g:194:2: ( ( (kw= '-' )? this_INT_1= RULE_INT ) )
518 // InternalSolverLanguage.g:195:2: ( (kw= '-' )? this_INT_1= RULE_INT )
519 {
520 // InternalSolverLanguage.g:195:2: ( (kw= '-' )? this_INT_1= RULE_INT )
521 // InternalSolverLanguage.g:196:3: (kw= '-' )? this_INT_1= RULE_INT
522 {
523 // InternalSolverLanguage.g:196:3: (kw= '-' )?
524 int alt4=2;
525 int LA4_0 = input.LA(1);
526
527 if ( (LA4_0==11) ) {
528 alt4=1;
529 }
530 switch (alt4) {
531 case 1 :
532 // InternalSolverLanguage.g:197:4: kw= '-'
533 {
534 kw=(Token)match(input,11,FOLLOW_4);
535
536 current.merge(kw);
537 newLeafNode(kw, grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0());
538
539
540 }
541 break;
542
543 }
544
545 this_INT_1=(Token)match(input,RULE_INT,FOLLOW_2);
546
547 current.merge(this_INT_1);
548
549
550 newLeafNode(this_INT_1, grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1());
551
552
553 }
554
555
556 }
557
558
559 leaveRule();
560
561 }
562
563 catch (RecognitionException re) {
564 recover(input,re);
565 appendSkippedTokens();
566 }
567 finally {
568 }
569 return current;
570 }
571 // $ANTLR end "ruleINTLiteral"
572
573
574 // $ANTLR start "entryRuleBooleanValue"
575 // InternalSolverLanguage.g:214:1: entryRuleBooleanValue returns [EObject current=null] : iv_ruleBooleanValue= ruleBooleanValue EOF ;
576 public final EObject entryRuleBooleanValue() throws RecognitionException {
577 EObject current = null;
578
579 EObject iv_ruleBooleanValue = null;
580
581
582 try {
583 // InternalSolverLanguage.g:214:53: (iv_ruleBooleanValue= ruleBooleanValue EOF )
584 // InternalSolverLanguage.g:215:2: iv_ruleBooleanValue= ruleBooleanValue EOF
585 {
586 newCompositeNode(grammarAccess.getBooleanValueRule());
587 pushFollow(FOLLOW_1);
588 iv_ruleBooleanValue=ruleBooleanValue();
589
590 state._fsp--;
591
592 current =iv_ruleBooleanValue;
593 match(input,EOF,FOLLOW_2);
594
595 }
596
597 }
598
599 catch (RecognitionException re) {
600 recover(input,re);
601 appendSkippedTokens();
602 }
603 finally {
604 }
605 return current;
606 }
607 // $ANTLR end "entryRuleBooleanValue"
608
609
610 // $ANTLR start "ruleBooleanValue"
611 // InternalSolverLanguage.g:221:1: ruleBooleanValue returns [EObject current=null] : ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) ;
612 public final EObject ruleBooleanValue() throws RecognitionException {
613 EObject current = null;
614
615 Token otherlv_1=null;
616 Token otherlv_2=null;
617
618
619 enterRule();
620
621 try {
622 // InternalSolverLanguage.g:227:2: ( ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) )
623 // InternalSolverLanguage.g:228:2: ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) )
624 {
625 // InternalSolverLanguage.g:228:2: ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) )
626 int alt5=2;
627 int LA5_0 = input.LA(1);
628
629 if ( (LA5_0==13) ) {
630 alt5=1;
631 }
632 else if ( (LA5_0==14) ) {
633 alt5=2;
634 }
635 else {
636 NoViableAltException nvae =
637 new NoViableAltException("", 5, 0, input);
638
639 throw nvae;
640 }
641 switch (alt5) {
642 case 1 :
643 // InternalSolverLanguage.g:229:3: ( () otherlv_1= 'true' )
644 {
645 // InternalSolverLanguage.g:229:3: ( () otherlv_1= 'true' )
646 // InternalSolverLanguage.g:230:4: () otherlv_1= 'true'
647 {
648 // InternalSolverLanguage.g:230:4: ()
649 // InternalSolverLanguage.g:231:5:
650 {
651
652 current = forceCreateModelElement(
653 grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0(),
654 current);
655
656
657 }
658
659 otherlv_1=(Token)match(input,13,FOLLOW_2);
660
661 newLeafNode(otherlv_1, grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1());
662
663
664 }
665
666
667 }
668 break;
669 case 2 :
670 // InternalSolverLanguage.g:243:3: (otherlv_2= 'false' () )
671 {
672 // InternalSolverLanguage.g:243:3: (otherlv_2= 'false' () )
673 // InternalSolverLanguage.g:244:4: otherlv_2= 'false' ()
674 {
675 otherlv_2=(Token)match(input,14,FOLLOW_2);
676
677 newLeafNode(otherlv_2, grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0());
678
679 // InternalSolverLanguage.g:248:4: ()
680 // InternalSolverLanguage.g:249:5:
681 {
682
683 current = forceCreateModelElement(
684 grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1(),
685 current);
686
687
688 }
689
690
691 }
692
693
694 }
695 break;
696
697 }
698
699
700 }
701
702
703 leaveRule();
704
705 }
706
707 catch (RecognitionException re) {
708 recover(input,re);
709 appendSkippedTokens();
710 }
711 finally {
712 }
713 return current;
714 }
715 // $ANTLR end "ruleBooleanValue"
716
717
718 // $ANTLR start "entryRuleTruthValue"
719 // InternalSolverLanguage.g:260:1: entryRuleTruthValue returns [EObject current=null] : iv_ruleTruthValue= ruleTruthValue EOF ;
720 public final EObject entryRuleTruthValue() throws RecognitionException {
721 EObject current = null;
722
723 EObject iv_ruleTruthValue = null;
724
725
726 try {
727 // InternalSolverLanguage.g:260:51: (iv_ruleTruthValue= ruleTruthValue EOF )
728 // InternalSolverLanguage.g:261:2: iv_ruleTruthValue= ruleTruthValue EOF
729 {
730 newCompositeNode(grammarAccess.getTruthValueRule());
731 pushFollow(FOLLOW_1);
732 iv_ruleTruthValue=ruleTruthValue();
733
734 state._fsp--;
735
736 current =iv_ruleTruthValue;
737 match(input,EOF,FOLLOW_2);
738
739 }
740
741 }
742
743 catch (RecognitionException re) {
744 recover(input,re);
745 appendSkippedTokens();
746 }
747 finally {
748 }
749 return current;
750 }
751 // $ANTLR end "entryRuleTruthValue"
752
753
754 // $ANTLR start "ruleTruthValue"
755 // InternalSolverLanguage.g:267:1: ruleTruthValue returns [EObject current=null] : ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) ;
756 public final EObject ruleTruthValue() throws RecognitionException {
757 EObject current = null;
758
759 Token otherlv_1=null;
760 Token otherlv_3=null;
761 Token otherlv_5=null;
762 Token otherlv_7=null;
763
764
765 enterRule();
766
767 try {
768 // InternalSolverLanguage.g:273:2: ( ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) )
769 // InternalSolverLanguage.g:274:2: ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) )
770 {
771 // InternalSolverLanguage.g:274:2: ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) )
772 int alt6=4;
773 switch ( input.LA(1) ) {
774 case 13:
775 {
776 alt6=1;
777 }
778 break;
779 case 14:
780 {
781 alt6=2;
782 }
783 break;
784 case 15:
785 {
786 alt6=3;
787 }
788 break;
789 case 16:
790 {
791 alt6=4;
792 }
793 break;
794 default:
795 NoViableAltException nvae =
796 new NoViableAltException("", 6, 0, input);
797
798 throw nvae;
799 }
800
801 switch (alt6) {
802 case 1 :
803 // InternalSolverLanguage.g:275:3: ( () otherlv_1= 'true' )
804 {
805 // InternalSolverLanguage.g:275:3: ( () otherlv_1= 'true' )
806 // InternalSolverLanguage.g:276:4: () otherlv_1= 'true'
807 {
808 // InternalSolverLanguage.g:276:4: ()
809 // InternalSolverLanguage.g:277:5:
810 {
811
812 current = forceCreateModelElement(
813 grammarAccess.getTruthValueAccess().getTrueAction_0_0(),
814 current);
815
816
817 }
818
819 otherlv_1=(Token)match(input,13,FOLLOW_2);
820
821 newLeafNode(otherlv_1, grammarAccess.getTruthValueAccess().getTrueKeyword_0_1());
822
823
824 }
825
826
827 }
828 break;
829 case 2 :
830 // InternalSolverLanguage.g:289:3: ( () otherlv_3= 'false' )
831 {
832 // InternalSolverLanguage.g:289:3: ( () otherlv_3= 'false' )
833 // InternalSolverLanguage.g:290:4: () otherlv_3= 'false'
834 {
835 // InternalSolverLanguage.g:290:4: ()
836 // InternalSolverLanguage.g:291:5:
837 {
838
839 current = forceCreateModelElement(
840 grammarAccess.getTruthValueAccess().getFalseAction_1_0(),
841 current);
842
843
844 }
845
846 otherlv_3=(Token)match(input,14,FOLLOW_2);
847
848 newLeafNode(otherlv_3, grammarAccess.getTruthValueAccess().getFalseKeyword_1_1());
849
850
851 }
852
853
854 }
855 break;
856 case 3 :
857 // InternalSolverLanguage.g:303:3: ( () otherlv_5= 'unknown' )
858 {
859 // InternalSolverLanguage.g:303:3: ( () otherlv_5= 'unknown' )
860 // InternalSolverLanguage.g:304:4: () otherlv_5= 'unknown'
861 {
862 // InternalSolverLanguage.g:304:4: ()
863 // InternalSolverLanguage.g:305:5:
864 {
865
866 current = forceCreateModelElement(
867 grammarAccess.getTruthValueAccess().getUnknownAction_2_0(),
868 current);
869
870
871 }
872
873 otherlv_5=(Token)match(input,15,FOLLOW_2);
874
875 newLeafNode(otherlv_5, grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1());
876
877
878 }
879
880
881 }
882 break;
883 case 4 :
884 // InternalSolverLanguage.g:317:3: ( () otherlv_7= 'error' )
885 {
886 // InternalSolverLanguage.g:317:3: ( () otherlv_7= 'error' )
887 // InternalSolverLanguage.g:318:4: () otherlv_7= 'error'
888 {
889 // InternalSolverLanguage.g:318:4: ()
890 // InternalSolverLanguage.g:319:5:
891 {
892
893 current = forceCreateModelElement(
894 grammarAccess.getTruthValueAccess().getErrorAction_3_0(),
895 current);
896
897
898 }
899
900 otherlv_7=(Token)match(input,16,FOLLOW_2);
901
902 newLeafNode(otherlv_7, grammarAccess.getTruthValueAccess().getErrorKeyword_3_1());
903
904
905 }
906
907
908 }
909 break;
910
911 }
912
913
914 }
915
916
917 leaveRule();
918
919 }
920
921 catch (RecognitionException re) {
922 recover(input,re);
923 appendSkippedTokens();
924 }
925 finally {
926 }
927 return current;
928 }
929 // $ANTLR end "ruleTruthValue"
930
931
932 // $ANTLR start "entryRuleInterpretation"
933 // InternalSolverLanguage.g:334:1: entryRuleInterpretation returns [EObject current=null] : iv_ruleInterpretation= ruleInterpretation EOF ;
934 public final EObject entryRuleInterpretation() throws RecognitionException {
935 EObject current = null;
936
937 EObject iv_ruleInterpretation = null;
938
939
940 try {
941 // InternalSolverLanguage.g:334:55: (iv_ruleInterpretation= ruleInterpretation EOF )
942 // InternalSolverLanguage.g:335:2: iv_ruleInterpretation= ruleInterpretation EOF
943 {
944 newCompositeNode(grammarAccess.getInterpretationRule());
945 pushFollow(FOLLOW_1);
946 iv_ruleInterpretation=ruleInterpretation();
947
948 state._fsp--;
949
950 current =iv_ruleInterpretation;
951 match(input,EOF,FOLLOW_2);
952
953 }
954
955 }
956
957 catch (RecognitionException re) {
958 recover(input,re);
959 appendSkippedTokens();
960 }
961 finally {
962 }
963 return current;
964 }
965 // $ANTLR end "entryRuleInterpretation"
966
967
968 // $ANTLR start "ruleInterpretation"
969 // InternalSolverLanguage.g:341:1: ruleInterpretation returns [EObject current=null] : (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) ;
970 public final EObject ruleInterpretation() throws RecognitionException {
971 EObject current = null;
972
973 EObject this_BasicInterpretation_0 = null;
974
975 EObject this_DefaultInterpretation_1 = null;
976
977 EObject this_CDInterpretation_2 = null;
978
979
980
981 enterRule();
982
983 try {
984 // InternalSolverLanguage.g:347:2: ( (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) )
985 // InternalSolverLanguage.g:348:2: (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation )
986 {
987 // InternalSolverLanguage.g:348:2: (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation )
988 int alt7=3;
989 switch ( input.LA(1) ) {
990 case RULE_ID:
991 case 20:
992 case 21:
993 case 22:
994 case 23:
995 case 24:
996 case 25:
997 {
998 alt7=1;
999 }
1000 break;
1001 case 31:
1002 {
1003 alt7=2;
1004 }
1005 break;
1006 case 32:
1007 case 37:
1008 case 38:
1009 {
1010 alt7=3;
1011 }
1012 break;
1013 default:
1014 NoViableAltException nvae =
1015 new NoViableAltException("", 7, 0, input);
1016
1017 throw nvae;
1018 }
1019
1020 switch (alt7) {
1021 case 1 :
1022 // InternalSolverLanguage.g:349:3: this_BasicInterpretation_0= ruleBasicInterpretation
1023 {
1024
1025 newCompositeNode(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0());
1026
1027 pushFollow(FOLLOW_2);
1028 this_BasicInterpretation_0=ruleBasicInterpretation();
1029
1030 state._fsp--;
1031
1032
1033 current = this_BasicInterpretation_0;
1034 afterParserOrEnumRuleCall();
1035
1036
1037 }
1038 break;
1039 case 2 :
1040 // InternalSolverLanguage.g:358:3: this_DefaultInterpretation_1= ruleDefaultInterpretation
1041 {
1042
1043 newCompositeNode(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1());
1044
1045 pushFollow(FOLLOW_2);
1046 this_DefaultInterpretation_1=ruleDefaultInterpretation();
1047
1048 state._fsp--;
1049
1050
1051 current = this_DefaultInterpretation_1;
1052 afterParserOrEnumRuleCall();
1053
1054
1055 }
1056 break;
1057 case 3 :
1058 // InternalSolverLanguage.g:367:3: this_CDInterpretation_2= ruleCDInterpretation
1059 {
1060
1061 newCompositeNode(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2());
1062
1063 pushFollow(FOLLOW_2);
1064 this_CDInterpretation_2=ruleCDInterpretation();
1065
1066 state._fsp--;
1067
1068
1069 current = this_CDInterpretation_2;
1070 afterParserOrEnumRuleCall();
1071
1072
1073 }
1074 break;
1075
1076 }
1077
1078
1079 }
1080
1081
1082 leaveRule();
1083
1084 }
1085
1086 catch (RecognitionException re) {
1087 recover(input,re);
1088 appendSkippedTokens();
1089 }
1090 finally {
1091 }
1092 return current;
1093 }
1094 // $ANTLR end "ruleInterpretation"
1095
1096
1097 // $ANTLR start "entryRuleBasicInterpretation"
1098 // InternalSolverLanguage.g:379:1: entryRuleBasicInterpretation returns [EObject current=null] : iv_ruleBasicInterpretation= ruleBasicInterpretation EOF ;
1099 public final EObject entryRuleBasicInterpretation() throws RecognitionException {
1100 EObject current = null;
1101
1102 EObject iv_ruleBasicInterpretation = null;
1103
1104
1105 try {
1106 // InternalSolverLanguage.g:379:60: (iv_ruleBasicInterpretation= ruleBasicInterpretation EOF )
1107 // InternalSolverLanguage.g:380:2: iv_ruleBasicInterpretation= ruleBasicInterpretation EOF
1108 {
1109 newCompositeNode(grammarAccess.getBasicInterpretationRule());
1110 pushFollow(FOLLOW_1);
1111 iv_ruleBasicInterpretation=ruleBasicInterpretation();
1112
1113 state._fsp--;
1114
1115 current =iv_ruleBasicInterpretation;
1116 match(input,EOF,FOLLOW_2);
1117
1118 }
1119
1120 }
1121
1122 catch (RecognitionException re) {
1123 recover(input,re);
1124 appendSkippedTokens();
1125 }
1126 finally {
1127 }
1128 return current;
1129 }
1130 // $ANTLR end "entryRuleBasicInterpretation"
1131
1132
1133 // $ANTLR start "ruleBasicInterpretation"
1134 // InternalSolverLanguage.g:386:1: ruleBasicInterpretation returns [EObject current=null] : ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) ) ;
1135 public final EObject ruleBasicInterpretation() throws RecognitionException {
1136 EObject current = null;
1137
1138 Token otherlv_1=null;
1139 Token otherlv_3=null;
1140 Token otherlv_4=null;
1141 EObject lv_symbol_0_0 = null;
1142
1143 EObject lv_objects_2_0 = null;
1144
1145 EObject lv_value_5_0 = null;
1146
1147
1148
1149 enterRule();
1150
1151 try {
1152 // InternalSolverLanguage.g:392:2: ( ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) ) )
1153 // InternalSolverLanguage.g:393:2: ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) )
1154 {
1155 // InternalSolverLanguage.g:393:2: ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) )
1156 // InternalSolverLanguage.g:394:3: ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) )
1157 {
1158 // InternalSolverLanguage.g:394:3: ( (lv_symbol_0_0= ruleSymbol ) )
1159 // InternalSolverLanguage.g:395:4: (lv_symbol_0_0= ruleSymbol )
1160 {
1161 // InternalSolverLanguage.g:395:4: (lv_symbol_0_0= ruleSymbol )
1162 // InternalSolverLanguage.g:396:5: lv_symbol_0_0= ruleSymbol
1163 {
1164
1165 newCompositeNode(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0());
1166
1167 pushFollow(FOLLOW_6);
1168 lv_symbol_0_0=ruleSymbol();
1169
1170 state._fsp--;
1171
1172
1173 if (current==null) {
1174 current = createModelElementForParent(grammarAccess.getBasicInterpretationRule());
1175 }
1176 set(
1177 current,
1178 "symbol",
1179 lv_symbol_0_0,
1180 "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
1181 afterParserOrEnumRuleCall();
1182
1183
1184 }
1185
1186
1187 }
1188
1189 otherlv_1=(Token)match(input,17,FOLLOW_7);
1190
1191 newLeafNode(otherlv_1, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1());
1192
1193 // InternalSolverLanguage.g:417:3: ( (lv_objects_2_0= ruleComplexObject ) )*
1194 loop8:
1195 do {
1196 int alt8=2;
1197 int LA8_0 = input.LA(1);
1198
1199 if ( ((LA8_0>=RULE_INT && LA8_0<=RULE_STRING)||LA8_0==11||(LA8_0>=13 && LA8_0<=14)||LA8_0==19||LA8_0==26||LA8_0==30) ) {
1200 alt8=1;
1201 }
1202
1203
1204 switch (alt8) {
1205 case 1 :
1206 // InternalSolverLanguage.g:418:4: (lv_objects_2_0= ruleComplexObject )
1207 {
1208 // InternalSolverLanguage.g:418:4: (lv_objects_2_0= ruleComplexObject )
1209 // InternalSolverLanguage.g:419:5: lv_objects_2_0= ruleComplexObject
1210 {
1211
1212 newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_2_0());
1213
1214 pushFollow(FOLLOW_7);
1215 lv_objects_2_0=ruleComplexObject();
1216
1217 state._fsp--;
1218
1219
1220 if (current==null) {
1221 current = createModelElementForParent(grammarAccess.getBasicInterpretationRule());
1222 }
1223 add(
1224 current,
1225 "objects",
1226 lv_objects_2_0,
1227 "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject");
1228 afterParserOrEnumRuleCall();
1229
1230
1231 }
1232
1233
1234 }
1235 break;
1236
1237 default :
1238 break loop8;
1239 }
1240 } while (true);
1241
1242 otherlv_3=(Token)match(input,18,FOLLOW_8);
1243
1244 newLeafNode(otherlv_3, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_3());
1245
1246 otherlv_4=(Token)match(input,19,FOLLOW_9);
1247
1248 newLeafNode(otherlv_4, grammarAccess.getBasicInterpretationAccess().getColonKeyword_4());
1249
1250 // InternalSolverLanguage.g:444:3: ( (lv_value_5_0= ruleTruthValue ) )
1251 // InternalSolverLanguage.g:445:4: (lv_value_5_0= ruleTruthValue )
1252 {
1253 // InternalSolverLanguage.g:445:4: (lv_value_5_0= ruleTruthValue )
1254 // InternalSolverLanguage.g:446:5: lv_value_5_0= ruleTruthValue
1255 {
1256
1257 newCompositeNode(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_5_0());
1258
1259 pushFollow(FOLLOW_2);
1260 lv_value_5_0=ruleTruthValue();
1261
1262 state._fsp--;
1263
1264
1265 if (current==null) {
1266 current = createModelElementForParent(grammarAccess.getBasicInterpretationRule());
1267 }
1268 set(
1269 current,
1270 "value",
1271 lv_value_5_0,
1272 "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue");
1273 afterParserOrEnumRuleCall();
1274
1275
1276 }
1277
1278
1279 }
1280
1281
1282 }
1283
1284
1285 }
1286
1287
1288 leaveRule();
1289
1290 }
1291
1292 catch (RecognitionException re) {
1293 recover(input,re);
1294 appendSkippedTokens();
1295 }
1296 finally {
1297 }
1298 return current;
1299 }
1300 // $ANTLR end "ruleBasicInterpretation"
1301
1302
1303 // $ANTLR start "entryRuleSymbol"
1304 // InternalSolverLanguage.g:467:1: entryRuleSymbol returns [EObject current=null] : iv_ruleSymbol= ruleSymbol EOF ;
1305 public final EObject entryRuleSymbol() throws RecognitionException {
1306 EObject current = null;
1307
1308 EObject iv_ruleSymbol = null;
1309
1310
1311 try {
1312 // InternalSolverLanguage.g:467:47: (iv_ruleSymbol= ruleSymbol EOF )
1313 // InternalSolverLanguage.g:468:2: iv_ruleSymbol= ruleSymbol EOF
1314 {
1315 newCompositeNode(grammarAccess.getSymbolRule());
1316 pushFollow(FOLLOW_1);
1317 iv_ruleSymbol=ruleSymbol();
1318
1319 state._fsp--;
1320
1321 current =iv_ruleSymbol;
1322 match(input,EOF,FOLLOW_2);
1323
1324 }
1325
1326 }
1327
1328 catch (RecognitionException re) {
1329 recover(input,re);
1330 appendSkippedTokens();
1331 }
1332 finally {
1333 }
1334 return current;
1335 }
1336 // $ANTLR end "entryRuleSymbol"
1337
1338
1339 // $ANTLR start "ruleSymbol"
1340 // InternalSolverLanguage.g:474:1: ruleSymbol returns [EObject current=null] : (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) ;
1341 public final EObject ruleSymbol() throws RecognitionException {
1342 EObject current = null;
1343
1344 EObject this_ModelSymbol_0 = null;
1345
1346 EObject this_PartialitySymbol_1 = null;
1347
1348 EObject this_DataSymbol_2 = null;
1349
1350
1351
1352 enterRule();
1353
1354 try {
1355 // InternalSolverLanguage.g:480:2: ( (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) )
1356 // InternalSolverLanguage.g:481:2: (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol )
1357 {
1358 // InternalSolverLanguage.g:481:2: (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol )
1359 int alt9=3;
1360 switch ( input.LA(1) ) {
1361 case RULE_ID:
1362 {
1363 alt9=1;
1364 }
1365 break;
1366 case 20:
1367 case 21:
1368 {
1369 alt9=2;
1370 }
1371 break;
1372 case 22:
1373 case 23:
1374 case 24:
1375 case 25:
1376 {
1377 alt9=3;
1378 }
1379 break;
1380 default:
1381 NoViableAltException nvae =
1382 new NoViableAltException("", 9, 0, input);
1383
1384 throw nvae;
1385 }
1386
1387 switch (alt9) {
1388 case 1 :
1389 // InternalSolverLanguage.g:482:3: this_ModelSymbol_0= ruleModelSymbol
1390 {
1391
1392 newCompositeNode(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0());
1393
1394 pushFollow(FOLLOW_2);
1395 this_ModelSymbol_0=ruleModelSymbol();
1396
1397 state._fsp--;
1398
1399
1400 current = this_ModelSymbol_0;
1401 afterParserOrEnumRuleCall();
1402
1403
1404 }
1405 break;
1406 case 2 :
1407 // InternalSolverLanguage.g:491:3: this_PartialitySymbol_1= rulePartialitySymbol
1408 {
1409
1410 newCompositeNode(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1());
1411
1412 pushFollow(FOLLOW_2);
1413 this_PartialitySymbol_1=rulePartialitySymbol();
1414
1415 state._fsp--;
1416
1417
1418 current = this_PartialitySymbol_1;
1419 afterParserOrEnumRuleCall();
1420
1421
1422 }
1423 break;
1424 case 3 :
1425 // InternalSolverLanguage.g:500:3: this_DataSymbol_2= ruleDataSymbol
1426 {
1427
1428 newCompositeNode(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2());
1429
1430 pushFollow(FOLLOW_2);
1431 this_DataSymbol_2=ruleDataSymbol();
1432
1433 state._fsp--;
1434
1435
1436 current = this_DataSymbol_2;
1437 afterParserOrEnumRuleCall();
1438
1439
1440 }
1441 break;
1442
1443 }
1444
1445
1446 }
1447
1448
1449 leaveRule();
1450
1451 }
1452
1453 catch (RecognitionException re) {
1454 recover(input,re);
1455 appendSkippedTokens();
1456 }
1457 finally {
1458 }
1459 return current;
1460 }
1461 // $ANTLR end "ruleSymbol"
1462
1463
1464 // $ANTLR start "entryRuleModelSymbol"
1465 // InternalSolverLanguage.g:512:1: entryRuleModelSymbol returns [EObject current=null] : iv_ruleModelSymbol= ruleModelSymbol EOF ;
1466 public final EObject entryRuleModelSymbol() throws RecognitionException {
1467 EObject current = null;
1468
1469 EObject iv_ruleModelSymbol = null;
1470
1471
1472 try {
1473 // InternalSolverLanguage.g:512:52: (iv_ruleModelSymbol= ruleModelSymbol EOF )
1474 // InternalSolverLanguage.g:513:2: iv_ruleModelSymbol= ruleModelSymbol EOF
1475 {
1476 newCompositeNode(grammarAccess.getModelSymbolRule());
1477 pushFollow(FOLLOW_1);
1478 iv_ruleModelSymbol=ruleModelSymbol();
1479
1480 state._fsp--;
1481
1482 current =iv_ruleModelSymbol;
1483 match(input,EOF,FOLLOW_2);
1484
1485 }
1486
1487 }
1488
1489 catch (RecognitionException re) {
1490 recover(input,re);
1491 appendSkippedTokens();
1492 }
1493 finally {
1494 }
1495 return current;
1496 }
1497 // $ANTLR end "entryRuleModelSymbol"
1498
1499
1500 // $ANTLR start "ruleModelSymbol"
1501 // InternalSolverLanguage.g:519:1: ruleModelSymbol returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ;
1502 public final EObject ruleModelSymbol() throws RecognitionException {
1503 EObject current = null;
1504
1505 Token lv_name_0_0=null;
1506
1507
1508 enterRule();
1509
1510 try {
1511 // InternalSolverLanguage.g:525:2: ( ( (lv_name_0_0= RULE_ID ) ) )
1512 // InternalSolverLanguage.g:526:2: ( (lv_name_0_0= RULE_ID ) )
1513 {
1514 // InternalSolverLanguage.g:526:2: ( (lv_name_0_0= RULE_ID ) )
1515 // InternalSolverLanguage.g:527:3: (lv_name_0_0= RULE_ID )
1516 {
1517 // InternalSolverLanguage.g:527:3: (lv_name_0_0= RULE_ID )
1518 // InternalSolverLanguage.g:528:4: lv_name_0_0= RULE_ID
1519 {
1520 lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2);
1521
1522 newLeafNode(lv_name_0_0, grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0());
1523
1524
1525 if (current==null) {
1526 current = createModelElement(grammarAccess.getModelSymbolRule());
1527 }
1528 setWithLastConsumed(
1529 current,
1530 "name",
1531 lv_name_0_0,
1532 "org.eclipse.xtext.common.Terminals.ID");
1533
1534
1535 }
1536
1537
1538 }
1539
1540
1541 }
1542
1543
1544 leaveRule();
1545
1546 }
1547
1548 catch (RecognitionException re) {
1549 recover(input,re);
1550 appendSkippedTokens();
1551 }
1552 finally {
1553 }
1554 return current;
1555 }
1556 // $ANTLR end "ruleModelSymbol"
1557
1558
1559 // $ANTLR start "entryRulePartialitySymbol"
1560 // InternalSolverLanguage.g:547:1: entryRulePartialitySymbol returns [EObject current=null] : iv_rulePartialitySymbol= rulePartialitySymbol EOF ;
1561 public final EObject entryRulePartialitySymbol() throws RecognitionException {
1562 EObject current = null;
1563
1564 EObject iv_rulePartialitySymbol = null;
1565
1566
1567 try {
1568 // InternalSolverLanguage.g:547:57: (iv_rulePartialitySymbol= rulePartialitySymbol EOF )
1569 // InternalSolverLanguage.g:548:2: iv_rulePartialitySymbol= rulePartialitySymbol EOF
1570 {
1571 newCompositeNode(grammarAccess.getPartialitySymbolRule());
1572 pushFollow(FOLLOW_1);
1573 iv_rulePartialitySymbol=rulePartialitySymbol();
1574
1575 state._fsp--;
1576
1577 current =iv_rulePartialitySymbol;
1578 match(input,EOF,FOLLOW_2);
1579
1580 }
1581
1582 }
1583
1584 catch (RecognitionException re) {
1585 recover(input,re);
1586 appendSkippedTokens();
1587 }
1588 finally {
1589 }
1590 return current;
1591 }
1592 // $ANTLR end "entryRulePartialitySymbol"
1593
1594
1595 // $ANTLR start "rulePartialitySymbol"
1596 // InternalSolverLanguage.g:554:1: rulePartialitySymbol returns [EObject current=null] : (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) ;
1597 public final EObject rulePartialitySymbol() throws RecognitionException {
1598 EObject current = null;
1599
1600 EObject this_ExistSymbol_0 = null;
1601
1602 EObject this_EqualsSymbol_1 = null;
1603
1604
1605
1606 enterRule();
1607
1608 try {
1609 // InternalSolverLanguage.g:560:2: ( (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) )
1610 // InternalSolverLanguage.g:561:2: (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol )
1611 {
1612 // InternalSolverLanguage.g:561:2: (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol )
1613 int alt10=2;
1614 int LA10_0 = input.LA(1);
1615
1616 if ( (LA10_0==20) ) {
1617 alt10=1;
1618 }
1619 else if ( (LA10_0==21) ) {
1620 alt10=2;
1621 }
1622 else {
1623 NoViableAltException nvae =
1624 new NoViableAltException("", 10, 0, input);
1625
1626 throw nvae;
1627 }
1628 switch (alt10) {
1629 case 1 :
1630 // InternalSolverLanguage.g:562:3: this_ExistSymbol_0= ruleExistSymbol
1631 {
1632
1633 newCompositeNode(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0());
1634
1635 pushFollow(FOLLOW_2);
1636 this_ExistSymbol_0=ruleExistSymbol();
1637
1638 state._fsp--;
1639
1640
1641 current = this_ExistSymbol_0;
1642 afterParserOrEnumRuleCall();
1643
1644
1645 }
1646 break;
1647 case 2 :
1648 // InternalSolverLanguage.g:571:3: this_EqualsSymbol_1= ruleEqualsSymbol
1649 {
1650
1651 newCompositeNode(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1());
1652
1653 pushFollow(FOLLOW_2);
1654 this_EqualsSymbol_1=ruleEqualsSymbol();
1655
1656 state._fsp--;
1657
1658
1659 current = this_EqualsSymbol_1;
1660 afterParserOrEnumRuleCall();
1661
1662
1663 }
1664 break;
1665
1666 }
1667
1668
1669 }
1670
1671
1672 leaveRule();
1673
1674 }
1675
1676 catch (RecognitionException re) {
1677 recover(input,re);
1678 appendSkippedTokens();
1679 }
1680 finally {
1681 }
1682 return current;
1683 }
1684 // $ANTLR end "rulePartialitySymbol"
1685
1686
1687 // $ANTLR start "entryRuleExistSymbol"
1688 // InternalSolverLanguage.g:583:1: entryRuleExistSymbol returns [EObject current=null] : iv_ruleExistSymbol= ruleExistSymbol EOF ;
1689 public final EObject entryRuleExistSymbol() throws RecognitionException {
1690 EObject current = null;
1691
1692 EObject iv_ruleExistSymbol = null;
1693
1694
1695 try {
1696 // InternalSolverLanguage.g:583:52: (iv_ruleExistSymbol= ruleExistSymbol EOF )
1697 // InternalSolverLanguage.g:584:2: iv_ruleExistSymbol= ruleExistSymbol EOF
1698 {
1699 newCompositeNode(grammarAccess.getExistSymbolRule());
1700 pushFollow(FOLLOW_1);
1701 iv_ruleExistSymbol=ruleExistSymbol();
1702
1703 state._fsp--;
1704
1705 current =iv_ruleExistSymbol;
1706 match(input,EOF,FOLLOW_2);
1707
1708 }
1709
1710 }
1711
1712 catch (RecognitionException re) {
1713 recover(input,re);
1714 appendSkippedTokens();
1715 }
1716 finally {
1717 }
1718 return current;
1719 }
1720 // $ANTLR end "entryRuleExistSymbol"
1721
1722
1723 // $ANTLR start "ruleExistSymbol"
1724 // InternalSolverLanguage.g:590:1: ruleExistSymbol returns [EObject current=null] : (otherlv_0= 'exists' () ) ;
1725 public final EObject ruleExistSymbol() throws RecognitionException {
1726 EObject current = null;
1727
1728 Token otherlv_0=null;
1729
1730
1731 enterRule();
1732
1733 try {
1734 // InternalSolverLanguage.g:596:2: ( (otherlv_0= 'exists' () ) )
1735 // InternalSolverLanguage.g:597:2: (otherlv_0= 'exists' () )
1736 {
1737 // InternalSolverLanguage.g:597:2: (otherlv_0= 'exists' () )
1738 // InternalSolverLanguage.g:598:3: otherlv_0= 'exists' ()
1739 {
1740 otherlv_0=(Token)match(input,20,FOLLOW_2);
1741
1742 newLeafNode(otherlv_0, grammarAccess.getExistSymbolAccess().getExistsKeyword_0());
1743
1744 // InternalSolverLanguage.g:602:3: ()
1745 // InternalSolverLanguage.g:603:4:
1746 {
1747
1748 current = forceCreateModelElement(
1749 grammarAccess.getExistSymbolAccess().getExistSymbolAction_1(),
1750 current);
1751
1752
1753 }
1754
1755
1756 }
1757
1758
1759 }
1760
1761
1762 leaveRule();
1763
1764 }
1765
1766 catch (RecognitionException re) {
1767 recover(input,re);
1768 appendSkippedTokens();
1769 }
1770 finally {
1771 }
1772 return current;
1773 }
1774 // $ANTLR end "ruleExistSymbol"
1775
1776
1777 // $ANTLR start "entryRuleEqualsSymbol"
1778 // InternalSolverLanguage.g:613:1: entryRuleEqualsSymbol returns [EObject current=null] : iv_ruleEqualsSymbol= ruleEqualsSymbol EOF ;
1779 public final EObject entryRuleEqualsSymbol() throws RecognitionException {
1780 EObject current = null;
1781
1782 EObject iv_ruleEqualsSymbol = null;
1783
1784
1785 try {
1786 // InternalSolverLanguage.g:613:53: (iv_ruleEqualsSymbol= ruleEqualsSymbol EOF )
1787 // InternalSolverLanguage.g:614:2: iv_ruleEqualsSymbol= ruleEqualsSymbol EOF
1788 {
1789 newCompositeNode(grammarAccess.getEqualsSymbolRule());
1790 pushFollow(FOLLOW_1);
1791 iv_ruleEqualsSymbol=ruleEqualsSymbol();
1792
1793 state._fsp--;
1794
1795 current =iv_ruleEqualsSymbol;
1796 match(input,EOF,FOLLOW_2);
1797
1798 }
1799
1800 }
1801
1802 catch (RecognitionException re) {
1803 recover(input,re);
1804 appendSkippedTokens();
1805 }
1806 finally {
1807 }
1808 return current;
1809 }
1810 // $ANTLR end "entryRuleEqualsSymbol"
1811
1812
1813 // $ANTLR start "ruleEqualsSymbol"
1814 // InternalSolverLanguage.g:620:1: ruleEqualsSymbol returns [EObject current=null] : (otherlv_0= 'equals' () ) ;
1815 public final EObject ruleEqualsSymbol() throws RecognitionException {
1816 EObject current = null;
1817
1818 Token otherlv_0=null;
1819
1820
1821 enterRule();
1822
1823 try {
1824 // InternalSolverLanguage.g:626:2: ( (otherlv_0= 'equals' () ) )
1825 // InternalSolverLanguage.g:627:2: (otherlv_0= 'equals' () )
1826 {
1827 // InternalSolverLanguage.g:627:2: (otherlv_0= 'equals' () )
1828 // InternalSolverLanguage.g:628:3: otherlv_0= 'equals' ()
1829 {
1830 otherlv_0=(Token)match(input,21,FOLLOW_2);
1831
1832 newLeafNode(otherlv_0, grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0());
1833
1834 // InternalSolverLanguage.g:632:3: ()
1835 // InternalSolverLanguage.g:633:4:
1836 {
1837
1838 current = forceCreateModelElement(
1839 grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1(),
1840 current);
1841
1842
1843 }
1844
1845
1846 }
1847
1848
1849 }
1850
1851
1852 leaveRule();
1853
1854 }
1855
1856 catch (RecognitionException re) {
1857 recover(input,re);
1858 appendSkippedTokens();
1859 }
1860 finally {
1861 }
1862 return current;
1863 }
1864 // $ANTLR end "ruleEqualsSymbol"
1865
1866
1867 // $ANTLR start "entryRuleDataSymbol"
1868 // InternalSolverLanguage.g:643:1: entryRuleDataSymbol returns [EObject current=null] : iv_ruleDataSymbol= ruleDataSymbol EOF ;
1869 public final EObject entryRuleDataSymbol() throws RecognitionException {
1870 EObject current = null;
1871
1872 EObject iv_ruleDataSymbol = null;
1873
1874
1875 try {
1876 // InternalSolverLanguage.g:643:51: (iv_ruleDataSymbol= ruleDataSymbol EOF )
1877 // InternalSolverLanguage.g:644:2: iv_ruleDataSymbol= ruleDataSymbol EOF
1878 {
1879 newCompositeNode(grammarAccess.getDataSymbolRule());
1880 pushFollow(FOLLOW_1);
1881 iv_ruleDataSymbol=ruleDataSymbol();
1882
1883 state._fsp--;
1884
1885 current =iv_ruleDataSymbol;
1886 match(input,EOF,FOLLOW_2);
1887
1888 }
1889
1890 }
1891
1892 catch (RecognitionException re) {
1893 recover(input,re);
1894 appendSkippedTokens();
1895 }
1896 finally {
1897 }
1898 return current;
1899 }
1900 // $ANTLR end "entryRuleDataSymbol"
1901
1902
1903 // $ANTLR start "ruleDataSymbol"
1904 // InternalSolverLanguage.g:650:1: ruleDataSymbol returns [EObject current=null] : (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) ;
1905 public final EObject ruleDataSymbol() throws RecognitionException {
1906 EObject current = null;
1907
1908 EObject this_BooleanSymbol_0 = null;
1909
1910 EObject this_IntegerSymbol_1 = null;
1911
1912 EObject this_RealSymbol_2 = null;
1913
1914 EObject this_StringSymbol_3 = null;
1915
1916
1917
1918 enterRule();
1919
1920 try {
1921 // InternalSolverLanguage.g:656:2: ( (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) )
1922 // InternalSolverLanguage.g:657:2: (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol )
1923 {
1924 // InternalSolverLanguage.g:657:2: (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol )
1925 int alt11=4;
1926 switch ( input.LA(1) ) {
1927 case 22:
1928 {
1929 alt11=1;
1930 }
1931 break;
1932 case 23:
1933 {
1934 alt11=2;
1935 }
1936 break;
1937 case 24:
1938 {
1939 alt11=3;
1940 }
1941 break;
1942 case 25:
1943 {
1944 alt11=4;
1945 }
1946 break;
1947 default:
1948 NoViableAltException nvae =
1949 new NoViableAltException("", 11, 0, input);
1950
1951 throw nvae;
1952 }
1953
1954 switch (alt11) {
1955 case 1 :
1956 // InternalSolverLanguage.g:658:3: this_BooleanSymbol_0= ruleBooleanSymbol
1957 {
1958
1959 newCompositeNode(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0());
1960
1961 pushFollow(FOLLOW_2);
1962 this_BooleanSymbol_0=ruleBooleanSymbol();
1963
1964 state._fsp--;
1965
1966
1967 current = this_BooleanSymbol_0;
1968 afterParserOrEnumRuleCall();
1969
1970
1971 }
1972 break;
1973 case 2 :
1974 // InternalSolverLanguage.g:667:3: this_IntegerSymbol_1= ruleIntegerSymbol
1975 {
1976
1977 newCompositeNode(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1());
1978
1979 pushFollow(FOLLOW_2);
1980 this_IntegerSymbol_1=ruleIntegerSymbol();
1981
1982 state._fsp--;
1983
1984
1985 current = this_IntegerSymbol_1;
1986 afterParserOrEnumRuleCall();
1987
1988
1989 }
1990 break;
1991 case 3 :
1992 // InternalSolverLanguage.g:676:3: this_RealSymbol_2= ruleRealSymbol
1993 {
1994
1995 newCompositeNode(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2());
1996
1997 pushFollow(FOLLOW_2);
1998 this_RealSymbol_2=ruleRealSymbol();
1999
2000 state._fsp--;
2001
2002
2003 current = this_RealSymbol_2;
2004 afterParserOrEnumRuleCall();
2005
2006
2007 }
2008 break;
2009 case 4 :
2010 // InternalSolverLanguage.g:685:3: this_StringSymbol_3= ruleStringSymbol
2011 {
2012
2013 newCompositeNode(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3());
2014
2015 pushFollow(FOLLOW_2);
2016 this_StringSymbol_3=ruleStringSymbol();
2017
2018 state._fsp--;
2019
2020
2021 current = this_StringSymbol_3;
2022 afterParserOrEnumRuleCall();
2023
2024
2025 }
2026 break;
2027
2028 }
2029
2030
2031 }
2032
2033
2034 leaveRule();
2035
2036 }
2037
2038 catch (RecognitionException re) {
2039 recover(input,re);
2040 appendSkippedTokens();
2041 }
2042 finally {
2043 }
2044 return current;
2045 }
2046 // $ANTLR end "ruleDataSymbol"
2047
2048
2049 // $ANTLR start "entryRuleBooleanSymbol"
2050 // InternalSolverLanguage.g:697:1: entryRuleBooleanSymbol returns [EObject current=null] : iv_ruleBooleanSymbol= ruleBooleanSymbol EOF ;
2051 public final EObject entryRuleBooleanSymbol() throws RecognitionException {
2052 EObject current = null;
2053
2054 EObject iv_ruleBooleanSymbol = null;
2055
2056
2057 try {
2058 // InternalSolverLanguage.g:697:54: (iv_ruleBooleanSymbol= ruleBooleanSymbol EOF )
2059 // InternalSolverLanguage.g:698:2: iv_ruleBooleanSymbol= ruleBooleanSymbol EOF
2060 {
2061 newCompositeNode(grammarAccess.getBooleanSymbolRule());
2062 pushFollow(FOLLOW_1);
2063 iv_ruleBooleanSymbol=ruleBooleanSymbol();
2064
2065 state._fsp--;
2066
2067 current =iv_ruleBooleanSymbol;
2068 match(input,EOF,FOLLOW_2);
2069
2070 }
2071
2072 }
2073
2074 catch (RecognitionException re) {
2075 recover(input,re);
2076 appendSkippedTokens();
2077 }
2078 finally {
2079 }
2080 return current;
2081 }
2082 // $ANTLR end "entryRuleBooleanSymbol"
2083
2084
2085 // $ANTLR start "ruleBooleanSymbol"
2086 // InternalSolverLanguage.g:704:1: ruleBooleanSymbol returns [EObject current=null] : (otherlv_0= 'bool' () ) ;
2087 public final EObject ruleBooleanSymbol() throws RecognitionException {
2088 EObject current = null;
2089
2090 Token otherlv_0=null;
2091
2092
2093 enterRule();
2094
2095 try {
2096 // InternalSolverLanguage.g:710:2: ( (otherlv_0= 'bool' () ) )
2097 // InternalSolverLanguage.g:711:2: (otherlv_0= 'bool' () )
2098 {
2099 // InternalSolverLanguage.g:711:2: (otherlv_0= 'bool' () )
2100 // InternalSolverLanguage.g:712:3: otherlv_0= 'bool' ()
2101 {
2102 otherlv_0=(Token)match(input,22,FOLLOW_2);
2103
2104 newLeafNode(otherlv_0, grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0());
2105
2106 // InternalSolverLanguage.g:716:3: ()
2107 // InternalSolverLanguage.g:717:4:
2108 {
2109
2110 current = forceCreateModelElement(
2111 grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1(),
2112 current);
2113
2114
2115 }
2116
2117
2118 }
2119
2120
2121 }
2122
2123
2124 leaveRule();
2125
2126 }
2127
2128 catch (RecognitionException re) {
2129 recover(input,re);
2130 appendSkippedTokens();
2131 }
2132 finally {
2133 }
2134 return current;
2135 }
2136 // $ANTLR end "ruleBooleanSymbol"
2137
2138
2139 // $ANTLR start "entryRuleIntegerSymbol"
2140 // InternalSolverLanguage.g:727:1: entryRuleIntegerSymbol returns [EObject current=null] : iv_ruleIntegerSymbol= ruleIntegerSymbol EOF ;
2141 public final EObject entryRuleIntegerSymbol() throws RecognitionException {
2142 EObject current = null;
2143
2144 EObject iv_ruleIntegerSymbol = null;
2145
2146
2147 try {
2148 // InternalSolverLanguage.g:727:54: (iv_ruleIntegerSymbol= ruleIntegerSymbol EOF )
2149 // InternalSolverLanguage.g:728:2: iv_ruleIntegerSymbol= ruleIntegerSymbol EOF
2150 {
2151 newCompositeNode(grammarAccess.getIntegerSymbolRule());
2152 pushFollow(FOLLOW_1);
2153 iv_ruleIntegerSymbol=ruleIntegerSymbol();
2154
2155 state._fsp--;
2156
2157 current =iv_ruleIntegerSymbol;
2158 match(input,EOF,FOLLOW_2);
2159
2160 }
2161
2162 }
2163
2164 catch (RecognitionException re) {
2165 recover(input,re);
2166 appendSkippedTokens();
2167 }
2168 finally {
2169 }
2170 return current;
2171 }
2172 // $ANTLR end "entryRuleIntegerSymbol"
2173
2174
2175 // $ANTLR start "ruleIntegerSymbol"
2176 // InternalSolverLanguage.g:734:1: ruleIntegerSymbol returns [EObject current=null] : (otherlv_0= 'int' () ) ;
2177 public final EObject ruleIntegerSymbol() throws RecognitionException {
2178 EObject current = null;
2179
2180 Token otherlv_0=null;
2181
2182
2183 enterRule();
2184
2185 try {
2186 // InternalSolverLanguage.g:740:2: ( (otherlv_0= 'int' () ) )
2187 // InternalSolverLanguage.g:741:2: (otherlv_0= 'int' () )
2188 {
2189 // InternalSolverLanguage.g:741:2: (otherlv_0= 'int' () )
2190 // InternalSolverLanguage.g:742:3: otherlv_0= 'int' ()
2191 {
2192 otherlv_0=(Token)match(input,23,FOLLOW_2);
2193
2194 newLeafNode(otherlv_0, grammarAccess.getIntegerSymbolAccess().getIntKeyword_0());
2195
2196 // InternalSolverLanguage.g:746:3: ()
2197 // InternalSolverLanguage.g:747:4:
2198 {
2199
2200 current = forceCreateModelElement(
2201 grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1(),
2202 current);
2203
2204
2205 }
2206
2207
2208 }
2209
2210
2211 }
2212
2213
2214 leaveRule();
2215
2216 }
2217
2218 catch (RecognitionException re) {
2219 recover(input,re);
2220 appendSkippedTokens();
2221 }
2222 finally {
2223 }
2224 return current;
2225 }
2226 // $ANTLR end "ruleIntegerSymbol"
2227
2228
2229 // $ANTLR start "entryRuleRealSymbol"
2230 // InternalSolverLanguage.g:757:1: entryRuleRealSymbol returns [EObject current=null] : iv_ruleRealSymbol= ruleRealSymbol EOF ;
2231 public final EObject entryRuleRealSymbol() throws RecognitionException {
2232 EObject current = null;
2233
2234 EObject iv_ruleRealSymbol = null;
2235
2236
2237 try {
2238 // InternalSolverLanguage.g:757:51: (iv_ruleRealSymbol= ruleRealSymbol EOF )
2239 // InternalSolverLanguage.g:758:2: iv_ruleRealSymbol= ruleRealSymbol EOF
2240 {
2241 newCompositeNode(grammarAccess.getRealSymbolRule());
2242 pushFollow(FOLLOW_1);
2243 iv_ruleRealSymbol=ruleRealSymbol();
2244
2245 state._fsp--;
2246
2247 current =iv_ruleRealSymbol;
2248 match(input,EOF,FOLLOW_2);
2249
2250 }
2251
2252 }
2253
2254 catch (RecognitionException re) {
2255 recover(input,re);
2256 appendSkippedTokens();
2257 }
2258 finally {
2259 }
2260 return current;
2261 }
2262 // $ANTLR end "entryRuleRealSymbol"
2263
2264
2265 // $ANTLR start "ruleRealSymbol"
2266 // InternalSolverLanguage.g:764:1: ruleRealSymbol returns [EObject current=null] : (otherlv_0= 'real' () ) ;
2267 public final EObject ruleRealSymbol() throws RecognitionException {
2268 EObject current = null;
2269
2270 Token otherlv_0=null;
2271
2272
2273 enterRule();
2274
2275 try {
2276 // InternalSolverLanguage.g:770:2: ( (otherlv_0= 'real' () ) )
2277 // InternalSolverLanguage.g:771:2: (otherlv_0= 'real' () )
2278 {
2279 // InternalSolverLanguage.g:771:2: (otherlv_0= 'real' () )
2280 // InternalSolverLanguage.g:772:3: otherlv_0= 'real' ()
2281 {
2282 otherlv_0=(Token)match(input,24,FOLLOW_2);
2283
2284 newLeafNode(otherlv_0, grammarAccess.getRealSymbolAccess().getRealKeyword_0());
2285
2286 // InternalSolverLanguage.g:776:3: ()
2287 // InternalSolverLanguage.g:777:4:
2288 {
2289
2290 current = forceCreateModelElement(
2291 grammarAccess.getRealSymbolAccess().getRealSymbolAction_1(),
2292 current);
2293
2294
2295 }
2296
2297
2298 }
2299
2300
2301 }
2302
2303
2304 leaveRule();
2305
2306 }
2307
2308 catch (RecognitionException re) {
2309 recover(input,re);
2310 appendSkippedTokens();
2311 }
2312 finally {
2313 }
2314 return current;
2315 }
2316 // $ANTLR end "ruleRealSymbol"
2317
2318
2319 // $ANTLR start "entryRuleStringSymbol"
2320 // InternalSolverLanguage.g:787:1: entryRuleStringSymbol returns [EObject current=null] : iv_ruleStringSymbol= ruleStringSymbol EOF ;
2321 public final EObject entryRuleStringSymbol() throws RecognitionException {
2322 EObject current = null;
2323
2324 EObject iv_ruleStringSymbol = null;
2325
2326
2327 try {
2328 // InternalSolverLanguage.g:787:53: (iv_ruleStringSymbol= ruleStringSymbol EOF )
2329 // InternalSolverLanguage.g:788:2: iv_ruleStringSymbol= ruleStringSymbol EOF
2330 {
2331 newCompositeNode(grammarAccess.getStringSymbolRule());
2332 pushFollow(FOLLOW_1);
2333 iv_ruleStringSymbol=ruleStringSymbol();
2334
2335 state._fsp--;
2336
2337 current =iv_ruleStringSymbol;
2338 match(input,EOF,FOLLOW_2);
2339
2340 }
2341
2342 }
2343
2344 catch (RecognitionException re) {
2345 recover(input,re);
2346 appendSkippedTokens();
2347 }
2348 finally {
2349 }
2350 return current;
2351 }
2352 // $ANTLR end "entryRuleStringSymbol"
2353
2354
2355 // $ANTLR start "ruleStringSymbol"
2356 // InternalSolverLanguage.g:794:1: ruleStringSymbol returns [EObject current=null] : (otherlv_0= 'string' () ) ;
2357 public final EObject ruleStringSymbol() throws RecognitionException {
2358 EObject current = null;
2359
2360 Token otherlv_0=null;
2361
2362
2363 enterRule();
2364
2365 try {
2366 // InternalSolverLanguage.g:800:2: ( (otherlv_0= 'string' () ) )
2367 // InternalSolverLanguage.g:801:2: (otherlv_0= 'string' () )
2368 {
2369 // InternalSolverLanguage.g:801:2: (otherlv_0= 'string' () )
2370 // InternalSolverLanguage.g:802:3: otherlv_0= 'string' ()
2371 {
2372 otherlv_0=(Token)match(input,25,FOLLOW_2);
2373
2374 newLeafNode(otherlv_0, grammarAccess.getStringSymbolAccess().getStringKeyword_0());
2375
2376 // InternalSolverLanguage.g:806:3: ()
2377 // InternalSolverLanguage.g:807:4:
2378 {
2379
2380 current = forceCreateModelElement(
2381 grammarAccess.getStringSymbolAccess().getStringSymbolAction_1(),
2382 current);
2383
2384
2385 }
2386
2387
2388 }
2389
2390
2391 }
2392
2393
2394 leaveRule();
2395
2396 }
2397
2398 catch (RecognitionException re) {
2399 recover(input,re);
2400 appendSkippedTokens();
2401 }
2402 finally {
2403 }
2404 return current;
2405 }
2406 // $ANTLR end "ruleStringSymbol"
2407
2408
2409 // $ANTLR start "entryRuleComplexObject"
2410 // InternalSolverLanguage.g:817:1: entryRuleComplexObject returns [EObject current=null] : iv_ruleComplexObject= ruleComplexObject EOF ;
2411 public final EObject entryRuleComplexObject() throws RecognitionException {
2412 EObject current = null;
2413
2414 EObject iv_ruleComplexObject = null;
2415
2416
2417 try {
2418 // InternalSolverLanguage.g:817:54: (iv_ruleComplexObject= ruleComplexObject EOF )
2419 // InternalSolverLanguage.g:818:2: iv_ruleComplexObject= ruleComplexObject EOF
2420 {
2421 newCompositeNode(grammarAccess.getComplexObjectRule());
2422 pushFollow(FOLLOW_1);
2423 iv_ruleComplexObject=ruleComplexObject();
2424
2425 state._fsp--;
2426
2427 current =iv_ruleComplexObject;
2428 match(input,EOF,FOLLOW_2);
2429
2430 }
2431
2432 }
2433
2434 catch (RecognitionException re) {
2435 recover(input,re);
2436 appendSkippedTokens();
2437 }
2438 finally {
2439 }
2440 return current;
2441 }
2442 // $ANTLR end "entryRuleComplexObject"
2443
2444
2445 // $ANTLR start "ruleComplexObject"
2446 // InternalSolverLanguage.g:824:1: ruleComplexObject returns [EObject current=null] : (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) ;
2447 public final EObject ruleComplexObject() throws RecognitionException {
2448 EObject current = null;
2449
2450 EObject this_Object_0 = null;
2451
2452 EObject this_AllInstances_1 = null;
2453
2454 EObject this_AllObjects_2 = null;
2455
2456
2457
2458 enterRule();
2459
2460 try {
2461 // InternalSolverLanguage.g:830:2: ( (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) )
2462 // InternalSolverLanguage.g:831:2: (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects )
2463 {
2464 // InternalSolverLanguage.g:831:2: (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects )
2465 int alt12=3;
2466 switch ( input.LA(1) ) {
2467 case RULE_INT:
2468 case RULE_ID:
2469 case RULE_STRING:
2470 case 11:
2471 case 13:
2472 case 14:
2473 case 26:
2474 {
2475 alt12=1;
2476 }
2477 break;
2478 case 19:
2479 {
2480 alt12=2;
2481 }
2482 break;
2483 case 30:
2484 {
2485 alt12=3;
2486 }
2487 break;
2488 default:
2489 NoViableAltException nvae =
2490 new NoViableAltException("", 12, 0, input);
2491
2492 throw nvae;
2493 }
2494
2495 switch (alt12) {
2496 case 1 :
2497 // InternalSolverLanguage.g:832:3: this_Object_0= ruleObject
2498 {
2499
2500 newCompositeNode(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0());
2501
2502 pushFollow(FOLLOW_2);
2503 this_Object_0=ruleObject();
2504
2505 state._fsp--;
2506
2507
2508 current = this_Object_0;
2509 afterParserOrEnumRuleCall();
2510
2511
2512 }
2513 break;
2514 case 2 :
2515 // InternalSolverLanguage.g:841:3: this_AllInstances_1= ruleAllInstances
2516 {
2517
2518 newCompositeNode(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1());
2519
2520 pushFollow(FOLLOW_2);
2521 this_AllInstances_1=ruleAllInstances();
2522
2523 state._fsp--;
2524
2525
2526 current = this_AllInstances_1;
2527 afterParserOrEnumRuleCall();
2528
2529
2530 }
2531 break;
2532 case 3 :
2533 // InternalSolverLanguage.g:850:3: this_AllObjects_2= ruleAllObjects
2534 {
2535
2536 newCompositeNode(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2());
2537
2538 pushFollow(FOLLOW_2);
2539 this_AllObjects_2=ruleAllObjects();
2540
2541 state._fsp--;
2542
2543
2544 current = this_AllObjects_2;
2545 afterParserOrEnumRuleCall();
2546
2547
2548 }
2549 break;
2550
2551 }
2552
2553
2554 }
2555
2556
2557 leaveRule();
2558
2559 }
2560
2561 catch (RecognitionException re) {
2562 recover(input,re);
2563 appendSkippedTokens();
2564 }
2565 finally {
2566 }
2567 return current;
2568 }
2569 // $ANTLR end "ruleComplexObject"
2570
2571
2572 // $ANTLR start "entryRuleObject"
2573 // InternalSolverLanguage.g:862:1: entryRuleObject returns [EObject current=null] : iv_ruleObject= ruleObject EOF ;
2574 public final EObject entryRuleObject() throws RecognitionException {
2575 EObject current = null;
2576
2577 EObject iv_ruleObject = null;
2578
2579
2580 try {
2581 // InternalSolverLanguage.g:862:47: (iv_ruleObject= ruleObject EOF )
2582 // InternalSolverLanguage.g:863:2: iv_ruleObject= ruleObject EOF
2583 {
2584 newCompositeNode(grammarAccess.getObjectRule());
2585 pushFollow(FOLLOW_1);
2586 iv_ruleObject=ruleObject();
2587
2588 state._fsp--;
2589
2590 current =iv_ruleObject;
2591 match(input,EOF,FOLLOW_2);
2592
2593 }
2594
2595 }
2596
2597 catch (RecognitionException re) {
2598 recover(input,re);
2599 appendSkippedTokens();
2600 }
2601 finally {
2602 }
2603 return current;
2604 }
2605 // $ANTLR end "entryRuleObject"
2606
2607
2608 // $ANTLR start "ruleObject"
2609 // InternalSolverLanguage.g:869:1: ruleObject returns [EObject current=null] : (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) ;
2610 public final EObject ruleObject() throws RecognitionException {
2611 EObject current = null;
2612
2613 EObject this_NamedObject_0 = null;
2614
2615 EObject this_UnnamedObject_1 = null;
2616
2617 EObject this_DataObject_2 = null;
2618
2619
2620
2621 enterRule();
2622
2623 try {
2624 // InternalSolverLanguage.g:875:2: ( (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) )
2625 // InternalSolverLanguage.g:876:2: (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject )
2626 {
2627 // InternalSolverLanguage.g:876:2: (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject )
2628 int alt13=3;
2629 switch ( input.LA(1) ) {
2630 case 26:
2631 {
2632 alt13=1;
2633 }
2634 break;
2635 case RULE_ID:
2636 {
2637 alt13=2;
2638 }
2639 break;
2640 case RULE_INT:
2641 case RULE_STRING:
2642 case 11:
2643 case 13:
2644 case 14:
2645 {
2646 alt13=3;
2647 }
2648 break;
2649 default:
2650 NoViableAltException nvae =
2651 new NoViableAltException("", 13, 0, input);
2652
2653 throw nvae;
2654 }
2655
2656 switch (alt13) {
2657 case 1 :
2658 // InternalSolverLanguage.g:877:3: this_NamedObject_0= ruleNamedObject
2659 {
2660
2661 newCompositeNode(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0());
2662
2663 pushFollow(FOLLOW_2);
2664 this_NamedObject_0=ruleNamedObject();
2665
2666 state._fsp--;
2667
2668
2669 current = this_NamedObject_0;
2670 afterParserOrEnumRuleCall();
2671
2672
2673 }
2674 break;
2675 case 2 :
2676 // InternalSolverLanguage.g:886:3: this_UnnamedObject_1= ruleUnnamedObject
2677 {
2678
2679 newCompositeNode(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1());
2680
2681 pushFollow(FOLLOW_2);
2682 this_UnnamedObject_1=ruleUnnamedObject();
2683
2684 state._fsp--;
2685
2686
2687 current = this_UnnamedObject_1;
2688 afterParserOrEnumRuleCall();
2689
2690
2691 }
2692 break;
2693 case 3 :
2694 // InternalSolverLanguage.g:895:3: this_DataObject_2= ruleDataObject
2695 {
2696
2697 newCompositeNode(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2());
2698
2699 pushFollow(FOLLOW_2);
2700 this_DataObject_2=ruleDataObject();
2701
2702 state._fsp--;
2703
2704
2705 current = this_DataObject_2;
2706 afterParserOrEnumRuleCall();
2707
2708
2709 }
2710 break;
2711
2712 }
2713
2714
2715 }
2716
2717
2718 leaveRule();
2719
2720 }
2721
2722 catch (RecognitionException re) {
2723 recover(input,re);
2724 appendSkippedTokens();
2725 }
2726 finally {
2727 }
2728 return current;
2729 }
2730 // $ANTLR end "ruleObject"
2731
2732
2733 // $ANTLR start "entryRuleNamedObject"
2734 // InternalSolverLanguage.g:907:1: entryRuleNamedObject returns [EObject current=null] : iv_ruleNamedObject= ruleNamedObject EOF ;
2735 public final EObject entryRuleNamedObject() throws RecognitionException {
2736 EObject current = null;
2737
2738 EObject iv_ruleNamedObject = null;
2739
2740
2741 try {
2742 // InternalSolverLanguage.g:907:52: (iv_ruleNamedObject= ruleNamedObject EOF )
2743 // InternalSolverLanguage.g:908:2: iv_ruleNamedObject= ruleNamedObject EOF
2744 {
2745 newCompositeNode(grammarAccess.getNamedObjectRule());
2746 pushFollow(FOLLOW_1);
2747 iv_ruleNamedObject=ruleNamedObject();
2748
2749 state._fsp--;
2750
2751 current =iv_ruleNamedObject;
2752 match(input,EOF,FOLLOW_2);
2753
2754 }
2755
2756 }
2757
2758 catch (RecognitionException re) {
2759 recover(input,re);
2760 appendSkippedTokens();
2761 }
2762 finally {
2763 }
2764 return current;
2765 }
2766 // $ANTLR end "entryRuleNamedObject"
2767
2768
2769 // $ANTLR start "ruleNamedObject"
2770 // InternalSolverLanguage.g:914:1: ruleNamedObject returns [EObject current=null] : (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) ;
2771 public final EObject ruleNamedObject() throws RecognitionException {
2772 EObject current = null;
2773
2774 Token otherlv_0=null;
2775 Token lv_name_1_0=null;
2776 Token otherlv_2=null;
2777
2778
2779 enterRule();
2780
2781 try {
2782 // InternalSolverLanguage.g:920:2: ( (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) )
2783 // InternalSolverLanguage.g:921:2: (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' )
2784 {
2785 // InternalSolverLanguage.g:921:2: (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' )
2786 // InternalSolverLanguage.g:922:3: otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\''
2787 {
2788 otherlv_0=(Token)match(input,26,FOLLOW_10);
2789
2790 newLeafNode(otherlv_0, grammarAccess.getNamedObjectAccess().getApostropheKeyword_0());
2791
2792 // InternalSolverLanguage.g:926:3: ( (lv_name_1_0= RULE_ID ) )
2793 // InternalSolverLanguage.g:927:4: (lv_name_1_0= RULE_ID )
2794 {
2795 // InternalSolverLanguage.g:927:4: (lv_name_1_0= RULE_ID )
2796 // InternalSolverLanguage.g:928:5: lv_name_1_0= RULE_ID
2797 {
2798 lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_11);
2799
2800 newLeafNode(lv_name_1_0, grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0());
2801
2802
2803 if (current==null) {
2804 current = createModelElement(grammarAccess.getNamedObjectRule());
2805 }
2806 setWithLastConsumed(
2807 current,
2808 "name",
2809 lv_name_1_0,
2810 "org.eclipse.xtext.common.Terminals.ID");
2811
2812
2813 }
2814
2815
2816 }
2817
2818 otherlv_2=(Token)match(input,26,FOLLOW_2);
2819
2820 newLeafNode(otherlv_2, grammarAccess.getNamedObjectAccess().getApostropheKeyword_2());
2821
2822
2823 }
2824
2825
2826 }
2827
2828
2829 leaveRule();
2830
2831 }
2832
2833 catch (RecognitionException re) {
2834 recover(input,re);
2835 appendSkippedTokens();
2836 }
2837 finally {
2838 }
2839 return current;
2840 }
2841 // $ANTLR end "ruleNamedObject"
2842
2843
2844 // $ANTLR start "entryRuleUnnamedObject"
2845 // InternalSolverLanguage.g:952:1: entryRuleUnnamedObject returns [EObject current=null] : iv_ruleUnnamedObject= ruleUnnamedObject EOF ;
2846 public final EObject entryRuleUnnamedObject() throws RecognitionException {
2847 EObject current = null;
2848
2849 EObject iv_ruleUnnamedObject = null;
2850
2851
2852 try {
2853 // InternalSolverLanguage.g:952:54: (iv_ruleUnnamedObject= ruleUnnamedObject EOF )
2854 // InternalSolverLanguage.g:953:2: iv_ruleUnnamedObject= ruleUnnamedObject EOF
2855 {
2856 newCompositeNode(grammarAccess.getUnnamedObjectRule());
2857 pushFollow(FOLLOW_1);
2858 iv_ruleUnnamedObject=ruleUnnamedObject();
2859
2860 state._fsp--;
2861
2862 current =iv_ruleUnnamedObject;
2863 match(input,EOF,FOLLOW_2);
2864
2865 }
2866
2867 }
2868
2869 catch (RecognitionException re) {
2870 recover(input,re);
2871 appendSkippedTokens();
2872 }
2873 finally {
2874 }
2875 return current;
2876 }
2877 // $ANTLR end "entryRuleUnnamedObject"
2878
2879
2880 // $ANTLR start "ruleUnnamedObject"
2881 // InternalSolverLanguage.g:959:1: ruleUnnamedObject returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ;
2882 public final EObject ruleUnnamedObject() throws RecognitionException {
2883 EObject current = null;
2884
2885 Token lv_name_0_0=null;
2886
2887
2888 enterRule();
2889
2890 try {
2891 // InternalSolverLanguage.g:965:2: ( ( (lv_name_0_0= RULE_ID ) ) )
2892 // InternalSolverLanguage.g:966:2: ( (lv_name_0_0= RULE_ID ) )
2893 {
2894 // InternalSolverLanguage.g:966:2: ( (lv_name_0_0= RULE_ID ) )
2895 // InternalSolverLanguage.g:967:3: (lv_name_0_0= RULE_ID )
2896 {
2897 // InternalSolverLanguage.g:967:3: (lv_name_0_0= RULE_ID )
2898 // InternalSolverLanguage.g:968:4: lv_name_0_0= RULE_ID
2899 {
2900 lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2);
2901
2902 newLeafNode(lv_name_0_0, grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0());
2903
2904
2905 if (current==null) {
2906 current = createModelElement(grammarAccess.getUnnamedObjectRule());
2907 }
2908 setWithLastConsumed(
2909 current,
2910 "name",
2911 lv_name_0_0,
2912 "org.eclipse.xtext.common.Terminals.ID");
2913
2914
2915 }
2916
2917
2918 }
2919
2920
2921 }
2922
2923
2924 leaveRule();
2925
2926 }
2927
2928 catch (RecognitionException re) {
2929 recover(input,re);
2930 appendSkippedTokens();
2931 }
2932 finally {
2933 }
2934 return current;
2935 }
2936 // $ANTLR end "ruleUnnamedObject"
2937
2938
2939 // $ANTLR start "entryRuleDataObject"
2940 // InternalSolverLanguage.g:987:1: entryRuleDataObject returns [EObject current=null] : iv_ruleDataObject= ruleDataObject EOF ;
2941 public final EObject entryRuleDataObject() throws RecognitionException {
2942 EObject current = null;
2943
2944 EObject iv_ruleDataObject = null;
2945
2946
2947 try {
2948 // InternalSolverLanguage.g:987:51: (iv_ruleDataObject= ruleDataObject EOF )
2949 // InternalSolverLanguage.g:988:2: iv_ruleDataObject= ruleDataObject EOF
2950 {
2951 newCompositeNode(grammarAccess.getDataObjectRule());
2952 pushFollow(FOLLOW_1);
2953 iv_ruleDataObject=ruleDataObject();
2954
2955 state._fsp--;
2956
2957 current =iv_ruleDataObject;
2958 match(input,EOF,FOLLOW_2);
2959
2960 }
2961
2962 }
2963
2964 catch (RecognitionException re) {
2965 recover(input,re);
2966 appendSkippedTokens();
2967 }
2968 finally {
2969 }
2970 return current;
2971 }
2972 // $ANTLR end "entryRuleDataObject"
2973
2974
2975 // $ANTLR start "ruleDataObject"
2976 // InternalSolverLanguage.g:994:1: ruleDataObject returns [EObject current=null] : (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) ;
2977 public final EObject ruleDataObject() throws RecognitionException {
2978 EObject current = null;
2979
2980 EObject this_BooleanObject_0 = null;
2981
2982 EObject this_IntObject_1 = null;
2983
2984 EObject this_RealObject_2 = null;
2985
2986 EObject this_StringObject_3 = null;
2987
2988
2989
2990 enterRule();
2991
2992 try {
2993 // InternalSolverLanguage.g:1000:2: ( (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) )
2994 // InternalSolverLanguage.g:1001:2: (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject )
2995 {
2996 // InternalSolverLanguage.g:1001:2: (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject )
2997 int alt14=4;
2998 switch ( input.LA(1) ) {
2999 case 13:
3000 case 14:
3001 {
3002 alt14=1;
3003 }
3004 break;
3005 case 11:
3006 {
3007 int LA14_2 = input.LA(2);
3008
3009 if ( (LA14_2==RULE_INT) ) {
3010 int LA14_3 = input.LA(3);
3011
3012 if ( (LA14_3==12) ) {
3013 alt14=3;
3014 }
3015 else if ( (LA14_3==EOF||(LA14_3>=RULE_INT && LA14_3<=RULE_STRING)||LA14_3==11||(LA14_3>=13 && LA14_3<=14)||(LA14_3>=18 && LA14_3<=19)||LA14_3==26||LA14_3==30) ) {
3016 alt14=2;
3017 }
3018 else {
3019 NoViableAltException nvae =
3020 new NoViableAltException("", 14, 3, input);
3021
3022 throw nvae;
3023 }
3024 }
3025 else {
3026 NoViableAltException nvae =
3027 new NoViableAltException("", 14, 2, input);
3028
3029 throw nvae;
3030 }
3031 }
3032 break;
3033 case RULE_INT:
3034 {
3035 int LA14_3 = input.LA(2);
3036
3037 if ( (LA14_3==12) ) {
3038 alt14=3;
3039 }
3040 else if ( (LA14_3==EOF||(LA14_3>=RULE_INT && LA14_3<=RULE_STRING)||LA14_3==11||(LA14_3>=13 && LA14_3<=14)||(LA14_3>=18 && LA14_3<=19)||LA14_3==26||LA14_3==30) ) {
3041 alt14=2;
3042 }
3043 else {
3044 NoViableAltException nvae =
3045 new NoViableAltException("", 14, 3, input);
3046
3047 throw nvae;
3048 }
3049 }
3050 break;
3051 case RULE_STRING:
3052 {
3053 alt14=4;
3054 }
3055 break;
3056 default:
3057 NoViableAltException nvae =
3058 new NoViableAltException("", 14, 0, input);
3059
3060 throw nvae;
3061 }
3062
3063 switch (alt14) {
3064 case 1 :
3065 // InternalSolverLanguage.g:1002:3: this_BooleanObject_0= ruleBooleanObject
3066 {
3067
3068 newCompositeNode(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0());
3069
3070 pushFollow(FOLLOW_2);
3071 this_BooleanObject_0=ruleBooleanObject();
3072
3073 state._fsp--;
3074
3075
3076 current = this_BooleanObject_0;
3077 afterParserOrEnumRuleCall();
3078
3079
3080 }
3081 break;
3082 case 2 :
3083 // InternalSolverLanguage.g:1011:3: this_IntObject_1= ruleIntObject
3084 {
3085
3086 newCompositeNode(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1());
3087
3088 pushFollow(FOLLOW_2);
3089 this_IntObject_1=ruleIntObject();
3090
3091 state._fsp--;
3092
3093
3094 current = this_IntObject_1;
3095 afterParserOrEnumRuleCall();
3096
3097
3098 }
3099 break;
3100 case 3 :
3101 // InternalSolverLanguage.g:1020:3: this_RealObject_2= ruleRealObject
3102 {
3103
3104 newCompositeNode(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2());
3105
3106 pushFollow(FOLLOW_2);
3107 this_RealObject_2=ruleRealObject();
3108
3109 state._fsp--;
3110
3111
3112 current = this_RealObject_2;
3113 afterParserOrEnumRuleCall();
3114
3115
3116 }
3117 break;
3118 case 4 :
3119 // InternalSolverLanguage.g:1029:3: this_StringObject_3= ruleStringObject
3120 {
3121
3122 newCompositeNode(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3());
3123
3124 pushFollow(FOLLOW_2);
3125 this_StringObject_3=ruleStringObject();
3126
3127 state._fsp--;
3128
3129
3130 current = this_StringObject_3;
3131 afterParserOrEnumRuleCall();
3132
3133
3134 }
3135 break;
3136
3137 }
3138
3139
3140 }
3141
3142
3143 leaveRule();
3144
3145 }
3146
3147 catch (RecognitionException re) {
3148 recover(input,re);
3149 appendSkippedTokens();
3150 }
3151 finally {
3152 }
3153 return current;
3154 }
3155 // $ANTLR end "ruleDataObject"
3156
3157
3158 // $ANTLR start "entryRuleBooleanObject"
3159 // InternalSolverLanguage.g:1041:1: entryRuleBooleanObject returns [EObject current=null] : iv_ruleBooleanObject= ruleBooleanObject EOF ;
3160 public final EObject entryRuleBooleanObject() throws RecognitionException {
3161 EObject current = null;
3162
3163 EObject iv_ruleBooleanObject = null;
3164
3165
3166 try {
3167 // InternalSolverLanguage.g:1041:54: (iv_ruleBooleanObject= ruleBooleanObject EOF )
3168 // InternalSolverLanguage.g:1042:2: iv_ruleBooleanObject= ruleBooleanObject EOF
3169 {
3170 newCompositeNode(grammarAccess.getBooleanObjectRule());
3171 pushFollow(FOLLOW_1);
3172 iv_ruleBooleanObject=ruleBooleanObject();
3173
3174 state._fsp--;
3175
3176 current =iv_ruleBooleanObject;
3177 match(input,EOF,FOLLOW_2);
3178
3179 }
3180
3181 }
3182
3183 catch (RecognitionException re) {
3184 recover(input,re);
3185 appendSkippedTokens();
3186 }
3187 finally {
3188 }
3189 return current;
3190 }
3191 // $ANTLR end "entryRuleBooleanObject"
3192
3193
3194 // $ANTLR start "ruleBooleanObject"
3195 // InternalSolverLanguage.g:1048:1: ruleBooleanObject returns [EObject current=null] : ( (lv_value_0_0= ruleBooleanValue ) ) ;
3196 public final EObject ruleBooleanObject() throws RecognitionException {
3197 EObject current = null;
3198
3199 EObject lv_value_0_0 = null;
3200
3201
3202
3203 enterRule();
3204
3205 try {
3206 // InternalSolverLanguage.g:1054:2: ( ( (lv_value_0_0= ruleBooleanValue ) ) )
3207 // InternalSolverLanguage.g:1055:2: ( (lv_value_0_0= ruleBooleanValue ) )
3208 {
3209 // InternalSolverLanguage.g:1055:2: ( (lv_value_0_0= ruleBooleanValue ) )
3210 // InternalSolverLanguage.g:1056:3: (lv_value_0_0= ruleBooleanValue )
3211 {
3212 // InternalSolverLanguage.g:1056:3: (lv_value_0_0= ruleBooleanValue )
3213 // InternalSolverLanguage.g:1057:4: lv_value_0_0= ruleBooleanValue
3214 {
3215
3216 newCompositeNode(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0());
3217
3218 pushFollow(FOLLOW_2);
3219 lv_value_0_0=ruleBooleanValue();
3220
3221 state._fsp--;
3222
3223
3224 if (current==null) {
3225 current = createModelElementForParent(grammarAccess.getBooleanObjectRule());
3226 }
3227 set(
3228 current,
3229 "value",
3230 lv_value_0_0,
3231 "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue");
3232 afterParserOrEnumRuleCall();
3233
3234
3235 }
3236
3237
3238 }
3239
3240
3241 }
3242
3243
3244 leaveRule();
3245
3246 }
3247
3248 catch (RecognitionException re) {
3249 recover(input,re);
3250 appendSkippedTokens();
3251 }
3252 finally {
3253 }
3254 return current;
3255 }
3256 // $ANTLR end "ruleBooleanObject"
3257
3258
3259 // $ANTLR start "entryRuleIntObject"
3260 // InternalSolverLanguage.g:1077:1: entryRuleIntObject returns [EObject current=null] : iv_ruleIntObject= ruleIntObject EOF ;
3261 public final EObject entryRuleIntObject() throws RecognitionException {
3262 EObject current = null;
3263
3264 EObject iv_ruleIntObject = null;
3265
3266
3267 try {
3268 // InternalSolverLanguage.g:1077:50: (iv_ruleIntObject= ruleIntObject EOF )
3269 // InternalSolverLanguage.g:1078:2: iv_ruleIntObject= ruleIntObject EOF
3270 {
3271 newCompositeNode(grammarAccess.getIntObjectRule());
3272 pushFollow(FOLLOW_1);
3273 iv_ruleIntObject=ruleIntObject();
3274
3275 state._fsp--;
3276
3277 current =iv_ruleIntObject;
3278 match(input,EOF,FOLLOW_2);
3279
3280 }
3281
3282 }
3283
3284 catch (RecognitionException re) {
3285 recover(input,re);
3286 appendSkippedTokens();
3287 }
3288 finally {
3289 }
3290 return current;
3291 }
3292 // $ANTLR end "entryRuleIntObject"
3293
3294
3295 // $ANTLR start "ruleIntObject"
3296 // InternalSolverLanguage.g:1084:1: ruleIntObject returns [EObject current=null] : ( (lv_value_0_0= ruleINTLiteral ) ) ;
3297 public final EObject ruleIntObject() throws RecognitionException {
3298 EObject current = null;
3299
3300 AntlrDatatypeRuleToken lv_value_0_0 = null;
3301
3302
3303
3304 enterRule();
3305
3306 try {
3307 // InternalSolverLanguage.g:1090:2: ( ( (lv_value_0_0= ruleINTLiteral ) ) )
3308 // InternalSolverLanguage.g:1091:2: ( (lv_value_0_0= ruleINTLiteral ) )
3309 {
3310 // InternalSolverLanguage.g:1091:2: ( (lv_value_0_0= ruleINTLiteral ) )
3311 // InternalSolverLanguage.g:1092:3: (lv_value_0_0= ruleINTLiteral )
3312 {
3313 // InternalSolverLanguage.g:1092:3: (lv_value_0_0= ruleINTLiteral )
3314 // InternalSolverLanguage.g:1093:4: lv_value_0_0= ruleINTLiteral
3315 {
3316
3317 newCompositeNode(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0());
3318
3319 pushFollow(FOLLOW_2);
3320 lv_value_0_0=ruleINTLiteral();
3321
3322 state._fsp--;
3323
3324
3325 if (current==null) {
3326 current = createModelElementForParent(grammarAccess.getIntObjectRule());
3327 }
3328 set(
3329 current,
3330 "value",
3331 lv_value_0_0,
3332 "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral");
3333 afterParserOrEnumRuleCall();
3334
3335
3336 }
3337
3338
3339 }
3340
3341
3342 }
3343
3344
3345 leaveRule();
3346
3347 }
3348
3349 catch (RecognitionException re) {
3350 recover(input,re);
3351 appendSkippedTokens();
3352 }
3353 finally {
3354 }
3355 return current;
3356 }
3357 // $ANTLR end "ruleIntObject"
3358
3359
3360 // $ANTLR start "entryRuleRealObject"
3361 // InternalSolverLanguage.g:1113:1: entryRuleRealObject returns [EObject current=null] : iv_ruleRealObject= ruleRealObject EOF ;
3362 public final EObject entryRuleRealObject() throws RecognitionException {
3363 EObject current = null;
3364
3365 EObject iv_ruleRealObject = null;
3366
3367
3368 try {
3369 // InternalSolverLanguage.g:1113:51: (iv_ruleRealObject= ruleRealObject EOF )
3370 // InternalSolverLanguage.g:1114:2: iv_ruleRealObject= ruleRealObject EOF
3371 {
3372 newCompositeNode(grammarAccess.getRealObjectRule());
3373 pushFollow(FOLLOW_1);
3374 iv_ruleRealObject=ruleRealObject();
3375
3376 state._fsp--;
3377
3378 current =iv_ruleRealObject;
3379 match(input,EOF,FOLLOW_2);
3380
3381 }
3382
3383 }
3384
3385 catch (RecognitionException re) {
3386 recover(input,re);
3387 appendSkippedTokens();
3388 }
3389 finally {
3390 }
3391 return current;
3392 }
3393 // $ANTLR end "entryRuleRealObject"
3394
3395
3396 // $ANTLR start "ruleRealObject"
3397 // InternalSolverLanguage.g:1120:1: ruleRealObject returns [EObject current=null] : ( (lv_value_0_0= ruleREALLiteral ) ) ;
3398 public final EObject ruleRealObject() throws RecognitionException {
3399 EObject current = null;
3400
3401 AntlrDatatypeRuleToken lv_value_0_0 = null;
3402
3403
3404
3405 enterRule();
3406
3407 try {
3408 // InternalSolverLanguage.g:1126:2: ( ( (lv_value_0_0= ruleREALLiteral ) ) )
3409 // InternalSolverLanguage.g:1127:2: ( (lv_value_0_0= ruleREALLiteral ) )
3410 {
3411 // InternalSolverLanguage.g:1127:2: ( (lv_value_0_0= ruleREALLiteral ) )
3412 // InternalSolverLanguage.g:1128:3: (lv_value_0_0= ruleREALLiteral )
3413 {
3414 // InternalSolverLanguage.g:1128:3: (lv_value_0_0= ruleREALLiteral )
3415 // InternalSolverLanguage.g:1129:4: lv_value_0_0= ruleREALLiteral
3416 {
3417
3418 newCompositeNode(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0());
3419
3420 pushFollow(FOLLOW_2);
3421 lv_value_0_0=ruleREALLiteral();
3422
3423 state._fsp--;
3424
3425
3426 if (current==null) {
3427 current = createModelElementForParent(grammarAccess.getRealObjectRule());
3428 }
3429 set(
3430 current,
3431 "value",
3432 lv_value_0_0,
3433 "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral");
3434 afterParserOrEnumRuleCall();
3435
3436
3437 }
3438
3439
3440 }
3441
3442
3443 }
3444
3445
3446 leaveRule();
3447
3448 }
3449
3450 catch (RecognitionException re) {
3451 recover(input,re);
3452 appendSkippedTokens();
3453 }
3454 finally {
3455 }
3456 return current;
3457 }
3458 // $ANTLR end "ruleRealObject"
3459
3460
3461 // $ANTLR start "entryRuleStringObject"
3462 // InternalSolverLanguage.g:1149:1: entryRuleStringObject returns [EObject current=null] : iv_ruleStringObject= ruleStringObject EOF ;
3463 public final EObject entryRuleStringObject() throws RecognitionException {
3464 EObject current = null;
3465
3466 EObject iv_ruleStringObject = null;
3467
3468
3469 try {
3470 // InternalSolverLanguage.g:1149:53: (iv_ruleStringObject= ruleStringObject EOF )
3471 // InternalSolverLanguage.g:1150:2: iv_ruleStringObject= ruleStringObject EOF
3472 {
3473 newCompositeNode(grammarAccess.getStringObjectRule());
3474 pushFollow(FOLLOW_1);
3475 iv_ruleStringObject=ruleStringObject();
3476
3477 state._fsp--;
3478
3479 current =iv_ruleStringObject;
3480 match(input,EOF,FOLLOW_2);
3481
3482 }
3483
3484 }
3485
3486 catch (RecognitionException re) {
3487 recover(input,re);
3488 appendSkippedTokens();
3489 }
3490 finally {
3491 }
3492 return current;
3493 }
3494 // $ANTLR end "entryRuleStringObject"
3495
3496
3497 // $ANTLR start "ruleStringObject"
3498 // InternalSolverLanguage.g:1156:1: ruleStringObject returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ;
3499 public final EObject ruleStringObject() throws RecognitionException {
3500 EObject current = null;
3501
3502 Token lv_value_0_0=null;
3503
3504
3505 enterRule();
3506
3507 try {
3508 // InternalSolverLanguage.g:1162:2: ( ( (lv_value_0_0= RULE_STRING ) ) )
3509 // InternalSolverLanguage.g:1163:2: ( (lv_value_0_0= RULE_STRING ) )
3510 {
3511 // InternalSolverLanguage.g:1163:2: ( (lv_value_0_0= RULE_STRING ) )
3512 // InternalSolverLanguage.g:1164:3: (lv_value_0_0= RULE_STRING )
3513 {
3514 // InternalSolverLanguage.g:1164:3: (lv_value_0_0= RULE_STRING )
3515 // InternalSolverLanguage.g:1165:4: lv_value_0_0= RULE_STRING
3516 {
3517 lv_value_0_0=(Token)match(input,RULE_STRING,FOLLOW_2);
3518
3519 newLeafNode(lv_value_0_0, grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0());
3520
3521
3522 if (current==null) {
3523 current = createModelElement(grammarAccess.getStringObjectRule());
3524 }
3525 setWithLastConsumed(
3526 current,
3527 "value",
3528 lv_value_0_0,
3529 "org.eclipse.viatra.solver.language.SolverLanguage.STRING");
3530
3531
3532 }
3533
3534
3535 }
3536
3537
3538 }
3539
3540
3541 leaveRule();
3542
3543 }
3544
3545 catch (RecognitionException re) {
3546 recover(input,re);
3547 appendSkippedTokens();
3548 }
3549 finally {
3550 }
3551 return current;
3552 }
3553 // $ANTLR end "ruleStringObject"
3554
3555
3556 // $ANTLR start "entryRulePredicate"
3557 // InternalSolverLanguage.g:1184:1: entryRulePredicate returns [EObject current=null] : iv_rulePredicate= rulePredicate EOF ;
3558 public final EObject entryRulePredicate() throws RecognitionException {
3559 EObject current = null;
3560
3561 EObject iv_rulePredicate = null;
3562
3563
3564 try {
3565 // InternalSolverLanguage.g:1184:50: (iv_rulePredicate= rulePredicate EOF )
3566 // InternalSolverLanguage.g:1185:2: iv_rulePredicate= rulePredicate EOF
3567 {
3568 newCompositeNode(grammarAccess.getPredicateRule());
3569 pushFollow(FOLLOW_1);
3570 iv_rulePredicate=rulePredicate();
3571
3572 state._fsp--;
3573
3574 current =iv_rulePredicate;
3575 match(input,EOF,FOLLOW_2);
3576
3577 }
3578
3579 }
3580
3581 catch (RecognitionException re) {
3582 recover(input,re);
3583 appendSkippedTokens();
3584 }
3585 finally {
3586 }
3587 return current;
3588 }
3589 // $ANTLR end "entryRulePredicate"
3590
3591
3592 // $ANTLR start "rulePredicate"
3593 // InternalSolverLanguage.g:1191:1: rulePredicate returns [EObject current=null] : (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate ) ;
3594 public final EObject rulePredicate() throws RecognitionException {
3595 EObject current = null;
3596
3597 EObject this_PredicateSymbol_0 = null;
3598
3599 EObject this_ErrorPredicate_1 = null;
3600
3601
3602
3603 enterRule();
3604
3605 try {
3606 // InternalSolverLanguage.g:1197:2: ( (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate ) )
3607 // InternalSolverLanguage.g:1198:2: (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate )
3608 {
3609 // InternalSolverLanguage.g:1198:2: (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate )
3610 int alt15=2;
3611 int LA15_0 = input.LA(1);
3612
3613 if ( (LA15_0==27) ) {
3614 alt15=1;
3615 }
3616 else if ( (LA15_0==16) ) {
3617 alt15=2;
3618 }
3619 else {
3620 NoViableAltException nvae =
3621 new NoViableAltException("", 15, 0, input);
3622
3623 throw nvae;
3624 }
3625 switch (alt15) {
3626 case 1 :
3627 // InternalSolverLanguage.g:1199:3: this_PredicateSymbol_0= rulePredicateSymbol
3628 {
3629
3630 newCompositeNode(grammarAccess.getPredicateAccess().getPredicateSymbolParserRuleCall_0());
3631
3632 pushFollow(FOLLOW_2);
3633 this_PredicateSymbol_0=rulePredicateSymbol();
3634
3635 state._fsp--;
3636
3637
3638 current = this_PredicateSymbol_0;
3639 afterParserOrEnumRuleCall();
3640
3641
3642 }
3643 break;
3644 case 2 :
3645 // InternalSolverLanguage.g:1208:3: this_ErrorPredicate_1= ruleErrorPredicate
3646 {
3647
3648 newCompositeNode(grammarAccess.getPredicateAccess().getErrorPredicateParserRuleCall_1());
3649
3650 pushFollow(FOLLOW_2);
3651 this_ErrorPredicate_1=ruleErrorPredicate();
3652
3653 state._fsp--;
3654
3655
3656 current = this_ErrorPredicate_1;
3657 afterParserOrEnumRuleCall();
3658
3659
3660 }
3661 break;
3662
3663 }
3664
3665
3666 }
3667
3668
3669 leaveRule();
3670
3671 }
3672
3673 catch (RecognitionException re) {
3674 recover(input,re);
3675 appendSkippedTokens();
3676 }
3677 finally {
3678 }
3679 return current;
3680 }
3681 // $ANTLR end "rulePredicate"
3682
3683
3684 // $ANTLR start "entryRulePredicateSymbol"
3685 // InternalSolverLanguage.g:1220:1: entryRulePredicateSymbol returns [EObject current=null] : iv_rulePredicateSymbol= rulePredicateSymbol EOF ;
3686 public final EObject entryRulePredicateSymbol() throws RecognitionException {
3687 EObject current = null;
3688
3689 EObject iv_rulePredicateSymbol = null;
3690
3691
3692 try {
3693 // InternalSolverLanguage.g:1220:56: (iv_rulePredicateSymbol= rulePredicateSymbol EOF )
3694 // InternalSolverLanguage.g:1221:2: iv_rulePredicateSymbol= rulePredicateSymbol EOF
3695 {
3696 newCompositeNode(grammarAccess.getPredicateSymbolRule());
3697 pushFollow(FOLLOW_1);
3698 iv_rulePredicateSymbol=rulePredicateSymbol();
3699
3700 state._fsp--;
3701
3702 current =iv_rulePredicateSymbol;
3703 match(input,EOF,FOLLOW_2);
3704
3705 }
3706
3707 }
3708
3709 catch (RecognitionException re) {
3710 recover(input,re);
3711 appendSkippedTokens();
3712 }
3713 finally {
3714 }
3715 return current;
3716 }
3717 // $ANTLR end "entryRulePredicateSymbol"
3718
3719
3720 // $ANTLR start "rulePredicateSymbol"
3721 // InternalSolverLanguage.g:1227:1: rulePredicateSymbol returns [EObject current=null] : (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' ) ;
3722 public final EObject rulePredicateSymbol() throws RecognitionException {
3723 EObject current = null;
3724
3725 Token otherlv_0=null;
3726 Token otherlv_2=null;
3727 Token otherlv_4=null;
3728 Token otherlv_5=null;
3729 Token otherlv_6=null;
3730 Token otherlv_8=null;
3731 Token otherlv_10=null;
3732 EObject lv_symbol_1_0 = null;
3733
3734 EObject lv_parameters_3_0 = null;
3735
3736 EObject lv_bodies_7_0 = null;
3737
3738 EObject lv_bodies_9_0 = null;
3739
3740
3741
3742 enterRule();
3743
3744 try {
3745 // InternalSolverLanguage.g:1233:2: ( (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' ) )
3746 // InternalSolverLanguage.g:1234:2: (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' )
3747 {
3748 // InternalSolverLanguage.g:1234:2: (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' )
3749 // InternalSolverLanguage.g:1235:3: otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.'
3750 {
3751 otherlv_0=(Token)match(input,27,FOLLOW_10);
3752
3753 newLeafNode(otherlv_0, grammarAccess.getPredicateSymbolAccess().getPredicateKeyword_0());
3754
3755 // InternalSolverLanguage.g:1239:3: ( (lv_symbol_1_0= ruleModelSymbol ) )
3756 // InternalSolverLanguage.g:1240:4: (lv_symbol_1_0= ruleModelSymbol )
3757 {
3758 // InternalSolverLanguage.g:1240:4: (lv_symbol_1_0= ruleModelSymbol )
3759 // InternalSolverLanguage.g:1241:5: lv_symbol_1_0= ruleModelSymbol
3760 {
3761
3762 newCompositeNode(grammarAccess.getPredicateSymbolAccess().getSymbolModelSymbolParserRuleCall_1_0());
3763
3764 pushFollow(FOLLOW_6);
3765 lv_symbol_1_0=ruleModelSymbol();
3766
3767 state._fsp--;
3768
3769
3770 if (current==null) {
3771 current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
3772 }
3773 set(
3774 current,
3775 "symbol",
3776 lv_symbol_1_0,
3777 "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
3778 afterParserOrEnumRuleCall();
3779
3780
3781 }
3782
3783
3784 }
3785
3786 otherlv_2=(Token)match(input,17,FOLLOW_12);
3787
3788 newLeafNode(otherlv_2, grammarAccess.getPredicateSymbolAccess().getLeftParenthesisKeyword_2());
3789
3790 // InternalSolverLanguage.g:1262:3: ( (lv_parameters_3_0= ruleParameter ) )*
3791 loop16:
3792 do {
3793 int alt16=2;
3794 int LA16_0 = input.LA(1);
3795
3796 if ( (LA16_0==RULE_ID) ) {
3797 alt16=1;
3798 }
3799
3800
3801 switch (alt16) {
3802 case 1 :
3803 // InternalSolverLanguage.g:1263:4: (lv_parameters_3_0= ruleParameter )
3804 {
3805 // InternalSolverLanguage.g:1263:4: (lv_parameters_3_0= ruleParameter )
3806 // InternalSolverLanguage.g:1264:5: lv_parameters_3_0= ruleParameter
3807 {
3808
3809 newCompositeNode(grammarAccess.getPredicateSymbolAccess().getParametersParameterParserRuleCall_3_0());
3810
3811 pushFollow(FOLLOW_12);
3812 lv_parameters_3_0=ruleParameter();
3813
3814 state._fsp--;
3815
3816
3817 if (current==null) {
3818 current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
3819 }
3820 add(
3821 current,
3822 "parameters",
3823 lv_parameters_3_0,
3824 "org.eclipse.viatra.solver.language.SolverLanguage.Parameter");
3825 afterParserOrEnumRuleCall();
3826
3827
3828 }
3829
3830
3831 }
3832 break;
3833
3834 default :
3835 break loop16;
3836 }
3837 } while (true);
3838
3839 otherlv_4=(Token)match(input,18,FOLLOW_8);
3840
3841 newLeafNode(otherlv_4, grammarAccess.getPredicateSymbolAccess().getRightParenthesisKeyword_4());
3842
3843 otherlv_5=(Token)match(input,19,FOLLOW_13);
3844
3845 newLeafNode(otherlv_5, grammarAccess.getPredicateSymbolAccess().getColonKeyword_5());
3846
3847 // InternalSolverLanguage.g:1289:3: (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) )
3848 int alt18=2;
3849 int LA18_0 = input.LA(1);
3850
3851 if ( (LA18_0==14) ) {
3852 alt18=1;
3853 }
3854 else if ( (LA18_0==EOF||LA18_0==RULE_ID||(LA18_0>=11 && LA18_0<=13)||(LA18_0>=28 && LA18_0<=29)) ) {
3855 alt18=2;
3856 }
3857 else {
3858 NoViableAltException nvae =
3859 new NoViableAltException("", 18, 0, input);
3860
3861 throw nvae;
3862 }
3863 switch (alt18) {
3864 case 1 :
3865 // InternalSolverLanguage.g:1290:4: otherlv_6= 'false'
3866 {
3867 otherlv_6=(Token)match(input,14,FOLLOW_5);
3868
3869 newLeafNode(otherlv_6, grammarAccess.getPredicateSymbolAccess().getFalseKeyword_6_0());
3870
3871
3872 }
3873 break;
3874 case 2 :
3875 // InternalSolverLanguage.g:1295:4: ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* )
3876 {
3877 // InternalSolverLanguage.g:1295:4: ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* )
3878 // InternalSolverLanguage.g:1296:5: ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )*
3879 {
3880 // InternalSolverLanguage.g:1296:5: ( (lv_bodies_7_0= rulePatternBody ) )
3881 // InternalSolverLanguage.g:1297:6: (lv_bodies_7_0= rulePatternBody )
3882 {
3883 // InternalSolverLanguage.g:1297:6: (lv_bodies_7_0= rulePatternBody )
3884 // InternalSolverLanguage.g:1298:7: lv_bodies_7_0= rulePatternBody
3885 {
3886
3887 newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_0_0());
3888
3889 pushFollow(FOLLOW_14);
3890 lv_bodies_7_0=rulePatternBody();
3891
3892 state._fsp--;
3893
3894
3895 if (current==null) {
3896 current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
3897 }
3898 add(
3899 current,
3900 "bodies",
3901 lv_bodies_7_0,
3902 "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
3903 afterParserOrEnumRuleCall();
3904
3905
3906 }
3907
3908
3909 }
3910
3911 // InternalSolverLanguage.g:1315:5: (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )*
3912 loop17:
3913 do {
3914 int alt17=2;
3915 int LA17_0 = input.LA(1);
3916
3917 if ( (LA17_0==28) ) {
3918 alt17=1;
3919 }
3920
3921
3922 switch (alt17) {
3923 case 1 :
3924 // InternalSolverLanguage.g:1316:6: otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) )
3925 {
3926 otherlv_8=(Token)match(input,28,FOLLOW_15);
3927
3928 newLeafNode(otherlv_8, grammarAccess.getPredicateSymbolAccess().getVerticalLineKeyword_6_1_1_0());
3929
3930 // InternalSolverLanguage.g:1320:6: ( (lv_bodies_9_0= rulePatternBody ) )
3931 // InternalSolverLanguage.g:1321:7: (lv_bodies_9_0= rulePatternBody )
3932 {
3933 // InternalSolverLanguage.g:1321:7: (lv_bodies_9_0= rulePatternBody )
3934 // InternalSolverLanguage.g:1322:8: lv_bodies_9_0= rulePatternBody
3935 {
3936
3937 newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_1_1_0());
3938
3939 pushFollow(FOLLOW_14);
3940 lv_bodies_9_0=rulePatternBody();
3941
3942 state._fsp--;
3943
3944
3945 if (current==null) {
3946 current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
3947 }
3948 add(
3949 current,
3950 "bodies",
3951 lv_bodies_9_0,
3952 "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
3953 afterParserOrEnumRuleCall();
3954
3955
3956 }
3957
3958
3959 }
3960
3961
3962 }
3963 break;
3964
3965 default :
3966 break loop17;
3967 }
3968 } while (true);
3969
3970
3971 }
3972
3973
3974 }
3975 break;
3976
3977 }
3978
3979 otherlv_10=(Token)match(input,12,FOLLOW_2);
3980
3981 newLeafNode(otherlv_10, grammarAccess.getPredicateSymbolAccess().getFullStopKeyword_7());
3982
3983
3984 }
3985
3986
3987 }
3988
3989
3990 leaveRule();
3991
3992 }
3993
3994 catch (RecognitionException re) {
3995 recover(input,re);
3996 appendSkippedTokens();
3997 }
3998 finally {
3999 }
4000 return current;
4001 }
4002 // $ANTLR end "rulePredicateSymbol"
4003
4004
4005 // $ANTLR start "entryRuleErrorPredicate"
4006 // InternalSolverLanguage.g:1350:1: entryRuleErrorPredicate returns [EObject current=null] : iv_ruleErrorPredicate= ruleErrorPredicate EOF ;
4007 public final EObject entryRuleErrorPredicate() throws RecognitionException {
4008 EObject current = null;
4009
4010 EObject iv_ruleErrorPredicate = null;
4011
4012
4013 try {
4014 // InternalSolverLanguage.g:1350:55: (iv_ruleErrorPredicate= ruleErrorPredicate EOF )
4015 // InternalSolverLanguage.g:1351:2: iv_ruleErrorPredicate= ruleErrorPredicate EOF
4016 {
4017 newCompositeNode(grammarAccess.getErrorPredicateRule());
4018 pushFollow(FOLLOW_1);
4019 iv_ruleErrorPredicate=ruleErrorPredicate();
4020
4021 state._fsp--;
4022
4023 current =iv_ruleErrorPredicate;
4024 match(input,EOF,FOLLOW_2);
4025
4026 }
4027
4028 }
4029
4030 catch (RecognitionException re) {
4031 recover(input,re);
4032 appendSkippedTokens();
4033 }
4034 finally {
4035 }
4036 return current;
4037 }
4038 // $ANTLR end "entryRuleErrorPredicate"
4039
4040
4041 // $ANTLR start "ruleErrorPredicate"
4042 // InternalSolverLanguage.g:1357:1: ruleErrorPredicate returns [EObject current=null] : ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' ) ;
4043 public final EObject ruleErrorPredicate() throws RecognitionException {
4044 EObject current = null;
4045
4046 Token otherlv_1=null;
4047 Token lv_name_2_0=null;
4048 Token otherlv_3=null;
4049 Token otherlv_5=null;
4050 Token otherlv_6=null;
4051 Token otherlv_7=null;
4052 Token otherlv_9=null;
4053 Token otherlv_11=null;
4054 EObject lv_parameters_4_0 = null;
4055
4056 EObject lv_bodies_8_0 = null;
4057
4058 EObject lv_bodies_10_0 = null;
4059
4060
4061
4062 enterRule();
4063
4064 try {
4065 // InternalSolverLanguage.g:1363:2: ( ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' ) )
4066 // InternalSolverLanguage.g:1364:2: ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' )
4067 {
4068 // InternalSolverLanguage.g:1364:2: ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' )
4069 // InternalSolverLanguage.g:1365:3: () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.'
4070 {
4071 // InternalSolverLanguage.g:1365:3: ()
4072 // InternalSolverLanguage.g:1366:4:
4073 {
4074
4075 current = forceCreateModelElement(
4076 grammarAccess.getErrorPredicateAccess().getErrorPredicateAction_0(),
4077 current);
4078
4079
4080 }
4081
4082 otherlv_1=(Token)match(input,16,FOLLOW_16);
4083
4084 newLeafNode(otherlv_1, grammarAccess.getErrorPredicateAccess().getErrorKeyword_1());
4085
4086 // InternalSolverLanguage.g:1376:3: ( (lv_name_2_0= RULE_ID ) )?
4087 int alt19=2;
4088 int LA19_0 = input.LA(1);
4089
4090 if ( (LA19_0==RULE_ID) ) {
4091 alt19=1;
4092 }
4093 switch (alt19) {
4094 case 1 :
4095 // InternalSolverLanguage.g:1377:4: (lv_name_2_0= RULE_ID )
4096 {
4097 // InternalSolverLanguage.g:1377:4: (lv_name_2_0= RULE_ID )
4098 // InternalSolverLanguage.g:1378:5: lv_name_2_0= RULE_ID
4099 {
4100 lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_6);
4101
4102 newLeafNode(lv_name_2_0, grammarAccess.getErrorPredicateAccess().getNameIDTerminalRuleCall_2_0());
4103
4104
4105 if (current==null) {
4106 current = createModelElement(grammarAccess.getErrorPredicateRule());
4107 }
4108 setWithLastConsumed(
4109 current,
4110 "name",
4111 lv_name_2_0,
4112 "org.eclipse.xtext.common.Terminals.ID");
4113
4114
4115 }
4116
4117
4118 }
4119 break;
4120
4121 }
4122
4123 // InternalSolverLanguage.g:1394:3: (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' )
4124 // InternalSolverLanguage.g:1395:4: otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')'
4125 {
4126 otherlv_3=(Token)match(input,17,FOLLOW_12);
4127
4128 newLeafNode(otherlv_3, grammarAccess.getErrorPredicateAccess().getLeftParenthesisKeyword_3_0());
4129
4130 // InternalSolverLanguage.g:1399:4: ( (lv_parameters_4_0= ruleParameter ) )*
4131 loop20:
4132 do {
4133 int alt20=2;
4134 int LA20_0 = input.LA(1);
4135
4136 if ( (LA20_0==RULE_ID) ) {
4137 alt20=1;
4138 }
4139
4140
4141 switch (alt20) {
4142 case 1 :
4143 // InternalSolverLanguage.g:1400:5: (lv_parameters_4_0= ruleParameter )
4144 {
4145 // InternalSolverLanguage.g:1400:5: (lv_parameters_4_0= ruleParameter )
4146 // InternalSolverLanguage.g:1401:6: lv_parameters_4_0= ruleParameter
4147 {
4148
4149 newCompositeNode(grammarAccess.getErrorPredicateAccess().getParametersParameterParserRuleCall_3_1_0());
4150
4151 pushFollow(FOLLOW_12);
4152 lv_parameters_4_0=ruleParameter();
4153
4154 state._fsp--;
4155
4156
4157 if (current==null) {
4158 current = createModelElementForParent(grammarAccess.getErrorPredicateRule());
4159 }
4160 add(
4161 current,
4162 "parameters",
4163 lv_parameters_4_0,
4164 "org.eclipse.viatra.solver.language.SolverLanguage.Parameter");
4165 afterParserOrEnumRuleCall();
4166
4167
4168 }
4169
4170
4171 }
4172 break;
4173
4174 default :
4175 break loop20;
4176 }
4177 } while (true);
4178
4179 otherlv_5=(Token)match(input,18,FOLLOW_8);
4180
4181 newLeafNode(otherlv_5, grammarAccess.getErrorPredicateAccess().getRightParenthesisKeyword_3_2());
4182
4183
4184 }
4185
4186 otherlv_6=(Token)match(input,19,FOLLOW_13);
4187
4188 newLeafNode(otherlv_6, grammarAccess.getErrorPredicateAccess().getColonKeyword_4());
4189
4190 // InternalSolverLanguage.g:1427:3: (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) )
4191 int alt22=2;
4192 int LA22_0 = input.LA(1);
4193
4194 if ( (LA22_0==14) ) {
4195 alt22=1;
4196 }
4197 else if ( (LA22_0==EOF||LA22_0==RULE_ID||(LA22_0>=11 && LA22_0<=13)||(LA22_0>=28 && LA22_0<=29)) ) {
4198 alt22=2;
4199 }
4200 else {
4201 NoViableAltException nvae =
4202 new NoViableAltException("", 22, 0, input);
4203
4204 throw nvae;
4205 }
4206 switch (alt22) {
4207 case 1 :
4208 // InternalSolverLanguage.g:1428:4: otherlv_7= 'false'
4209 {
4210 otherlv_7=(Token)match(input,14,FOLLOW_5);
4211
4212 newLeafNode(otherlv_7, grammarAccess.getErrorPredicateAccess().getFalseKeyword_5_0());
4213
4214
4215 }
4216 break;
4217 case 2 :
4218 // InternalSolverLanguage.g:1433:4: ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* )
4219 {
4220 // InternalSolverLanguage.g:1433:4: ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* )
4221 // InternalSolverLanguage.g:1434:5: ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )*
4222 {
4223 // InternalSolverLanguage.g:1434:5: ( (lv_bodies_8_0= rulePatternBody ) )
4224 // InternalSolverLanguage.g:1435:6: (lv_bodies_8_0= rulePatternBody )
4225 {
4226 // InternalSolverLanguage.g:1435:6: (lv_bodies_8_0= rulePatternBody )
4227 // InternalSolverLanguage.g:1436:7: lv_bodies_8_0= rulePatternBody
4228 {
4229
4230 newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_0_0());
4231
4232 pushFollow(FOLLOW_14);
4233 lv_bodies_8_0=rulePatternBody();
4234
4235 state._fsp--;
4236
4237
4238 if (current==null) {
4239 current = createModelElementForParent(grammarAccess.getErrorPredicateRule());
4240 }
4241 add(
4242 current,
4243 "bodies",
4244 lv_bodies_8_0,
4245 "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
4246 afterParserOrEnumRuleCall();
4247
4248
4249 }
4250
4251
4252 }
4253
4254 // InternalSolverLanguage.g:1453:5: (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )*
4255 loop21:
4256 do {
4257 int alt21=2;
4258 int LA21_0 = input.LA(1);
4259
4260 if ( (LA21_0==28) ) {
4261 alt21=1;
4262 }
4263
4264
4265 switch (alt21) {
4266 case 1 :
4267 // InternalSolverLanguage.g:1454:6: otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) )
4268 {
4269 otherlv_9=(Token)match(input,28,FOLLOW_15);
4270
4271 newLeafNode(otherlv_9, grammarAccess.getErrorPredicateAccess().getVerticalLineKeyword_5_1_1_0());
4272
4273 // InternalSolverLanguage.g:1458:6: ( (lv_bodies_10_0= rulePatternBody ) )
4274 // InternalSolverLanguage.g:1459:7: (lv_bodies_10_0= rulePatternBody )
4275 {
4276 // InternalSolverLanguage.g:1459:7: (lv_bodies_10_0= rulePatternBody )
4277 // InternalSolverLanguage.g:1460:8: lv_bodies_10_0= rulePatternBody
4278 {
4279
4280 newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_1_1_0());
4281
4282 pushFollow(FOLLOW_14);
4283 lv_bodies_10_0=rulePatternBody();
4284
4285 state._fsp--;
4286
4287
4288 if (current==null) {
4289 current = createModelElementForParent(grammarAccess.getErrorPredicateRule());
4290 }
4291 add(
4292 current,
4293 "bodies",
4294 lv_bodies_10_0,
4295 "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
4296 afterParserOrEnumRuleCall();
4297
4298
4299 }
4300
4301
4302 }
4303
4304
4305 }
4306 break;
4307
4308 default :
4309 break loop21;
4310 }
4311 } while (true);
4312
4313
4314 }
4315
4316
4317 }
4318 break;
4319
4320 }
4321
4322 otherlv_11=(Token)match(input,12,FOLLOW_2);
4323
4324 newLeafNode(otherlv_11, grammarAccess.getErrorPredicateAccess().getFullStopKeyword_6());
4325
4326
4327 }
4328
4329
4330 }
4331
4332
4333 leaveRule();
4334
4335 }
4336
4337 catch (RecognitionException re) {
4338 recover(input,re);
4339 appendSkippedTokens();
4340 }
4341 finally {
4342 }
4343 return current;
4344 }
4345 // $ANTLR end "ruleErrorPredicate"
4346
4347
4348 // $ANTLR start "entryRuleParameter"
4349 // InternalSolverLanguage.g:1488:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ;
4350 public final EObject entryRuleParameter() throws RecognitionException {
4351 EObject current = null;
4352
4353 EObject iv_ruleParameter = null;
4354
4355
4356 try {
4357 // InternalSolverLanguage.g:1488:50: (iv_ruleParameter= ruleParameter EOF )
4358 // InternalSolverLanguage.g:1489:2: iv_ruleParameter= ruleParameter EOF
4359 {
4360 newCompositeNode(grammarAccess.getParameterRule());
4361 pushFollow(FOLLOW_1);
4362 iv_ruleParameter=ruleParameter();
4363
4364 state._fsp--;
4365
4366 current =iv_ruleParameter;
4367 match(input,EOF,FOLLOW_2);
4368
4369 }
4370
4371 }
4372
4373 catch (RecognitionException re) {
4374 recover(input,re);
4375 appendSkippedTokens();
4376 }
4377 finally {
4378 }
4379 return current;
4380 }
4381 // $ANTLR end "entryRuleParameter"
4382
4383
4384 // $ANTLR start "ruleParameter"
4385 // InternalSolverLanguage.g:1495:1: ruleParameter returns [EObject current=null] : ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) ;
4386 public final EObject ruleParameter() throws RecognitionException {
4387 EObject current = null;
4388
4389 Token otherlv_1=null;
4390 EObject lv_variable_0_0 = null;
4391
4392 EObject lv_type_2_0 = null;
4393
4394
4395
4396 enterRule();
4397
4398 try {
4399 // InternalSolverLanguage.g:1501:2: ( ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) )
4400 // InternalSolverLanguage.g:1502:2: ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? )
4401 {
4402 // InternalSolverLanguage.g:1502:2: ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? )
4403 // InternalSolverLanguage.g:1503:3: ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )?
4404 {
4405 // InternalSolverLanguage.g:1503:3: ( (lv_variable_0_0= ruleVariable ) )
4406 // InternalSolverLanguage.g:1504:4: (lv_variable_0_0= ruleVariable )
4407 {
4408 // InternalSolverLanguage.g:1504:4: (lv_variable_0_0= ruleVariable )
4409 // InternalSolverLanguage.g:1505:5: lv_variable_0_0= ruleVariable
4410 {
4411
4412 newCompositeNode(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0());
4413
4414 pushFollow(FOLLOW_17);
4415 lv_variable_0_0=ruleVariable();
4416
4417 state._fsp--;
4418
4419
4420 if (current==null) {
4421 current = createModelElementForParent(grammarAccess.getParameterRule());
4422 }
4423 set(
4424 current,
4425 "variable",
4426 lv_variable_0_0,
4427 "org.eclipse.viatra.solver.language.SolverLanguage.Variable");
4428 afterParserOrEnumRuleCall();
4429
4430
4431 }
4432
4433
4434 }
4435
4436 // InternalSolverLanguage.g:1522:3: (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )?
4437 int alt23=2;
4438 int LA23_0 = input.LA(1);
4439
4440 if ( (LA23_0==19) ) {
4441 alt23=1;
4442 }
4443 switch (alt23) {
4444 case 1 :
4445 // InternalSolverLanguage.g:1523:4: otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) )
4446 {
4447 otherlv_1=(Token)match(input,19,FOLLOW_18);
4448
4449 newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getColonKeyword_1_0());
4450
4451 // InternalSolverLanguage.g:1527:4: ( (lv_type_2_0= ruleSymbol ) )
4452 // InternalSolverLanguage.g:1528:5: (lv_type_2_0= ruleSymbol )
4453 {
4454 // InternalSolverLanguage.g:1528:5: (lv_type_2_0= ruleSymbol )
4455 // InternalSolverLanguage.g:1529:6: lv_type_2_0= ruleSymbol
4456 {
4457
4458 newCompositeNode(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0());
4459
4460 pushFollow(FOLLOW_2);
4461 lv_type_2_0=ruleSymbol();
4462
4463 state._fsp--;
4464
4465
4466 if (current==null) {
4467 current = createModelElementForParent(grammarAccess.getParameterRule());
4468 }
4469 set(
4470 current,
4471 "type",
4472 lv_type_2_0,
4473 "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
4474 afterParserOrEnumRuleCall();
4475
4476
4477 }
4478
4479
4480 }
4481
4482
4483 }
4484 break;
4485
4486 }
4487
4488
4489 }
4490
4491
4492 }
4493
4494
4495 leaveRule();
4496
4497 }
4498
4499 catch (RecognitionException re) {
4500 recover(input,re);
4501 appendSkippedTokens();
4502 }
4503 finally {
4504 }
4505 return current;
4506 }
4507 // $ANTLR end "ruleParameter"
4508
4509
4510 // $ANTLR start "entryRulePatternBody"
4511 // InternalSolverLanguage.g:1551:1: entryRulePatternBody returns [EObject current=null] : iv_rulePatternBody= rulePatternBody EOF ;
4512 public final EObject entryRulePatternBody() throws RecognitionException {
4513 EObject current = null;
4514
4515 EObject iv_rulePatternBody = null;
4516
4517
4518 try {
4519 // InternalSolverLanguage.g:1551:52: (iv_rulePatternBody= rulePatternBody EOF )
4520 // InternalSolverLanguage.g:1552:2: iv_rulePatternBody= rulePatternBody EOF
4521 {
4522 newCompositeNode(grammarAccess.getPatternBodyRule());
4523 pushFollow(FOLLOW_1);
4524 iv_rulePatternBody=rulePatternBody();
4525
4526 state._fsp--;
4527
4528 current =iv_rulePatternBody;
4529 match(input,EOF,FOLLOW_2);
4530
4531 }
4532
4533 }
4534
4535 catch (RecognitionException re) {
4536 recover(input,re);
4537 appendSkippedTokens();
4538 }
4539 finally {
4540 }
4541 return current;
4542 }
4543 // $ANTLR end "entryRulePatternBody"
4544
4545
4546 // $ANTLR start "rulePatternBody"
4547 // InternalSolverLanguage.g:1558:1: rulePatternBody returns [EObject current=null] : ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) ;
4548 public final EObject rulePatternBody() throws RecognitionException {
4549 EObject current = null;
4550
4551 Token otherlv_1=null;
4552 EObject lv_constraints_2_0 = null;
4553
4554
4555
4556 enterRule();
4557
4558 try {
4559 // InternalSolverLanguage.g:1564:2: ( ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) )
4560 // InternalSolverLanguage.g:1565:2: ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) )
4561 {
4562 // InternalSolverLanguage.g:1565:2: ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) )
4563 // InternalSolverLanguage.g:1566:3: () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* )
4564 {
4565 // InternalSolverLanguage.g:1566:3: ()
4566 // InternalSolverLanguage.g:1567:4:
4567 {
4568
4569 current = forceCreateModelElement(
4570 grammarAccess.getPatternBodyAccess().getPatternBodyAction_0(),
4571 current);
4572
4573
4574 }
4575
4576 // InternalSolverLanguage.g:1573:3: (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* )
4577 int alt25=2;
4578 int LA25_0 = input.LA(1);
4579
4580 if ( (LA25_0==13) ) {
4581 alt25=1;
4582 }
4583 else if ( (LA25_0==EOF||LA25_0==RULE_ID||(LA25_0>=11 && LA25_0<=12)||(LA25_0>=28 && LA25_0<=29)) ) {
4584 alt25=2;
4585 }
4586 else {
4587 NoViableAltException nvae =
4588 new NoViableAltException("", 25, 0, input);
4589
4590 throw nvae;
4591 }
4592 switch (alt25) {
4593 case 1 :
4594 // InternalSolverLanguage.g:1574:4: otherlv_1= 'true'
4595 {
4596 otherlv_1=(Token)match(input,13,FOLLOW_2);
4597
4598 newLeafNode(otherlv_1, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0());
4599
4600
4601 }
4602 break;
4603 case 2 :
4604 // InternalSolverLanguage.g:1579:4: ( (lv_constraints_2_0= ruleConstraint ) )*
4605 {
4606 // InternalSolverLanguage.g:1579:4: ( (lv_constraints_2_0= ruleConstraint ) )*
4607 loop24:
4608 do {
4609 int alt24=2;
4610 int LA24_0 = input.LA(1);
4611
4612 if ( (LA24_0==RULE_ID||LA24_0==11||LA24_0==29) ) {
4613 alt24=1;
4614 }
4615
4616
4617 switch (alt24) {
4618 case 1 :
4619 // InternalSolverLanguage.g:1580:5: (lv_constraints_2_0= ruleConstraint )
4620 {
4621 // InternalSolverLanguage.g:1580:5: (lv_constraints_2_0= ruleConstraint )
4622 // InternalSolverLanguage.g:1581:6: lv_constraints_2_0= ruleConstraint
4623 {
4624
4625 newCompositeNode(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0());
4626
4627 pushFollow(FOLLOW_19);
4628 lv_constraints_2_0=ruleConstraint();
4629
4630 state._fsp--;
4631
4632
4633 if (current==null) {
4634 current = createModelElementForParent(grammarAccess.getPatternBodyRule());
4635 }
4636 add(
4637 current,
4638 "constraints",
4639 lv_constraints_2_0,
4640 "org.eclipse.viatra.solver.language.SolverLanguage.Constraint");
4641 afterParserOrEnumRuleCall();
4642
4643
4644 }
4645
4646
4647 }
4648 break;
4649
4650 default :
4651 break loop24;
4652 }
4653 } while (true);
4654
4655
4656 }
4657 break;
4658
4659 }
4660
4661
4662 }
4663
4664
4665 }
4666
4667
4668 leaveRule();
4669
4670 }
4671
4672 catch (RecognitionException re) {
4673 recover(input,re);
4674 appendSkippedTokens();
4675 }
4676 finally {
4677 }
4678 return current;
4679 }
4680 // $ANTLR end "rulePatternBody"
4681
4682
4683 // $ANTLR start "entryRulePolarity"
4684 // InternalSolverLanguage.g:1603:1: entryRulePolarity returns [EObject current=null] : iv_rulePolarity= rulePolarity EOF ;
4685 public final EObject entryRulePolarity() throws RecognitionException {
4686 EObject current = null;
4687
4688 EObject iv_rulePolarity = null;
4689
4690
4691 try {
4692 // InternalSolverLanguage.g:1603:49: (iv_rulePolarity= rulePolarity EOF )
4693 // InternalSolverLanguage.g:1604:2: iv_rulePolarity= rulePolarity EOF
4694 {
4695 newCompositeNode(grammarAccess.getPolarityRule());
4696 pushFollow(FOLLOW_1);
4697 iv_rulePolarity=rulePolarity();
4698
4699 state._fsp--;
4700
4701 current =iv_rulePolarity;
4702 match(input,EOF,FOLLOW_2);
4703
4704 }
4705
4706 }
4707
4708 catch (RecognitionException re) {
4709 recover(input,re);
4710 appendSkippedTokens();
4711 }
4712 finally {
4713 }
4714 return current;
4715 }
4716 // $ANTLR end "entryRulePolarity"
4717
4718
4719 // $ANTLR start "rulePolarity"
4720 // InternalSolverLanguage.g:1610:1: rulePolarity returns [EObject current=null] : ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) ;
4721 public final EObject rulePolarity() throws RecognitionException {
4722 EObject current = null;
4723
4724 Token otherlv_1=null;
4725 Token otherlv_3=null;
4726
4727
4728 enterRule();
4729
4730 try {
4731 // InternalSolverLanguage.g:1616:2: ( ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) )
4732 // InternalSolverLanguage.g:1617:2: ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) )
4733 {
4734 // InternalSolverLanguage.g:1617:2: ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) )
4735 int alt26=2;
4736 int LA26_0 = input.LA(1);
4737
4738 if ( (LA26_0==29) ) {
4739 alt26=1;
4740 }
4741 else if ( (LA26_0==11) ) {
4742 alt26=2;
4743 }
4744 else {
4745 NoViableAltException nvae =
4746 new NoViableAltException("", 26, 0, input);
4747
4748 throw nvae;
4749 }
4750 switch (alt26) {
4751 case 1 :
4752 // InternalSolverLanguage.g:1618:3: ( () otherlv_1= '+' )
4753 {
4754 // InternalSolverLanguage.g:1618:3: ( () otherlv_1= '+' )
4755 // InternalSolverLanguage.g:1619:4: () otherlv_1= '+'
4756 {
4757 // InternalSolverLanguage.g:1619:4: ()
4758 // InternalSolverLanguage.g:1620:5:
4759 {
4760
4761 current = forceCreateModelElement(
4762 grammarAccess.getPolarityAccess().getPositiveAction_0_0(),
4763 current);
4764
4765
4766 }
4767
4768 otherlv_1=(Token)match(input,29,FOLLOW_2);
4769
4770 newLeafNode(otherlv_1, grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1());
4771
4772
4773 }
4774
4775
4776 }
4777 break;
4778 case 2 :
4779 // InternalSolverLanguage.g:1632:3: ( () otherlv_3= '-' )
4780 {
4781 // InternalSolverLanguage.g:1632:3: ( () otherlv_3= '-' )
4782 // InternalSolverLanguage.g:1633:4: () otherlv_3= '-'
4783 {
4784 // InternalSolverLanguage.g:1633:4: ()
4785 // InternalSolverLanguage.g:1634:5:
4786 {
4787
4788 current = forceCreateModelElement(
4789 grammarAccess.getPolarityAccess().getNegativeAction_1_0(),
4790 current);
4791
4792
4793 }
4794
4795 otherlv_3=(Token)match(input,11,FOLLOW_2);
4796
4797 newLeafNode(otherlv_3, grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1());
4798
4799
4800 }
4801
4802
4803 }
4804 break;
4805
4806 }
4807
4808
4809 }
4810
4811
4812 leaveRule();
4813
4814 }
4815
4816 catch (RecognitionException re) {
4817 recover(input,re);
4818 appendSkippedTokens();
4819 }
4820 finally {
4821 }
4822 return current;
4823 }
4824 // $ANTLR end "rulePolarity"
4825
4826
4827 // $ANTLR start "entryRuleConstraint"
4828 // InternalSolverLanguage.g:1649:1: entryRuleConstraint returns [EObject current=null] : iv_ruleConstraint= ruleConstraint EOF ;
4829 public final EObject entryRuleConstraint() throws RecognitionException {
4830 EObject current = null;
4831
4832 EObject iv_ruleConstraint = null;
4833
4834
4835 try {
4836 // InternalSolverLanguage.g:1649:51: (iv_ruleConstraint= ruleConstraint EOF )
4837 // InternalSolverLanguage.g:1650:2: iv_ruleConstraint= ruleConstraint EOF
4838 {
4839 newCompositeNode(grammarAccess.getConstraintRule());
4840 pushFollow(FOLLOW_1);
4841 iv_ruleConstraint=ruleConstraint();
4842
4843 state._fsp--;
4844
4845 current =iv_ruleConstraint;
4846 match(input,EOF,FOLLOW_2);
4847
4848 }
4849
4850 }
4851
4852 catch (RecognitionException re) {
4853 recover(input,re);
4854 appendSkippedTokens();
4855 }
4856 finally {
4857 }
4858 return current;
4859 }
4860 // $ANTLR end "entryRuleConstraint"
4861
4862
4863 // $ANTLR start "ruleConstraint"
4864 // InternalSolverLanguage.g:1656:1: ruleConstraint returns [EObject current=null] : ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) ) ;
4865 public final EObject ruleConstraint() throws RecognitionException {
4866 EObject current = null;
4867
4868 Token otherlv_2=null;
4869 Token otherlv_4=null;
4870 Token otherlv_6=null;
4871 Token otherlv_9=null;
4872 EObject lv_polarity_0_0 = null;
4873
4874 EObject lv_symbol_1_0 = null;
4875
4876 EObject lv_params_3_0 = null;
4877
4878 EObject lv_closureType_5_0 = null;
4879
4880 EObject lv_params_7_0 = null;
4881
4882 EObject lv_params_8_0 = null;
4883
4884
4885
4886 enterRule();
4887
4888 try {
4889 // InternalSolverLanguage.g:1662:2: ( ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) ) )
4890 // InternalSolverLanguage.g:1663:2: ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) )
4891 {
4892 // InternalSolverLanguage.g:1663:2: ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) )
4893 // InternalSolverLanguage.g:1664:3: ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) )
4894 {
4895 // InternalSolverLanguage.g:1664:3: ( (lv_polarity_0_0= rulePolarity ) )?
4896 int alt27=2;
4897 int LA27_0 = input.LA(1);
4898
4899 if ( (LA27_0==11||LA27_0==29) ) {
4900 alt27=1;
4901 }
4902 switch (alt27) {
4903 case 1 :
4904 // InternalSolverLanguage.g:1665:4: (lv_polarity_0_0= rulePolarity )
4905 {
4906 // InternalSolverLanguage.g:1665:4: (lv_polarity_0_0= rulePolarity )
4907 // InternalSolverLanguage.g:1666:5: lv_polarity_0_0= rulePolarity
4908 {
4909
4910 newCompositeNode(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0());
4911
4912 pushFollow(FOLLOW_10);
4913 lv_polarity_0_0=rulePolarity();
4914
4915 state._fsp--;
4916
4917
4918 if (current==null) {
4919 current = createModelElementForParent(grammarAccess.getConstraintRule());
4920 }
4921 set(
4922 current,
4923 "polarity",
4924 lv_polarity_0_0,
4925 "org.eclipse.viatra.solver.language.SolverLanguage.Polarity");
4926 afterParserOrEnumRuleCall();
4927
4928
4929 }
4930
4931
4932 }
4933 break;
4934
4935 }
4936
4937 // InternalSolverLanguage.g:1683:3: ( (lv_symbol_1_0= ruleModelSymbol ) )
4938 // InternalSolverLanguage.g:1684:4: (lv_symbol_1_0= ruleModelSymbol )
4939 {
4940 // InternalSolverLanguage.g:1684:4: (lv_symbol_1_0= ruleModelSymbol )
4941 // InternalSolverLanguage.g:1685:5: lv_symbol_1_0= ruleModelSymbol
4942 {
4943
4944 newCompositeNode(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_1_0());
4945
4946 pushFollow(FOLLOW_20);
4947 lv_symbol_1_0=ruleModelSymbol();
4948
4949 state._fsp--;
4950
4951
4952 if (current==null) {
4953 current = createModelElementForParent(grammarAccess.getConstraintRule());
4954 }
4955 set(
4956 current,
4957 "symbol",
4958 lv_symbol_1_0,
4959 "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
4960 afterParserOrEnumRuleCall();
4961
4962
4963 }
4964
4965
4966 }
4967
4968 // InternalSolverLanguage.g:1702:3: ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) )
4969 int alt29=2;
4970 int LA29_0 = input.LA(1);
4971
4972 if ( (LA29_0==17) ) {
4973 alt29=1;
4974 }
4975 else if ( ((LA29_0>=29 && LA29_0<=30)) ) {
4976 alt29=2;
4977 }
4978 else {
4979 NoViableAltException nvae =
4980 new NoViableAltException("", 29, 0, input);
4981
4982 throw nvae;
4983 }
4984 switch (alt29) {
4985 case 1 :
4986 // InternalSolverLanguage.g:1703:4: (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' )
4987 {
4988 // InternalSolverLanguage.g:1703:4: (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' )
4989 // InternalSolverLanguage.g:1704:5: otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')'
4990 {
4991 otherlv_2=(Token)match(input,17,FOLLOW_21);
4992
4993 newLeafNode(otherlv_2, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_0_0());
4994
4995 // InternalSolverLanguage.g:1708:5: ( (lv_params_3_0= ruleLiteral ) )*
4996 loop28:
4997 do {
4998 int alt28=2;
4999 int LA28_0 = input.LA(1);
5000
5001 if ( ((LA28_0>=RULE_INT && LA28_0<=RULE_STRING)||LA28_0==11||(LA28_0>=13 && LA28_0<=14)) ) {
5002 alt28=1;
5003 }
5004
5005
5006 switch (alt28) {
5007 case 1 :
5008 // InternalSolverLanguage.g:1709:6: (lv_params_3_0= ruleLiteral )
5009 {
5010 // InternalSolverLanguage.g:1709:6: (lv_params_3_0= ruleLiteral )
5011 // InternalSolverLanguage.g:1710:7: lv_params_3_0= ruleLiteral
5012 {
5013
5014 newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_0_1_0());
5015
5016 pushFollow(FOLLOW_21);
5017 lv_params_3_0=ruleLiteral();
5018
5019 state._fsp--;
5020
5021
5022 if (current==null) {
5023 current = createModelElementForParent(grammarAccess.getConstraintRule());
5024 }
5025 add(
5026 current,
5027 "params",
5028 lv_params_3_0,
5029 "org.eclipse.viatra.solver.language.SolverLanguage.Literal");
5030 afterParserOrEnumRuleCall();
5031
5032
5033 }
5034
5035
5036 }
5037 break;
5038
5039 default :
5040 break loop28;
5041 }
5042 } while (true);
5043
5044 otherlv_4=(Token)match(input,18,FOLLOW_2);
5045
5046 newLeafNode(otherlv_4, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_0_2());
5047
5048
5049 }
5050
5051
5052 }
5053 break;
5054 case 2 :
5055 // InternalSolverLanguage.g:1733:4: ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' )
5056 {
5057 // InternalSolverLanguage.g:1733:4: ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' )
5058 // InternalSolverLanguage.g:1734:5: ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')'
5059 {
5060 // InternalSolverLanguage.g:1734:5: ( (lv_closureType_5_0= ruleClosureType ) )
5061 // InternalSolverLanguage.g:1735:6: (lv_closureType_5_0= ruleClosureType )
5062 {
5063 // InternalSolverLanguage.g:1735:6: (lv_closureType_5_0= ruleClosureType )
5064 // InternalSolverLanguage.g:1736:7: lv_closureType_5_0= ruleClosureType
5065 {
5066
5067 newCompositeNode(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_2_1_0_0());
5068
5069 pushFollow(FOLLOW_6);
5070 lv_closureType_5_0=ruleClosureType();
5071
5072 state._fsp--;
5073
5074
5075 if (current==null) {
5076 current = createModelElementForParent(grammarAccess.getConstraintRule());
5077 }
5078 set(
5079 current,
5080 "closureType",
5081 lv_closureType_5_0,
5082 "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType");
5083 afterParserOrEnumRuleCall();
5084
5085
5086 }
5087
5088
5089 }
5090
5091 otherlv_6=(Token)match(input,17,FOLLOW_22);
5092
5093 newLeafNode(otherlv_6, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_1_1());
5094
5095 // InternalSolverLanguage.g:1757:5: ( (lv_params_7_0= ruleLiteral ) )
5096 // InternalSolverLanguage.g:1758:6: (lv_params_7_0= ruleLiteral )
5097 {
5098 // InternalSolverLanguage.g:1758:6: (lv_params_7_0= ruleLiteral )
5099 // InternalSolverLanguage.g:1759:7: lv_params_7_0= ruleLiteral
5100 {
5101
5102 newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_2_0());
5103
5104 pushFollow(FOLLOW_22);
5105 lv_params_7_0=ruleLiteral();
5106
5107 state._fsp--;
5108
5109
5110 if (current==null) {
5111 current = createModelElementForParent(grammarAccess.getConstraintRule());
5112 }
5113 add(
5114 current,
5115 "params",
5116 lv_params_7_0,
5117 "org.eclipse.viatra.solver.language.SolverLanguage.Literal");
5118 afterParserOrEnumRuleCall();
5119
5120
5121 }
5122
5123
5124 }
5125
5126 // InternalSolverLanguage.g:1776:5: ( (lv_params_8_0= ruleLiteral ) )
5127 // InternalSolverLanguage.g:1777:6: (lv_params_8_0= ruleLiteral )
5128 {
5129 // InternalSolverLanguage.g:1777:6: (lv_params_8_0= ruleLiteral )
5130 // InternalSolverLanguage.g:1778:7: lv_params_8_0= ruleLiteral
5131 {
5132
5133 newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_3_0());
5134
5135 pushFollow(FOLLOW_23);
5136 lv_params_8_0=ruleLiteral();
5137
5138 state._fsp--;
5139
5140
5141 if (current==null) {
5142 current = createModelElementForParent(grammarAccess.getConstraintRule());
5143 }
5144 add(
5145 current,
5146 "params",
5147 lv_params_8_0,
5148 "org.eclipse.viatra.solver.language.SolverLanguage.Literal");
5149 afterParserOrEnumRuleCall();
5150
5151
5152 }
5153
5154
5155 }
5156
5157 otherlv_9=(Token)match(input,18,FOLLOW_2);
5158
5159 newLeafNode(otherlv_9, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_1_4());
5160
5161
5162 }
5163
5164
5165 }
5166 break;
5167
5168 }
5169
5170
5171 }
5172
5173
5174 }
5175
5176
5177 leaveRule();
5178
5179 }
5180
5181 catch (RecognitionException re) {
5182 recover(input,re);
5183 appendSkippedTokens();
5184 }
5185 finally {
5186 }
5187 return current;
5188 }
5189 // $ANTLR end "ruleConstraint"
5190
5191
5192 // $ANTLR start "entryRuleClosureType"
5193 // InternalSolverLanguage.g:1805:1: entryRuleClosureType returns [EObject current=null] : iv_ruleClosureType= ruleClosureType EOF ;
5194 public final EObject entryRuleClosureType() throws RecognitionException {
5195 EObject current = null;
5196
5197 EObject iv_ruleClosureType = null;
5198
5199
5200 try {
5201 // InternalSolverLanguage.g:1805:52: (iv_ruleClosureType= ruleClosureType EOF )
5202 // InternalSolverLanguage.g:1806:2: iv_ruleClosureType= ruleClosureType EOF
5203 {
5204 newCompositeNode(grammarAccess.getClosureTypeRule());
5205 pushFollow(FOLLOW_1);
5206 iv_ruleClosureType=ruleClosureType();
5207
5208 state._fsp--;
5209
5210 current =iv_ruleClosureType;
5211 match(input,EOF,FOLLOW_2);
5212
5213 }
5214
5215 }
5216
5217 catch (RecognitionException re) {
5218 recover(input,re);
5219 appendSkippedTokens();
5220 }
5221 finally {
5222 }
5223 return current;
5224 }
5225 // $ANTLR end "entryRuleClosureType"
5226
5227
5228 // $ANTLR start "ruleClosureType"
5229 // InternalSolverLanguage.g:1812:1: ruleClosureType returns [EObject current=null] : ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) ;
5230 public final EObject ruleClosureType() throws RecognitionException {
5231 EObject current = null;
5232
5233 Token otherlv_1=null;
5234 Token otherlv_3=null;
5235
5236
5237 enterRule();
5238
5239 try {
5240 // InternalSolverLanguage.g:1818:2: ( ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) )
5241 // InternalSolverLanguage.g:1819:2: ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) )
5242 {
5243 // InternalSolverLanguage.g:1819:2: ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) )
5244 int alt30=2;
5245 int LA30_0 = input.LA(1);
5246
5247 if ( (LA30_0==30) ) {
5248 alt30=1;
5249 }
5250 else if ( (LA30_0==29) ) {
5251 alt30=2;
5252 }
5253 else {
5254 NoViableAltException nvae =
5255 new NoViableAltException("", 30, 0, input);
5256
5257 throw nvae;
5258 }
5259 switch (alt30) {
5260 case 1 :
5261 // InternalSolverLanguage.g:1820:3: ( () otherlv_1= '*' )
5262 {
5263 // InternalSolverLanguage.g:1820:3: ( () otherlv_1= '*' )
5264 // InternalSolverLanguage.g:1821:4: () otherlv_1= '*'
5265 {
5266 // InternalSolverLanguage.g:1821:4: ()
5267 // InternalSolverLanguage.g:1822:5:
5268 {
5269
5270 current = forceCreateModelElement(
5271 grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0(),
5272 current);
5273
5274
5275 }
5276
5277 otherlv_1=(Token)match(input,30,FOLLOW_2);
5278
5279 newLeafNode(otherlv_1, grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1());
5280
5281
5282 }
5283
5284
5285 }
5286 break;
5287 case 2 :
5288 // InternalSolverLanguage.g:1834:3: ( () otherlv_3= '+' )
5289 {
5290 // InternalSolverLanguage.g:1834:3: ( () otherlv_3= '+' )
5291 // InternalSolverLanguage.g:1835:4: () otherlv_3= '+'
5292 {
5293 // InternalSolverLanguage.g:1835:4: ()
5294 // InternalSolverLanguage.g:1836:5:
5295 {
5296
5297 current = forceCreateModelElement(
5298 grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0(),
5299 current);
5300
5301
5302 }
5303
5304 otherlv_3=(Token)match(input,29,FOLLOW_2);
5305
5306 newLeafNode(otherlv_3, grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1());
5307
5308
5309 }
5310
5311
5312 }
5313 break;
5314
5315 }
5316
5317
5318 }
5319
5320
5321 leaveRule();
5322
5323 }
5324
5325 catch (RecognitionException re) {
5326 recover(input,re);
5327 appendSkippedTokens();
5328 }
5329 finally {
5330 }
5331 return current;
5332 }
5333 // $ANTLR end "ruleClosureType"
5334
5335
5336 // $ANTLR start "entryRuleLiteral"
5337 // InternalSolverLanguage.g:1851:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ;
5338 public final EObject entryRuleLiteral() throws RecognitionException {
5339 EObject current = null;
5340
5341 EObject iv_ruleLiteral = null;
5342
5343
5344 try {
5345 // InternalSolverLanguage.g:1851:48: (iv_ruleLiteral= ruleLiteral EOF )
5346 // InternalSolverLanguage.g:1852:2: iv_ruleLiteral= ruleLiteral EOF
5347 {
5348 newCompositeNode(grammarAccess.getLiteralRule());
5349 pushFollow(FOLLOW_1);
5350 iv_ruleLiteral=ruleLiteral();
5351
5352 state._fsp--;
5353
5354 current =iv_ruleLiteral;
5355 match(input,EOF,FOLLOW_2);
5356
5357 }
5358
5359 }
5360
5361 catch (RecognitionException re) {
5362 recover(input,re);
5363 appendSkippedTokens();
5364 }
5365 finally {
5366 }
5367 return current;
5368 }
5369 // $ANTLR end "entryRuleLiteral"
5370
5371
5372 // $ANTLR start "ruleLiteral"
5373 // InternalSolverLanguage.g:1858:1: ruleLiteral returns [EObject current=null] : (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject ) ;
5374 public final EObject ruleLiteral() throws RecognitionException {
5375 EObject current = null;
5376
5377 EObject this_Variable_0 = null;
5378
5379 EObject this_DataObject_1 = null;
5380
5381
5382
5383 enterRule();
5384
5385 try {
5386 // InternalSolverLanguage.g:1864:2: ( (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject ) )
5387 // InternalSolverLanguage.g:1865:2: (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject )
5388 {
5389 // InternalSolverLanguage.g:1865:2: (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject )
5390 int alt31=2;
5391 int LA31_0 = input.LA(1);
5392
5393 if ( (LA31_0==RULE_ID) ) {
5394 alt31=1;
5395 }
5396 else if ( (LA31_0==RULE_INT||LA31_0==RULE_STRING||LA31_0==11||(LA31_0>=13 && LA31_0<=14)) ) {
5397 alt31=2;
5398 }
5399 else {
5400 NoViableAltException nvae =
5401 new NoViableAltException("", 31, 0, input);
5402
5403 throw nvae;
5404 }
5405 switch (alt31) {
5406 case 1 :
5407 // InternalSolverLanguage.g:1866:3: this_Variable_0= ruleVariable
5408 {
5409
5410 newCompositeNode(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0());
5411
5412 pushFollow(FOLLOW_2);
5413 this_Variable_0=ruleVariable();
5414
5415 state._fsp--;
5416
5417
5418 current = this_Variable_0;
5419 afterParserOrEnumRuleCall();
5420
5421
5422 }
5423 break;
5424 case 2 :
5425 // InternalSolverLanguage.g:1875:3: this_DataObject_1= ruleDataObject
5426 {
5427
5428 newCompositeNode(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1());
5429
5430 pushFollow(FOLLOW_2);
5431 this_DataObject_1=ruleDataObject();
5432
5433 state._fsp--;
5434
5435
5436 current = this_DataObject_1;
5437 afterParserOrEnumRuleCall();
5438
5439
5440 }
5441 break;
5442
5443 }
5444
5445
5446 }
5447
5448
5449 leaveRule();
5450
5451 }
5452
5453 catch (RecognitionException re) {
5454 recover(input,re);
5455 appendSkippedTokens();
5456 }
5457 finally {
5458 }
5459 return current;
5460 }
5461 // $ANTLR end "ruleLiteral"
5462
5463
5464 // $ANTLR start "entryRuleVariable"
5465 // InternalSolverLanguage.g:1887:1: entryRuleVariable returns [EObject current=null] : iv_ruleVariable= ruleVariable EOF ;
5466 public final EObject entryRuleVariable() throws RecognitionException {
5467 EObject current = null;
5468
5469 EObject iv_ruleVariable = null;
5470
5471
5472 try {
5473 // InternalSolverLanguage.g:1887:49: (iv_ruleVariable= ruleVariable EOF )
5474 // InternalSolverLanguage.g:1888:2: iv_ruleVariable= ruleVariable EOF
5475 {
5476 newCompositeNode(grammarAccess.getVariableRule());
5477 pushFollow(FOLLOW_1);
5478 iv_ruleVariable=ruleVariable();
5479
5480 state._fsp--;
5481
5482 current =iv_ruleVariable;
5483 match(input,EOF,FOLLOW_2);
5484
5485 }
5486
5487 }
5488
5489 catch (RecognitionException re) {
5490 recover(input,re);
5491 appendSkippedTokens();
5492 }
5493 finally {
5494 }
5495 return current;
5496 }
5497 // $ANTLR end "entryRuleVariable"
5498
5499
5500 // $ANTLR start "ruleVariable"
5501 // InternalSolverLanguage.g:1894:1: ruleVariable returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ;
5502 public final EObject ruleVariable() throws RecognitionException {
5503 EObject current = null;
5504
5505 Token lv_name_0_0=null;
5506
5507
5508 enterRule();
5509
5510 try {
5511 // InternalSolverLanguage.g:1900:2: ( ( (lv_name_0_0= RULE_ID ) ) )
5512 // InternalSolverLanguage.g:1901:2: ( (lv_name_0_0= RULE_ID ) )
5513 {
5514 // InternalSolverLanguage.g:1901:2: ( (lv_name_0_0= RULE_ID ) )
5515 // InternalSolverLanguage.g:1902:3: (lv_name_0_0= RULE_ID )
5516 {
5517 // InternalSolverLanguage.g:1902:3: (lv_name_0_0= RULE_ID )
5518 // InternalSolverLanguage.g:1903:4: lv_name_0_0= RULE_ID
5519 {
5520 lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2);
5521
5522 newLeafNode(lv_name_0_0, grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0());
5523
5524
5525 if (current==null) {
5526 current = createModelElement(grammarAccess.getVariableRule());
5527 }
5528 setWithLastConsumed(
5529 current,
5530 "name",
5531 lv_name_0_0,
5532 "org.eclipse.xtext.common.Terminals.ID");
5533
5534
5535 }
5536
5537
5538 }
5539
5540
5541 }
5542
5543
5544 leaveRule();
5545
5546 }
5547
5548 catch (RecognitionException re) {
5549 recover(input,re);
5550 appendSkippedTokens();
5551 }
5552 finally {
5553 }
5554 return current;
5555 }
5556 // $ANTLR end "ruleVariable"
5557
5558
5559 // $ANTLR start "entryRuleAllInstances"
5560 // InternalSolverLanguage.g:1922:1: entryRuleAllInstances returns [EObject current=null] : iv_ruleAllInstances= ruleAllInstances EOF ;
5561 public final EObject entryRuleAllInstances() throws RecognitionException {
5562 EObject current = null;
5563
5564 EObject iv_ruleAllInstances = null;
5565
5566
5567 try {
5568 // InternalSolverLanguage.g:1922:53: (iv_ruleAllInstances= ruleAllInstances EOF )
5569 // InternalSolverLanguage.g:1923:2: iv_ruleAllInstances= ruleAllInstances EOF
5570 {
5571 newCompositeNode(grammarAccess.getAllInstancesRule());
5572 pushFollow(FOLLOW_1);
5573 iv_ruleAllInstances=ruleAllInstances();
5574
5575 state._fsp--;
5576
5577 current =iv_ruleAllInstances;
5578 match(input,EOF,FOLLOW_2);
5579
5580 }
5581
5582 }
5583
5584 catch (RecognitionException re) {
5585 recover(input,re);
5586 appendSkippedTokens();
5587 }
5588 finally {
5589 }
5590 return current;
5591 }
5592 // $ANTLR end "entryRuleAllInstances"
5593
5594
5595 // $ANTLR start "ruleAllInstances"
5596 // InternalSolverLanguage.g:1929:1: ruleAllInstances returns [EObject current=null] : (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) ;
5597 public final EObject ruleAllInstances() throws RecognitionException {
5598 EObject current = null;
5599
5600 Token otherlv_0=null;
5601 EObject lv_symbol_1_0 = null;
5602
5603
5604
5605 enterRule();
5606
5607 try {
5608 // InternalSolverLanguage.g:1935:2: ( (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) )
5609 // InternalSolverLanguage.g:1936:2: (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) )
5610 {
5611 // InternalSolverLanguage.g:1936:2: (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) )
5612 // InternalSolverLanguage.g:1937:3: otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) )
5613 {
5614 otherlv_0=(Token)match(input,19,FOLLOW_18);
5615
5616 newLeafNode(otherlv_0, grammarAccess.getAllInstancesAccess().getColonKeyword_0());
5617
5618 // InternalSolverLanguage.g:1941:3: ( (lv_symbol_1_0= ruleSymbol ) )
5619 // InternalSolverLanguage.g:1942:4: (lv_symbol_1_0= ruleSymbol )
5620 {
5621 // InternalSolverLanguage.g:1942:4: (lv_symbol_1_0= ruleSymbol )
5622 // InternalSolverLanguage.g:1943:5: lv_symbol_1_0= ruleSymbol
5623 {
5624
5625 newCompositeNode(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0());
5626
5627 pushFollow(FOLLOW_2);
5628 lv_symbol_1_0=ruleSymbol();
5629
5630 state._fsp--;
5631
5632
5633 if (current==null) {
5634 current = createModelElementForParent(grammarAccess.getAllInstancesRule());
5635 }
5636 set(
5637 current,
5638 "symbol",
5639 lv_symbol_1_0,
5640 "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
5641 afterParserOrEnumRuleCall();
5642
5643
5644 }
5645
5646
5647 }
5648
5649
5650 }
5651
5652
5653 }
5654
5655
5656 leaveRule();
5657
5658 }
5659
5660 catch (RecognitionException re) {
5661 recover(input,re);
5662 appendSkippedTokens();
5663 }
5664 finally {
5665 }
5666 return current;
5667 }
5668 // $ANTLR end "ruleAllInstances"
5669
5670
5671 // $ANTLR start "entryRuleAllObjects"
5672 // InternalSolverLanguage.g:1964:1: entryRuleAllObjects returns [EObject current=null] : iv_ruleAllObjects= ruleAllObjects EOF ;
5673 public final EObject entryRuleAllObjects() throws RecognitionException {
5674 EObject current = null;
5675
5676 EObject iv_ruleAllObjects = null;
5677
5678
5679 try {
5680 // InternalSolverLanguage.g:1964:51: (iv_ruleAllObjects= ruleAllObjects EOF )
5681 // InternalSolverLanguage.g:1965:2: iv_ruleAllObjects= ruleAllObjects EOF
5682 {
5683 newCompositeNode(grammarAccess.getAllObjectsRule());
5684 pushFollow(FOLLOW_1);
5685 iv_ruleAllObjects=ruleAllObjects();
5686
5687 state._fsp--;
5688
5689 current =iv_ruleAllObjects;
5690 match(input,EOF,FOLLOW_2);
5691
5692 }
5693
5694 }
5695
5696 catch (RecognitionException re) {
5697 recover(input,re);
5698 appendSkippedTokens();
5699 }
5700 finally {
5701 }
5702 return current;
5703 }
5704 // $ANTLR end "entryRuleAllObjects"
5705
5706
5707 // $ANTLR start "ruleAllObjects"
5708 // InternalSolverLanguage.g:1971:1: ruleAllObjects returns [EObject current=null] : ( () otherlv_1= '*' ) ;
5709 public final EObject ruleAllObjects() throws RecognitionException {
5710 EObject current = null;
5711
5712 Token otherlv_1=null;
5713
5714
5715 enterRule();
5716
5717 try {
5718 // InternalSolverLanguage.g:1977:2: ( ( () otherlv_1= '*' ) )
5719 // InternalSolverLanguage.g:1978:2: ( () otherlv_1= '*' )
5720 {
5721 // InternalSolverLanguage.g:1978:2: ( () otherlv_1= '*' )
5722 // InternalSolverLanguage.g:1979:3: () otherlv_1= '*'
5723 {
5724 // InternalSolverLanguage.g:1979:3: ()
5725 // InternalSolverLanguage.g:1980:4:
5726 {
5727
5728 current = forceCreateModelElement(
5729 grammarAccess.getAllObjectsAccess().getAllObjectsAction_0(),
5730 current);
5731
5732
5733 }
5734
5735 otherlv_1=(Token)match(input,30,FOLLOW_2);
5736
5737 newLeafNode(otherlv_1, grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1());
5738
5739
5740 }
5741
5742
5743 }
5744
5745
5746 leaveRule();
5747
5748 }
5749
5750 catch (RecognitionException re) {
5751 recover(input,re);
5752 appendSkippedTokens();
5753 }
5754 finally {
5755 }
5756 return current;
5757 }
5758 // $ANTLR end "ruleAllObjects"
5759
5760
5761 // $ANTLR start "entryRuleDefaultInterpretation"
5762 // InternalSolverLanguage.g:1994:1: entryRuleDefaultInterpretation returns [EObject current=null] : iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF ;
5763 public final EObject entryRuleDefaultInterpretation() throws RecognitionException {
5764 EObject current = null;
5765
5766 EObject iv_ruleDefaultInterpretation = null;
5767
5768
5769 try {
5770 // InternalSolverLanguage.g:1994:62: (iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF )
5771 // InternalSolverLanguage.g:1995:2: iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF
5772 {
5773 newCompositeNode(grammarAccess.getDefaultInterpretationRule());
5774 pushFollow(FOLLOW_1);
5775 iv_ruleDefaultInterpretation=ruleDefaultInterpretation();
5776
5777 state._fsp--;
5778
5779 current =iv_ruleDefaultInterpretation;
5780 match(input,EOF,FOLLOW_2);
5781
5782 }
5783
5784 }
5785
5786 catch (RecognitionException re) {
5787 recover(input,re);
5788 appendSkippedTokens();
5789 }
5790 finally {
5791 }
5792 return current;
5793 }
5794 // $ANTLR end "entryRuleDefaultInterpretation"
5795
5796
5797 // $ANTLR start "ruleDefaultInterpretation"
5798 // InternalSolverLanguage.g:2001:1: ruleDefaultInterpretation returns [EObject current=null] : (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) ;
5799 public final EObject ruleDefaultInterpretation() throws RecognitionException {
5800 EObject current = null;
5801
5802 Token otherlv_0=null;
5803 EObject lv_interpretation_1_0 = null;
5804
5805
5806
5807 enterRule();
5808
5809 try {
5810 // InternalSolverLanguage.g:2007:2: ( (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) )
5811 // InternalSolverLanguage.g:2008:2: (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) )
5812 {
5813 // InternalSolverLanguage.g:2008:2: (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) )
5814 // InternalSolverLanguage.g:2009:3: otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) )
5815 {
5816 otherlv_0=(Token)match(input,31,FOLLOW_18);
5817
5818 newLeafNode(otherlv_0, grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0());
5819
5820 // InternalSolverLanguage.g:2013:3: ( (lv_interpretation_1_0= ruleBasicInterpretation ) )
5821 // InternalSolverLanguage.g:2014:4: (lv_interpretation_1_0= ruleBasicInterpretation )
5822 {
5823 // InternalSolverLanguage.g:2014:4: (lv_interpretation_1_0= ruleBasicInterpretation )
5824 // InternalSolverLanguage.g:2015:5: lv_interpretation_1_0= ruleBasicInterpretation
5825 {
5826
5827 newCompositeNode(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0());
5828
5829 pushFollow(FOLLOW_2);
5830 lv_interpretation_1_0=ruleBasicInterpretation();
5831
5832 state._fsp--;
5833
5834
5835 if (current==null) {
5836 current = createModelElementForParent(grammarAccess.getDefaultInterpretationRule());
5837 }
5838 set(
5839 current,
5840 "interpretation",
5841 lv_interpretation_1_0,
5842 "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation");
5843 afterParserOrEnumRuleCall();
5844
5845
5846 }
5847
5848
5849 }
5850
5851
5852 }
5853
5854
5855 }
5856
5857
5858 leaveRule();
5859
5860 }
5861
5862 catch (RecognitionException re) {
5863 recover(input,re);
5864 appendSkippedTokens();
5865 }
5866 finally {
5867 }
5868 return current;
5869 }
5870 // $ANTLR end "ruleDefaultInterpretation"
5871
5872
5873 // $ANTLR start "entryRuleCDInterpretation"
5874 // InternalSolverLanguage.g:2036:1: entryRuleCDInterpretation returns [EObject current=null] : iv_ruleCDInterpretation= ruleCDInterpretation EOF ;
5875 public final EObject entryRuleCDInterpretation() throws RecognitionException {
5876 EObject current = null;
5877
5878 EObject iv_ruleCDInterpretation = null;
5879
5880
5881 try {
5882 // InternalSolverLanguage.g:2036:57: (iv_ruleCDInterpretation= ruleCDInterpretation EOF )
5883 // InternalSolverLanguage.g:2037:2: iv_ruleCDInterpretation= ruleCDInterpretation EOF
5884 {
5885 newCompositeNode(grammarAccess.getCDInterpretationRule());
5886 pushFollow(FOLLOW_1);
5887 iv_ruleCDInterpretation=ruleCDInterpretation();
5888
5889 state._fsp--;
5890
5891 current =iv_ruleCDInterpretation;
5892 match(input,EOF,FOLLOW_2);
5893
5894 }
5895
5896 }
5897
5898 catch (RecognitionException re) {
5899 recover(input,re);
5900 appendSkippedTokens();
5901 }
5902 finally {
5903 }
5904 return current;
5905 }
5906 // $ANTLR end "entryRuleCDInterpretation"
5907
5908
5909 // $ANTLR start "ruleCDInterpretation"
5910 // InternalSolverLanguage.g:2043:1: ruleCDInterpretation returns [EObject current=null] : (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) ;
5911 public final EObject ruleCDInterpretation() throws RecognitionException {
5912 EObject current = null;
5913
5914 EObject this_ClassInterpretation_0 = null;
5915
5916 EObject this_EnumInterpretation_1 = null;
5917
5918 EObject this_GlobalRelationInterpretation_2 = null;
5919
5920
5921
5922 enterRule();
5923
5924 try {
5925 // InternalSolverLanguage.g:2049:2: ( (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) )
5926 // InternalSolverLanguage.g:2050:2: (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation )
5927 {
5928 // InternalSolverLanguage.g:2050:2: (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation )
5929 int alt32=3;
5930 switch ( input.LA(1) ) {
5931 case 32:
5932 {
5933 alt32=1;
5934 }
5935 break;
5936 case 37:
5937 {
5938 alt32=2;
5939 }
5940 break;
5941 case 38:
5942 {
5943 alt32=3;
5944 }
5945 break;
5946 default:
5947 NoViableAltException nvae =
5948 new NoViableAltException("", 32, 0, input);
5949
5950 throw nvae;
5951 }
5952
5953 switch (alt32) {
5954 case 1 :
5955 // InternalSolverLanguage.g:2051:3: this_ClassInterpretation_0= ruleClassInterpretation
5956 {
5957
5958 newCompositeNode(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0());
5959
5960 pushFollow(FOLLOW_2);
5961 this_ClassInterpretation_0=ruleClassInterpretation();
5962
5963 state._fsp--;
5964
5965
5966 current = this_ClassInterpretation_0;
5967 afterParserOrEnumRuleCall();
5968
5969
5970 }
5971 break;
5972 case 2 :
5973 // InternalSolverLanguage.g:2060:3: this_EnumInterpretation_1= ruleEnumInterpretation
5974 {
5975
5976 newCompositeNode(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1());
5977
5978 pushFollow(FOLLOW_2);
5979 this_EnumInterpretation_1=ruleEnumInterpretation();
5980
5981 state._fsp--;
5982
5983
5984 current = this_EnumInterpretation_1;
5985 afterParserOrEnumRuleCall();
5986
5987
5988 }
5989 break;
5990 case 3 :
5991 // InternalSolverLanguage.g:2069:3: this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation
5992 {
5993
5994 newCompositeNode(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2());
5995
5996 pushFollow(FOLLOW_2);
5997 this_GlobalRelationInterpretation_2=ruleGlobalRelationInterpretation();
5998
5999 state._fsp--;
6000
6001
6002 current = this_GlobalRelationInterpretation_2;
6003 afterParserOrEnumRuleCall();
6004
6005
6006 }
6007 break;
6008
6009 }
6010
6011
6012 }
6013
6014
6015 leaveRule();
6016
6017 }
6018
6019 catch (RecognitionException re) {
6020 recover(input,re);
6021 appendSkippedTokens();
6022 }
6023 finally {
6024 }
6025 return current;
6026 }
6027 // $ANTLR end "ruleCDInterpretation"
6028
6029
6030 // $ANTLR start "entryRuleClassInterpretation"
6031 // InternalSolverLanguage.g:2081:1: entryRuleClassInterpretation returns [EObject current=null] : iv_ruleClassInterpretation= ruleClassInterpretation EOF ;
6032 public final EObject entryRuleClassInterpretation() throws RecognitionException {
6033 EObject current = null;
6034
6035 EObject iv_ruleClassInterpretation = null;
6036
6037
6038 try {
6039 // InternalSolverLanguage.g:2081:60: (iv_ruleClassInterpretation= ruleClassInterpretation EOF )
6040 // InternalSolverLanguage.g:2082:2: iv_ruleClassInterpretation= ruleClassInterpretation EOF
6041 {
6042 newCompositeNode(grammarAccess.getClassInterpretationRule());
6043 pushFollow(FOLLOW_1);
6044 iv_ruleClassInterpretation=ruleClassInterpretation();
6045
6046 state._fsp--;
6047
6048 current =iv_ruleClassInterpretation;
6049 match(input,EOF,FOLLOW_2);
6050
6051 }
6052
6053 }
6054
6055 catch (RecognitionException re) {
6056 recover(input,re);
6057 appendSkippedTokens();
6058 }
6059 finally {
6060 }
6061 return current;
6062 }
6063 // $ANTLR end "entryRuleClassInterpretation"
6064
6065
6066 // $ANTLR start "ruleClassInterpretation"
6067 // InternalSolverLanguage.g:2088:1: ruleClassInterpretation returns [EObject current=null] : ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) ;
6068 public final EObject ruleClassInterpretation() throws RecognitionException {
6069 EObject current = null;
6070
6071 Token lv_abstract_0_0=null;
6072 Token otherlv_1=null;
6073 Token otherlv_3=null;
6074 Token otherlv_5=null;
6075 Token otherlv_7=null;
6076 EObject lv_symbol_2_0 = null;
6077
6078 EObject lv_supertypes_4_0 = null;
6079
6080 EObject lv_fielt_6_0 = null;
6081
6082
6083
6084 enterRule();
6085
6086 try {
6087 // InternalSolverLanguage.g:2094:2: ( ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) )
6088 // InternalSolverLanguage.g:2095:2: ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' )
6089 {
6090 // InternalSolverLanguage.g:2095:2: ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' )
6091 // InternalSolverLanguage.g:2096:3: ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}'
6092 {
6093 // InternalSolverLanguage.g:2096:3: ( (lv_abstract_0_0= 'abstract' ) )
6094 // InternalSolverLanguage.g:2097:4: (lv_abstract_0_0= 'abstract' )
6095 {
6096 // InternalSolverLanguage.g:2097:4: (lv_abstract_0_0= 'abstract' )
6097 // InternalSolverLanguage.g:2098:5: lv_abstract_0_0= 'abstract'
6098 {
6099 lv_abstract_0_0=(Token)match(input,32,FOLLOW_24);
6100
6101 newLeafNode(lv_abstract_0_0, grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0());
6102
6103
6104 if (current==null) {
6105 current = createModelElement(grammarAccess.getClassInterpretationRule());
6106 }
6107 setWithLastConsumed(current, "abstract", true, "abstract");
6108
6109
6110 }
6111
6112
6113 }
6114
6115 otherlv_1=(Token)match(input,33,FOLLOW_10);
6116
6117 newLeafNode(otherlv_1, grammarAccess.getClassInterpretationAccess().getClassKeyword_1());
6118
6119 // InternalSolverLanguage.g:2114:3: ( (lv_symbol_2_0= ruleModelSymbol ) )
6120 // InternalSolverLanguage.g:2115:4: (lv_symbol_2_0= ruleModelSymbol )
6121 {
6122 // InternalSolverLanguage.g:2115:4: (lv_symbol_2_0= ruleModelSymbol )
6123 // InternalSolverLanguage.g:2116:5: lv_symbol_2_0= ruleModelSymbol
6124 {
6125
6126 newCompositeNode(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0());
6127
6128 pushFollow(FOLLOW_25);
6129 lv_symbol_2_0=ruleModelSymbol();
6130
6131 state._fsp--;
6132
6133
6134 if (current==null) {
6135 current = createModelElementForParent(grammarAccess.getClassInterpretationRule());
6136 }
6137 set(
6138 current,
6139 "symbol",
6140 lv_symbol_2_0,
6141 "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
6142 afterParserOrEnumRuleCall();
6143
6144
6145 }
6146
6147
6148 }
6149
6150 // InternalSolverLanguage.g:2133:3: (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )?
6151 int alt34=2;
6152 int LA34_0 = input.LA(1);
6153
6154 if ( (LA34_0==34) ) {
6155 alt34=1;
6156 }
6157 switch (alt34) {
6158 case 1 :
6159 // InternalSolverLanguage.g:2134:4: otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+
6160 {
6161 otherlv_3=(Token)match(input,34,FOLLOW_10);
6162
6163 newLeafNode(otherlv_3, grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0());
6164
6165 // InternalSolverLanguage.g:2138:4: ( (lv_supertypes_4_0= ruleModelSymbol ) )+
6166 int cnt33=0;
6167 loop33:
6168 do {
6169 int alt33=2;
6170 int LA33_0 = input.LA(1);
6171
6172 if ( (LA33_0==RULE_ID) ) {
6173 alt33=1;
6174 }
6175
6176
6177 switch (alt33) {
6178 case 1 :
6179 // InternalSolverLanguage.g:2139:5: (lv_supertypes_4_0= ruleModelSymbol )
6180 {
6181 // InternalSolverLanguage.g:2139:5: (lv_supertypes_4_0= ruleModelSymbol )
6182 // InternalSolverLanguage.g:2140:6: lv_supertypes_4_0= ruleModelSymbol
6183 {
6184
6185 newCompositeNode(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0());
6186
6187 pushFollow(FOLLOW_26);
6188 lv_supertypes_4_0=ruleModelSymbol();
6189
6190 state._fsp--;
6191
6192
6193 if (current==null) {
6194 current = createModelElementForParent(grammarAccess.getClassInterpretationRule());
6195 }
6196 add(
6197 current,
6198 "supertypes",
6199 lv_supertypes_4_0,
6200 "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
6201 afterParserOrEnumRuleCall();
6202
6203
6204 }
6205
6206
6207 }
6208 break;
6209
6210 default :
6211 if ( cnt33 >= 1 ) break loop33;
6212 EarlyExitException eee =
6213 new EarlyExitException(33, input);
6214 throw eee;
6215 }
6216 cnt33++;
6217 } while (true);
6218
6219
6220 }
6221 break;
6222
6223 }
6224
6225 otherlv_5=(Token)match(input,35,FOLLOW_27);
6226
6227 newLeafNode(otherlv_5, grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4());
6228
6229 // InternalSolverLanguage.g:2162:3: ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )*
6230 loop35:
6231 do {
6232 int alt35=2;
6233 int LA35_0 = input.LA(1);
6234
6235 if ( (LA35_0==38) ) {
6236 alt35=1;
6237 }
6238
6239
6240 switch (alt35) {
6241 case 1 :
6242 // InternalSolverLanguage.g:2163:4: (lv_fielt_6_0= ruleFieldRelationInterpretation )
6243 {
6244 // InternalSolverLanguage.g:2163:4: (lv_fielt_6_0= ruleFieldRelationInterpretation )
6245 // InternalSolverLanguage.g:2164:5: lv_fielt_6_0= ruleFieldRelationInterpretation
6246 {
6247
6248 newCompositeNode(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0());
6249
6250 pushFollow(FOLLOW_27);
6251 lv_fielt_6_0=ruleFieldRelationInterpretation();
6252
6253 state._fsp--;
6254
6255
6256 if (current==null) {
6257 current = createModelElementForParent(grammarAccess.getClassInterpretationRule());
6258 }
6259 add(
6260 current,
6261 "fielt",
6262 lv_fielt_6_0,
6263 "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation");
6264 afterParserOrEnumRuleCall();
6265
6266
6267 }
6268
6269
6270 }
6271 break;
6272
6273 default :
6274 break loop35;
6275 }
6276 } while (true);
6277
6278 otherlv_7=(Token)match(input,36,FOLLOW_2);
6279
6280 newLeafNode(otherlv_7, grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6());
6281
6282
6283 }
6284
6285
6286 }
6287
6288
6289 leaveRule();
6290
6291 }
6292
6293 catch (RecognitionException re) {
6294 recover(input,re);
6295 appendSkippedTokens();
6296 }
6297 finally {
6298 }
6299 return current;
6300 }
6301 // $ANTLR end "ruleClassInterpretation"
6302
6303
6304 // $ANTLR start "entryRuleEnumInterpretation"
6305 // InternalSolverLanguage.g:2189:1: entryRuleEnumInterpretation returns [EObject current=null] : iv_ruleEnumInterpretation= ruleEnumInterpretation EOF ;
6306 public final EObject entryRuleEnumInterpretation() throws RecognitionException {
6307 EObject current = null;
6308
6309 EObject iv_ruleEnumInterpretation = null;
6310
6311
6312 try {
6313 // InternalSolverLanguage.g:2189:59: (iv_ruleEnumInterpretation= ruleEnumInterpretation EOF )
6314 // InternalSolverLanguage.g:2190:2: iv_ruleEnumInterpretation= ruleEnumInterpretation EOF
6315 {
6316 newCompositeNode(grammarAccess.getEnumInterpretationRule());
6317 pushFollow(FOLLOW_1);
6318 iv_ruleEnumInterpretation=ruleEnumInterpretation();
6319
6320 state._fsp--;
6321
6322 current =iv_ruleEnumInterpretation;
6323 match(input,EOF,FOLLOW_2);
6324
6325 }
6326
6327 }
6328
6329 catch (RecognitionException re) {
6330 recover(input,re);
6331 appendSkippedTokens();
6332 }
6333 finally {
6334 }
6335 return current;
6336 }
6337 // $ANTLR end "entryRuleEnumInterpretation"
6338
6339
6340 // $ANTLR start "ruleEnumInterpretation"
6341 // InternalSolverLanguage.g:2196:1: ruleEnumInterpretation returns [EObject current=null] : (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) ;
6342 public final EObject ruleEnumInterpretation() throws RecognitionException {
6343 EObject current = null;
6344
6345 Token otherlv_0=null;
6346 Token otherlv_2=null;
6347 Token otherlv_4=null;
6348 EObject lv_Symbol_1_0 = null;
6349
6350 EObject lv_objects_3_0 = null;
6351
6352
6353
6354 enterRule();
6355
6356 try {
6357 // InternalSolverLanguage.g:2202:2: ( (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) )
6358 // InternalSolverLanguage.g:2203:2: (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' )
6359 {
6360 // InternalSolverLanguage.g:2203:2: (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' )
6361 // InternalSolverLanguage.g:2204:3: otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}'
6362 {
6363 otherlv_0=(Token)match(input,37,FOLLOW_10);
6364
6365 newLeafNode(otherlv_0, grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0());
6366
6367 // InternalSolverLanguage.g:2208:3: ( (lv_Symbol_1_0= ruleModelSymbol ) )
6368 // InternalSolverLanguage.g:2209:4: (lv_Symbol_1_0= ruleModelSymbol )
6369 {
6370 // InternalSolverLanguage.g:2209:4: (lv_Symbol_1_0= ruleModelSymbol )
6371 // InternalSolverLanguage.g:2210:5: lv_Symbol_1_0= ruleModelSymbol
6372 {
6373
6374 newCompositeNode(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0());
6375
6376 pushFollow(FOLLOW_28);
6377 lv_Symbol_1_0=ruleModelSymbol();
6378
6379 state._fsp--;
6380
6381
6382 if (current==null) {
6383 current = createModelElementForParent(grammarAccess.getEnumInterpretationRule());
6384 }
6385 set(
6386 current,
6387 "Symbol",
6388 lv_Symbol_1_0,
6389 "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
6390 afterParserOrEnumRuleCall();
6391
6392
6393 }
6394
6395
6396 }
6397
6398 otherlv_2=(Token)match(input,35,FOLLOW_11);
6399
6400 newLeafNode(otherlv_2, grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2());
6401
6402 // InternalSolverLanguage.g:2231:3: ( (lv_objects_3_0= ruleNamedObject ) )+
6403 int cnt36=0;
6404 loop36:
6405 do {
6406 int alt36=2;
6407 int LA36_0 = input.LA(1);
6408
6409 if ( (LA36_0==26) ) {
6410 alt36=1;
6411 }
6412
6413
6414 switch (alt36) {
6415 case 1 :
6416 // InternalSolverLanguage.g:2232:4: (lv_objects_3_0= ruleNamedObject )
6417 {
6418 // InternalSolverLanguage.g:2232:4: (lv_objects_3_0= ruleNamedObject )
6419 // InternalSolverLanguage.g:2233:5: lv_objects_3_0= ruleNamedObject
6420 {
6421
6422 newCompositeNode(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0());
6423
6424 pushFollow(FOLLOW_29);
6425 lv_objects_3_0=ruleNamedObject();
6426
6427 state._fsp--;
6428
6429
6430 if (current==null) {
6431 current = createModelElementForParent(grammarAccess.getEnumInterpretationRule());
6432 }
6433 add(
6434 current,
6435 "objects",
6436 lv_objects_3_0,
6437 "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject");
6438 afterParserOrEnumRuleCall();
6439
6440
6441 }
6442
6443
6444 }
6445 break;
6446
6447 default :
6448 if ( cnt36 >= 1 ) break loop36;
6449 EarlyExitException eee =
6450 new EarlyExitException(36, input);
6451 throw eee;
6452 }
6453 cnt36++;
6454 } while (true);
6455
6456 otherlv_4=(Token)match(input,36,FOLLOW_2);
6457
6458 newLeafNode(otherlv_4, grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4());
6459
6460
6461 }
6462
6463
6464 }
6465
6466
6467 leaveRule();
6468
6469 }
6470
6471 catch (RecognitionException re) {
6472 recover(input,re);
6473 appendSkippedTokens();
6474 }
6475 finally {
6476 }
6477 return current;
6478 }
6479 // $ANTLR end "ruleEnumInterpretation"
6480
6481
6482 // $ANTLR start "entryRuleFieldRelationInterpretation"
6483 // InternalSolverLanguage.g:2258:1: entryRuleFieldRelationInterpretation returns [EObject current=null] : iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF ;
6484 public final EObject entryRuleFieldRelationInterpretation() throws RecognitionException {
6485 EObject current = null;
6486
6487 EObject iv_ruleFieldRelationInterpretation = null;
6488
6489
6490 try {
6491 // InternalSolverLanguage.g:2258:68: (iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF )
6492 // InternalSolverLanguage.g:2259:2: iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF
6493 {
6494 newCompositeNode(grammarAccess.getFieldRelationInterpretationRule());
6495 pushFollow(FOLLOW_1);
6496 iv_ruleFieldRelationInterpretation=ruleFieldRelationInterpretation();
6497
6498 state._fsp--;
6499
6500 current =iv_ruleFieldRelationInterpretation;
6501 match(input,EOF,FOLLOW_2);
6502
6503 }
6504
6505 }
6506
6507 catch (RecognitionException re) {
6508 recover(input,re);
6509 appendSkippedTokens();
6510 }
6511 finally {
6512 }
6513 return current;
6514 }
6515 // $ANTLR end "entryRuleFieldRelationInterpretation"
6516
6517
6518 // $ANTLR start "ruleFieldRelationInterpretation"
6519 // InternalSolverLanguage.g:2265:1: ruleFieldRelationInterpretation returns [EObject current=null] : ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) ;
6520 public final EObject ruleFieldRelationInterpretation() throws RecognitionException {
6521 EObject current = null;
6522
6523 Token lv_containment_0_0=null;
6524 Token otherlv_2=null;
6525 EObject lv_symbol_1_0 = null;
6526
6527 EObject lv_multiplicity_3_0 = null;
6528
6529 EObject lv_target_4_0 = null;
6530
6531
6532
6533 enterRule();
6534
6535 try {
6536 // InternalSolverLanguage.g:2271:2: ( ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) )
6537 // InternalSolverLanguage.g:2272:2: ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) )
6538 {
6539 // InternalSolverLanguage.g:2272:2: ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) )
6540 // InternalSolverLanguage.g:2273:3: ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) )
6541 {
6542 // InternalSolverLanguage.g:2273:3: ( (lv_containment_0_0= 'containment' ) )
6543 // InternalSolverLanguage.g:2274:4: (lv_containment_0_0= 'containment' )
6544 {
6545 // InternalSolverLanguage.g:2274:4: (lv_containment_0_0= 'containment' )
6546 // InternalSolverLanguage.g:2275:5: lv_containment_0_0= 'containment'
6547 {
6548 lv_containment_0_0=(Token)match(input,38,FOLLOW_10);
6549
6550 newLeafNode(lv_containment_0_0, grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
6551
6552
6553 if (current==null) {
6554 current = createModelElement(grammarAccess.getFieldRelationInterpretationRule());
6555 }
6556 setWithLastConsumed(current, "containment", true, "containment");
6557
6558
6559 }
6560
6561
6562 }
6563
6564 // InternalSolverLanguage.g:2287:3: ( (lv_symbol_1_0= ruleModelSymbol ) )
6565 // InternalSolverLanguage.g:2288:4: (lv_symbol_1_0= ruleModelSymbol )
6566 {
6567 // InternalSolverLanguage.g:2288:4: (lv_symbol_1_0= ruleModelSymbol )
6568 // InternalSolverLanguage.g:2289:5: lv_symbol_1_0= ruleModelSymbol
6569 {
6570
6571 newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0());
6572
6573 pushFollow(FOLLOW_8);
6574 lv_symbol_1_0=ruleModelSymbol();
6575
6576 state._fsp--;
6577
6578
6579 if (current==null) {
6580 current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule());
6581 }
6582 set(
6583 current,
6584 "symbol",
6585 lv_symbol_1_0,
6586 "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
6587 afterParserOrEnumRuleCall();
6588
6589
6590 }
6591
6592
6593 }
6594
6595 otherlv_2=(Token)match(input,19,FOLLOW_30);
6596
6597 newLeafNode(otherlv_2, grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2());
6598
6599 // InternalSolverLanguage.g:2310:3: ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )?
6600 int alt37=2;
6601 int LA37_0 = input.LA(1);
6602
6603 if ( (LA37_0==RULE_INT) ) {
6604 alt37=1;
6605 }
6606 switch (alt37) {
6607 case 1 :
6608 // InternalSolverLanguage.g:2311:4: (lv_multiplicity_3_0= ruleMultiplicityDefinition )
6609 {
6610 // InternalSolverLanguage.g:2311:4: (lv_multiplicity_3_0= ruleMultiplicityDefinition )
6611 // InternalSolverLanguage.g:2312:5: lv_multiplicity_3_0= ruleMultiplicityDefinition
6612 {
6613
6614 newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0());
6615
6616 pushFollow(FOLLOW_18);
6617 lv_multiplicity_3_0=ruleMultiplicityDefinition();
6618
6619 state._fsp--;
6620
6621
6622 if (current==null) {
6623 current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule());
6624 }
6625 set(
6626 current,
6627 "multiplicity",
6628 lv_multiplicity_3_0,
6629 "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition");
6630 afterParserOrEnumRuleCall();
6631
6632
6633 }
6634
6635
6636 }
6637 break;
6638
6639 }
6640
6641 // InternalSolverLanguage.g:2329:3: ( (lv_target_4_0= ruleSymbol ) )
6642 // InternalSolverLanguage.g:2330:4: (lv_target_4_0= ruleSymbol )
6643 {
6644 // InternalSolverLanguage.g:2330:4: (lv_target_4_0= ruleSymbol )
6645 // InternalSolverLanguage.g:2331:5: lv_target_4_0= ruleSymbol
6646 {
6647
6648 newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0());
6649
6650 pushFollow(FOLLOW_2);
6651 lv_target_4_0=ruleSymbol();
6652
6653 state._fsp--;
6654
6655
6656 if (current==null) {
6657 current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule());
6658 }
6659 set(
6660 current,
6661 "target",
6662 lv_target_4_0,
6663 "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
6664 afterParserOrEnumRuleCall();
6665
6666
6667 }
6668
6669
6670 }
6671
6672
6673 }
6674
6675
6676 }
6677
6678
6679 leaveRule();
6680
6681 }
6682
6683 catch (RecognitionException re) {
6684 recover(input,re);
6685 appendSkippedTokens();
6686 }
6687 finally {
6688 }
6689 return current;
6690 }
6691 // $ANTLR end "ruleFieldRelationInterpretation"
6692
6693
6694 // $ANTLR start "entryRuleGlobalRelationInterpretation"
6695 // InternalSolverLanguage.g:2352:1: entryRuleGlobalRelationInterpretation returns [EObject current=null] : iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF ;
6696 public final EObject entryRuleGlobalRelationInterpretation() throws RecognitionException {
6697 EObject current = null;
6698
6699 EObject iv_ruleGlobalRelationInterpretation = null;
6700
6701
6702 try {
6703 // InternalSolverLanguage.g:2352:69: (iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF )
6704 // InternalSolverLanguage.g:2353:2: iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF
6705 {
6706 newCompositeNode(grammarAccess.getGlobalRelationInterpretationRule());
6707 pushFollow(FOLLOW_1);
6708 iv_ruleGlobalRelationInterpretation=ruleGlobalRelationInterpretation();
6709
6710 state._fsp--;
6711
6712 current =iv_ruleGlobalRelationInterpretation;
6713 match(input,EOF,FOLLOW_2);
6714
6715 }
6716
6717 }
6718
6719 catch (RecognitionException re) {
6720 recover(input,re);
6721 appendSkippedTokens();
6722 }
6723 finally {
6724 }
6725 return current;
6726 }
6727 // $ANTLR end "entryRuleGlobalRelationInterpretation"
6728
6729
6730 // $ANTLR start "ruleGlobalRelationInterpretation"
6731 // InternalSolverLanguage.g:2359:1: ruleGlobalRelationInterpretation returns [EObject current=null] : ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) ;
6732 public final EObject ruleGlobalRelationInterpretation() throws RecognitionException {
6733 EObject current = null;
6734
6735 Token lv_containment_0_0=null;
6736 Token otherlv_1=null;
6737 Token otherlv_3=null;
6738 EObject lv_symbol_2_0 = null;
6739
6740 EObject lv_sourceMultiplicity_4_0 = null;
6741
6742 EObject lv_source_5_0 = null;
6743
6744 EObject lv_targetMultiplicity_6_0 = null;
6745
6746 EObject lv_target_7_0 = null;
6747
6748
6749
6750 enterRule();
6751
6752 try {
6753 // InternalSolverLanguage.g:2365:2: ( ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) )
6754 // InternalSolverLanguage.g:2366:2: ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) )
6755 {
6756 // InternalSolverLanguage.g:2366:2: ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) )
6757 // InternalSolverLanguage.g:2367:3: ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) )
6758 {
6759 // InternalSolverLanguage.g:2367:3: ( (lv_containment_0_0= 'containment' ) )
6760 // InternalSolverLanguage.g:2368:4: (lv_containment_0_0= 'containment' )
6761 {
6762 // InternalSolverLanguage.g:2368:4: (lv_containment_0_0= 'containment' )
6763 // InternalSolverLanguage.g:2369:5: lv_containment_0_0= 'containment'
6764 {
6765 lv_containment_0_0=(Token)match(input,38,FOLLOW_31);
6766
6767 newLeafNode(lv_containment_0_0, grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
6768
6769
6770 if (current==null) {
6771 current = createModelElement(grammarAccess.getGlobalRelationInterpretationRule());
6772 }
6773 setWithLastConsumed(current, "containment", true, "containment");
6774
6775
6776 }
6777
6778
6779 }
6780
6781 otherlv_1=(Token)match(input,39,FOLLOW_10);
6782
6783 newLeafNode(otherlv_1, grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1());
6784
6785 // InternalSolverLanguage.g:2385:3: ( (lv_symbol_2_0= ruleModelSymbol ) )
6786 // InternalSolverLanguage.g:2386:4: (lv_symbol_2_0= ruleModelSymbol )
6787 {
6788 // InternalSolverLanguage.g:2386:4: (lv_symbol_2_0= ruleModelSymbol )
6789 // InternalSolverLanguage.g:2387:5: lv_symbol_2_0= ruleModelSymbol
6790 {
6791
6792 newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0());
6793
6794 pushFollow(FOLLOW_8);
6795 lv_symbol_2_0=ruleModelSymbol();
6796
6797 state._fsp--;
6798
6799
6800 if (current==null) {
6801 current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
6802 }
6803 set(
6804 current,
6805 "symbol",
6806 lv_symbol_2_0,
6807 "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
6808 afterParserOrEnumRuleCall();
6809
6810
6811 }
6812
6813
6814 }
6815
6816 otherlv_3=(Token)match(input,19,FOLLOW_30);
6817
6818 newLeafNode(otherlv_3, grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3());
6819
6820 // InternalSolverLanguage.g:2408:3: ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )?
6821 int alt38=2;
6822 int LA38_0 = input.LA(1);
6823
6824 if ( (LA38_0==RULE_INT) ) {
6825 alt38=1;
6826 }
6827 switch (alt38) {
6828 case 1 :
6829 // InternalSolverLanguage.g:2409:4: (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition )
6830 {
6831 // InternalSolverLanguage.g:2409:4: (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition )
6832 // InternalSolverLanguage.g:2410:5: lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition
6833 {
6834
6835 newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0());
6836
6837 pushFollow(FOLLOW_18);
6838 lv_sourceMultiplicity_4_0=ruleMultiplicityDefinition();
6839
6840 state._fsp--;
6841
6842
6843 if (current==null) {
6844 current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
6845 }
6846 set(
6847 current,
6848 "sourceMultiplicity",
6849 lv_sourceMultiplicity_4_0,
6850 "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition");
6851 afterParserOrEnumRuleCall();
6852
6853
6854 }
6855
6856
6857 }
6858 break;
6859
6860 }
6861
6862 // InternalSolverLanguage.g:2427:3: ( (lv_source_5_0= ruleSymbol ) )
6863 // InternalSolverLanguage.g:2428:4: (lv_source_5_0= ruleSymbol )
6864 {
6865 // InternalSolverLanguage.g:2428:4: (lv_source_5_0= ruleSymbol )
6866 // InternalSolverLanguage.g:2429:5: lv_source_5_0= ruleSymbol
6867 {
6868
6869 newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0());
6870
6871 pushFollow(FOLLOW_30);
6872 lv_source_5_0=ruleSymbol();
6873
6874 state._fsp--;
6875
6876
6877 if (current==null) {
6878 current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
6879 }
6880 set(
6881 current,
6882 "source",
6883 lv_source_5_0,
6884 "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
6885 afterParserOrEnumRuleCall();
6886
6887
6888 }
6889
6890
6891 }
6892
6893 // InternalSolverLanguage.g:2446:3: ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )?
6894 int alt39=2;
6895 int LA39_0 = input.LA(1);
6896
6897 if ( (LA39_0==RULE_INT) ) {
6898 alt39=1;
6899 }
6900 switch (alt39) {
6901 case 1 :
6902 // InternalSolverLanguage.g:2447:4: (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition )
6903 {
6904 // InternalSolverLanguage.g:2447:4: (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition )
6905 // InternalSolverLanguage.g:2448:5: lv_targetMultiplicity_6_0= ruleMultiplicityDefinition
6906 {
6907
6908 newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0());
6909
6910 pushFollow(FOLLOW_18);
6911 lv_targetMultiplicity_6_0=ruleMultiplicityDefinition();
6912
6913 state._fsp--;
6914
6915
6916 if (current==null) {
6917 current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
6918 }
6919 set(
6920 current,
6921 "targetMultiplicity",
6922 lv_targetMultiplicity_6_0,
6923 "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition");
6924 afterParserOrEnumRuleCall();
6925
6926
6927 }
6928
6929
6930 }
6931 break;
6932
6933 }
6934
6935 // InternalSolverLanguage.g:2465:3: ( (lv_target_7_0= ruleSymbol ) )
6936 // InternalSolverLanguage.g:2466:4: (lv_target_7_0= ruleSymbol )
6937 {
6938 // InternalSolverLanguage.g:2466:4: (lv_target_7_0= ruleSymbol )
6939 // InternalSolverLanguage.g:2467:5: lv_target_7_0= ruleSymbol
6940 {
6941
6942 newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0());
6943
6944 pushFollow(FOLLOW_2);
6945 lv_target_7_0=ruleSymbol();
6946
6947 state._fsp--;
6948
6949
6950 if (current==null) {
6951 current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
6952 }
6953 set(
6954 current,
6955 "target",
6956 lv_target_7_0,
6957 "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
6958 afterParserOrEnumRuleCall();
6959
6960
6961 }
6962
6963
6964 }
6965
6966
6967 }
6968
6969
6970 }
6971
6972
6973 leaveRule();
6974
6975 }
6976
6977 catch (RecognitionException re) {
6978 recover(input,re);
6979 appendSkippedTokens();
6980 }
6981 finally {
6982 }
6983 return current;
6984 }
6985 // $ANTLR end "ruleGlobalRelationInterpretation"
6986
6987
6988 // $ANTLR start "entryRuleMultiplicityDefinition"
6989 // InternalSolverLanguage.g:2488:1: entryRuleMultiplicityDefinition returns [EObject current=null] : iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF ;
6990 public final EObject entryRuleMultiplicityDefinition() throws RecognitionException {
6991 EObject current = null;
6992
6993 EObject iv_ruleMultiplicityDefinition = null;
6994
6995
6996 try {
6997 // InternalSolverLanguage.g:2488:63: (iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF )
6998 // InternalSolverLanguage.g:2489:2: iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF
6999 {
7000 newCompositeNode(grammarAccess.getMultiplicityDefinitionRule());
7001 pushFollow(FOLLOW_1);
7002 iv_ruleMultiplicityDefinition=ruleMultiplicityDefinition();
7003
7004 state._fsp--;
7005
7006 current =iv_ruleMultiplicityDefinition;
7007 match(input,EOF,FOLLOW_2);
7008
7009 }
7010
7011 }
7012
7013 catch (RecognitionException re) {
7014 recover(input,re);
7015 appendSkippedTokens();
7016 }
7017 finally {
7018 }
7019 return current;
7020 }
7021 // $ANTLR end "entryRuleMultiplicityDefinition"
7022
7023
7024 // $ANTLR start "ruleMultiplicityDefinition"
7025 // InternalSolverLanguage.g:2495:1: ruleMultiplicityDefinition returns [EObject current=null] : ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) ;
7026 public final EObject ruleMultiplicityDefinition() throws RecognitionException {
7027 EObject current = null;
7028
7029 Token lv_lower_0_0=null;
7030 Token otherlv_1=null;
7031 Token lv_upper_2_0=null;
7032 Token lv_unlimitedUpper_3_0=null;
7033
7034
7035 enterRule();
7036
7037 try {
7038 // InternalSolverLanguage.g:2501:2: ( ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) )
7039 // InternalSolverLanguage.g:2502:2: ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) )
7040 {
7041 // InternalSolverLanguage.g:2502:2: ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) )
7042 // InternalSolverLanguage.g:2503:3: ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) )
7043 {
7044 // InternalSolverLanguage.g:2503:3: ( (lv_lower_0_0= RULE_INT ) )
7045 // InternalSolverLanguage.g:2504:4: (lv_lower_0_0= RULE_INT )
7046 {
7047 // InternalSolverLanguage.g:2504:4: (lv_lower_0_0= RULE_INT )
7048 // InternalSolverLanguage.g:2505:5: lv_lower_0_0= RULE_INT
7049 {
7050 lv_lower_0_0=(Token)match(input,RULE_INT,FOLLOW_32);
7051
7052 newLeafNode(lv_lower_0_0, grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0());
7053
7054
7055 if (current==null) {
7056 current = createModelElement(grammarAccess.getMultiplicityDefinitionRule());
7057 }
7058 setWithLastConsumed(
7059 current,
7060 "lower",
7061 lv_lower_0_0,
7062 "org.eclipse.xtext.common.Terminals.INT");
7063
7064
7065 }
7066
7067
7068 }
7069
7070 otherlv_1=(Token)match(input,40,FOLLOW_33);
7071
7072 newLeafNode(otherlv_1, grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1());
7073
7074 // InternalSolverLanguage.g:2525:3: ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) )
7075 int alt40=2;
7076 int LA40_0 = input.LA(1);
7077
7078 if ( (LA40_0==RULE_INT) ) {
7079 alt40=1;
7080 }
7081 else if ( (LA40_0==30) ) {
7082 alt40=2;
7083 }
7084 else {
7085 NoViableAltException nvae =
7086 new NoViableAltException("", 40, 0, input);
7087
7088 throw nvae;
7089 }
7090 switch (alt40) {
7091 case 1 :
7092 // InternalSolverLanguage.g:2526:4: ( (lv_upper_2_0= RULE_INT ) )
7093 {
7094 // InternalSolverLanguage.g:2526:4: ( (lv_upper_2_0= RULE_INT ) )
7095 // InternalSolverLanguage.g:2527:5: (lv_upper_2_0= RULE_INT )
7096 {
7097 // InternalSolverLanguage.g:2527:5: (lv_upper_2_0= RULE_INT )
7098 // InternalSolverLanguage.g:2528:6: lv_upper_2_0= RULE_INT
7099 {
7100 lv_upper_2_0=(Token)match(input,RULE_INT,FOLLOW_2);
7101
7102 newLeafNode(lv_upper_2_0, grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0());
7103
7104
7105 if (current==null) {
7106 current = createModelElement(grammarAccess.getMultiplicityDefinitionRule());
7107 }
7108 setWithLastConsumed(
7109 current,
7110 "upper",
7111 lv_upper_2_0,
7112 "org.eclipse.xtext.common.Terminals.INT");
7113
7114
7115 }
7116
7117
7118 }
7119
7120
7121 }
7122 break;
7123 case 2 :
7124 // InternalSolverLanguage.g:2545:4: ( (lv_unlimitedUpper_3_0= '*' ) )
7125 {
7126 // InternalSolverLanguage.g:2545:4: ( (lv_unlimitedUpper_3_0= '*' ) )
7127 // InternalSolverLanguage.g:2546:5: (lv_unlimitedUpper_3_0= '*' )
7128 {
7129 // InternalSolverLanguage.g:2546:5: (lv_unlimitedUpper_3_0= '*' )
7130 // InternalSolverLanguage.g:2547:6: lv_unlimitedUpper_3_0= '*'
7131 {
7132 lv_unlimitedUpper_3_0=(Token)match(input,30,FOLLOW_2);
7133
7134 newLeafNode(lv_unlimitedUpper_3_0, grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0());
7135
7136
7137 if (current==null) {
7138 current = createModelElement(grammarAccess.getMultiplicityDefinitionRule());
7139 }
7140 setWithLastConsumed(current, "unlimitedUpper", true, "*");
7141
7142
7143 }
7144
7145
7146 }
7147
7148
7149 }
7150 break;
7151
7152 }
7153
7154
7155 }
7156
7157
7158 }
7159
7160
7161 leaveRule();
7162
7163 }
7164
7165 catch (RecognitionException re) {
7166 recover(input,re);
7167 appendSkippedTokens();
7168 }
7169 finally {
7170 }
7171 return current;
7172 }
7173 // $ANTLR end "ruleMultiplicityDefinition"
7174
7175 // Delegated rules
7176
7177
7178
7179
7180 public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
7181 public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
7182 public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x000000618BF10022L});
7183 public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L});
7184 public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000001000L});
7185 public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000020000L});
7186 public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x00000000440C6870L});
7187 public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000080000L});
7188 public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x000000000001E000L});
7189 public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000020L});
7190 public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000004000000L});
7191 public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000040020L});
7192 public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000030007820L});
7193 public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000010001000L});
7194 public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000030003820L});
7195 public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000020020L});
7196 public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000080002L});
7197 public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000003F00020L});
7198 public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000020000822L});
7199 public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000060020000L});
7200 public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000004046870L});
7201 public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000004006870L});
7202 public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000040000L});
7203 public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000200000000L});
7204 public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000C00000000L});
7205 public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000800000020L});
7206 public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000005000000000L});
7207 public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000800000000L});
7208 public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000001004000000L});
7209 public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000003F00030L});
7210 public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000008000000000L});
7211 public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000010000000000L});
7212 public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000040000010L});
7213
7214} \ No newline at end of file
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-19 18:19:06 +0000