diff options
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr')
6 files changed, 11581 insertions, 0 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java new file mode 100644 index 00000000..059473c8 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java | |||
| @@ -0,0 +1,16 @@ | |||
| 1 | /* | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.parser.antlr; | ||
| 5 | |||
| 6 | import java.io.InputStream; | ||
| 7 | import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider; | ||
| 8 | |||
| 9 | public class SolverLanguageAntlrTokenFileProvider implements IAntlrTokenFileProvider { | ||
| 10 | |||
| 11 | @Override | ||
| 12 | public InputStream getAntlrTokenFile() { | ||
| 13 | ClassLoader classLoader = getClass().getClassLoader(); | ||
| 14 | return classLoader.getResourceAsStream("org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens"); | ||
| 15 | } | ||
| 16 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java new file mode 100644 index 00000000..7155770e --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java | |||
| @@ -0,0 +1,40 @@ | |||
| 1 | /* | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.parser.antlr; | ||
| 5 | |||
| 6 | import com.google.inject.Inject; | ||
| 7 | import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser; | ||
| 8 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
| 9 | import org.eclipse.xtext.parser.antlr.AbstractAntlrParser; | ||
| 10 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
| 11 | |||
| 12 | public class SolverLanguageParser extends AbstractAntlrParser { | ||
| 13 | |||
| 14 | @Inject | ||
| 15 | private SolverLanguageGrammarAccess grammarAccess; | ||
| 16 | |||
| 17 | @Override | ||
| 18 | protected void setInitialHiddenTokens(XtextTokenStream tokenStream) { | ||
| 19 | tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT"); | ||
| 20 | } | ||
| 21 | |||
| 22 | |||
| 23 | @Override | ||
| 24 | protected InternalSolverLanguageParser createParser(XtextTokenStream stream) { | ||
| 25 | return new InternalSolverLanguageParser(stream, getGrammarAccess()); | ||
| 26 | } | ||
| 27 | |||
| 28 | @Override | ||
| 29 | protected String getDefaultRuleName() { | ||
| 30 | return "Problem"; | ||
| 31 | } | ||
| 32 | |||
| 33 | public SolverLanguageGrammarAccess getGrammarAccess() { | ||
| 34 | return this.grammarAccess; | ||
| 35 | } | ||
| 36 | |||
| 37 | public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) { | ||
| 38 | this.grammarAccess = grammarAccess; | ||
| 39 | } | ||
| 40 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g new file mode 100644 index 00000000..afd73c2d --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g | |||
| @@ -0,0 +1,2575 @@ | |||
| 1 | /* | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | grammar InternalSolverLanguage; | ||
| 5 | |||
| 6 | options { | ||
| 7 | superClass=AbstractInternalAntlrParser; | ||
| 8 | } | ||
| 9 | |||
| 10 | @lexer::header { | ||
| 11 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
| 12 | |||
| 13 | // Hack: Use our own Lexer superclass by means of import. | ||
| 14 | // Currently there is no other way to specify the superclass for the lexer. | ||
| 15 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
| 16 | } | ||
| 17 | |||
| 18 | @parser::header { | ||
| 19 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
| 20 | |||
| 21 | import org.eclipse.xtext.*; | ||
| 22 | import org.eclipse.xtext.parser.*; | ||
| 23 | import org.eclipse.xtext.parser.impl.*; | ||
| 24 | import org.eclipse.emf.ecore.util.EcoreUtil; | ||
| 25 | import org.eclipse.emf.ecore.EObject; | ||
| 26 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; | ||
| 27 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
| 28 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | ||
| 29 | import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; | ||
| 30 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
| 31 | |||
| 32 | } | ||
| 33 | |||
| 34 | @parser::members { | ||
| 35 | |||
| 36 | private SolverLanguageGrammarAccess grammarAccess; | ||
| 37 | |||
| 38 | public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) { | ||
| 39 | this(input); | ||
| 40 | this.grammarAccess = grammarAccess; | ||
| 41 | registerRules(grammarAccess.getGrammar()); | ||
| 42 | } | ||
| 43 | |||
| 44 | @Override | ||
| 45 | protected String getFirstRuleName() { | ||
| 46 | return "Problem"; | ||
| 47 | } | ||
| 48 | |||
| 49 | @Override | ||
| 50 | protected SolverLanguageGrammarAccess getGrammarAccess() { | ||
| 51 | return grammarAccess; | ||
| 52 | } | ||
| 53 | |||
| 54 | } | ||
| 55 | |||
| 56 | @rulecatch { | ||
| 57 | catch (RecognitionException re) { | ||
| 58 | recover(input,re); | ||
| 59 | appendSkippedTokens(); | ||
| 60 | } | ||
| 61 | } | ||
| 62 | |||
| 63 | // Entry rule entryRuleProblem | ||
| 64 | entryRuleProblem returns [EObject current=null]: | ||
| 65 | { newCompositeNode(grammarAccess.getProblemRule()); } | ||
| 66 | iv_ruleProblem=ruleProblem | ||
| 67 | { $current=$iv_ruleProblem.current; } | ||
| 68 | EOF; | ||
| 69 | |||
| 70 | // Rule Problem | ||
| 71 | ruleProblem returns [EObject current=null] | ||
| 72 | @init { | ||
| 73 | enterRule(); | ||
| 74 | } | ||
| 75 | @after { | ||
| 76 | leaveRule(); | ||
| 77 | }: | ||
| 78 | ( | ||
| 79 | ( | ||
| 80 | { | ||
| 81 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); | ||
| 82 | } | ||
| 83 | lv_statements_0_0=ruleStatement | ||
| 84 | { | ||
| 85 | if ($current==null) { | ||
| 86 | $current = createModelElementForParent(grammarAccess.getProblemRule()); | ||
| 87 | } | ||
| 88 | add( | ||
| 89 | $current, | ||
| 90 | "statements", | ||
| 91 | lv_statements_0_0, | ||
| 92 | "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); | ||
| 93 | afterParserOrEnumRuleCall(); | ||
| 94 | } | ||
| 95 | ) | ||
| 96 | )* | ||
| 97 | ; | ||
| 98 | |||
| 99 | // Entry rule entryRuleStatement | ||
| 100 | entryRuleStatement returns [EObject current=null]: | ||
| 101 | { newCompositeNode(grammarAccess.getStatementRule()); } | ||
| 102 | iv_ruleStatement=ruleStatement | ||
| 103 | { $current=$iv_ruleStatement.current; } | ||
| 104 | EOF; | ||
| 105 | |||
| 106 | // Rule Statement | ||
| 107 | ruleStatement returns [EObject current=null] | ||
| 108 | @init { | ||
| 109 | enterRule(); | ||
| 110 | } | ||
| 111 | @after { | ||
| 112 | leaveRule(); | ||
| 113 | }: | ||
| 114 | ( | ||
| 115 | { | ||
| 116 | newCompositeNode(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); | ||
| 117 | } | ||
| 118 | this_Interpretation_0=ruleInterpretation | ||
| 119 | { | ||
| 120 | $current = $this_Interpretation_0.current; | ||
| 121 | afterParserOrEnumRuleCall(); | ||
| 122 | } | ||
| 123 | | | ||
| 124 | { | ||
| 125 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); | ||
| 126 | } | ||
| 127 | this_Predicate_1=rulePredicate | ||
| 128 | { | ||
| 129 | $current = $this_Predicate_1.current; | ||
| 130 | afterParserOrEnumRuleCall(); | ||
| 131 | } | ||
| 132 | ) | ||
| 133 | ; | ||
| 134 | |||
| 135 | // Entry rule entryRuleREALLiteral | ||
| 136 | entryRuleREALLiteral returns [String current=null]: | ||
| 137 | { newCompositeNode(grammarAccess.getREALLiteralRule()); } | ||
| 138 | iv_ruleREALLiteral=ruleREALLiteral | ||
| 139 | { $current=$iv_ruleREALLiteral.current.getText(); } | ||
| 140 | EOF; | ||
| 141 | |||
| 142 | // Rule REALLiteral | ||
| 143 | ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
| 144 | @init { | ||
| 145 | enterRule(); | ||
| 146 | } | ||
| 147 | @after { | ||
| 148 | leaveRule(); | ||
| 149 | }: | ||
| 150 | ( | ||
| 151 | ( | ||
| 152 | kw='-' | ||
| 153 | { | ||
| 154 | $current.merge(kw); | ||
| 155 | newLeafNode(kw, grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); | ||
| 156 | } | ||
| 157 | )? | ||
| 158 | this_INT_1=RULE_INT | ||
| 159 | { | ||
| 160 | $current.merge(this_INT_1); | ||
| 161 | } | ||
| 162 | { | ||
| 163 | newLeafNode(this_INT_1, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); | ||
| 164 | } | ||
| 165 | kw='.' | ||
| 166 | { | ||
| 167 | $current.merge(kw); | ||
| 168 | newLeafNode(kw, grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); | ||
| 169 | } | ||
| 170 | this_INT_3=RULE_INT | ||
| 171 | { | ||
| 172 | $current.merge(this_INT_3); | ||
| 173 | } | ||
| 174 | { | ||
| 175 | newLeafNode(this_INT_3, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); | ||
| 176 | } | ||
| 177 | ) | ||
| 178 | ; | ||
| 179 | |||
| 180 | // Entry rule entryRuleINTLiteral | ||
| 181 | entryRuleINTLiteral returns [String current=null]: | ||
| 182 | { newCompositeNode(grammarAccess.getINTLiteralRule()); } | ||
| 183 | iv_ruleINTLiteral=ruleINTLiteral | ||
| 184 | { $current=$iv_ruleINTLiteral.current.getText(); } | ||
| 185 | EOF; | ||
| 186 | |||
| 187 | // Rule INTLiteral | ||
| 188 | ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
| 189 | @init { | ||
| 190 | enterRule(); | ||
| 191 | } | ||
| 192 | @after { | ||
| 193 | leaveRule(); | ||
| 194 | }: | ||
| 195 | ( | ||
| 196 | ( | ||
| 197 | kw='-' | ||
| 198 | { | ||
| 199 | $current.merge(kw); | ||
| 200 | newLeafNode(kw, grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); | ||
| 201 | } | ||
| 202 | )? | ||
| 203 | this_INT_1=RULE_INT | ||
| 204 | { | ||
| 205 | $current.merge(this_INT_1); | ||
| 206 | } | ||
| 207 | { | ||
| 208 | newLeafNode(this_INT_1, grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); | ||
| 209 | } | ||
| 210 | ) | ||
| 211 | ; | ||
| 212 | |||
| 213 | // Entry rule entryRuleBooleanValue | ||
| 214 | entryRuleBooleanValue returns [EObject current=null]: | ||
| 215 | { newCompositeNode(grammarAccess.getBooleanValueRule()); } | ||
| 216 | iv_ruleBooleanValue=ruleBooleanValue | ||
| 217 | { $current=$iv_ruleBooleanValue.current; } | ||
| 218 | EOF; | ||
| 219 | |||
| 220 | // Rule BooleanValue | ||
| 221 | ruleBooleanValue returns [EObject current=null] | ||
| 222 | @init { | ||
| 223 | enterRule(); | ||
| 224 | } | ||
| 225 | @after { | ||
| 226 | leaveRule(); | ||
| 227 | }: | ||
| 228 | ( | ||
| 229 | ( | ||
| 230 | ( | ||
| 231 | { | ||
| 232 | $current = forceCreateModelElement( | ||
| 233 | grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0(), | ||
| 234 | $current); | ||
| 235 | } | ||
| 236 | ) | ||
| 237 | otherlv_1='true' | ||
| 238 | { | ||
| 239 | newLeafNode(otherlv_1, grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); | ||
| 240 | } | ||
| 241 | ) | ||
| 242 | | | ||
| 243 | ( | ||
| 244 | otherlv_2='false' | ||
| 245 | { | ||
| 246 | newLeafNode(otherlv_2, grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); | ||
| 247 | } | ||
| 248 | ( | ||
| 249 | { | ||
| 250 | $current = forceCreateModelElement( | ||
| 251 | grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1(), | ||
| 252 | $current); | ||
| 253 | } | ||
| 254 | ) | ||
| 255 | ) | ||
| 256 | ) | ||
| 257 | ; | ||
| 258 | |||
| 259 | // Entry rule entryRuleTruthValue | ||
| 260 | entryRuleTruthValue returns [EObject current=null]: | ||
| 261 | { newCompositeNode(grammarAccess.getTruthValueRule()); } | ||
| 262 | iv_ruleTruthValue=ruleTruthValue | ||
| 263 | { $current=$iv_ruleTruthValue.current; } | ||
| 264 | EOF; | ||
| 265 | |||
| 266 | // Rule TruthValue | ||
| 267 | ruleTruthValue returns [EObject current=null] | ||
| 268 | @init { | ||
| 269 | enterRule(); | ||
| 270 | } | ||
| 271 | @after { | ||
| 272 | leaveRule(); | ||
| 273 | }: | ||
| 274 | ( | ||
| 275 | ( | ||
| 276 | ( | ||
| 277 | { | ||
| 278 | $current = forceCreateModelElement( | ||
| 279 | grammarAccess.getTruthValueAccess().getTrueAction_0_0(), | ||
| 280 | $current); | ||
| 281 | } | ||
| 282 | ) | ||
| 283 | otherlv_1='true' | ||
| 284 | { | ||
| 285 | newLeafNode(otherlv_1, grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); | ||
| 286 | } | ||
| 287 | ) | ||
| 288 | | | ||
| 289 | ( | ||
| 290 | ( | ||
| 291 | { | ||
| 292 | $current = forceCreateModelElement( | ||
| 293 | grammarAccess.getTruthValueAccess().getFalseAction_1_0(), | ||
| 294 | $current); | ||
| 295 | } | ||
| 296 | ) | ||
| 297 | otherlv_3='false' | ||
| 298 | { | ||
| 299 | newLeafNode(otherlv_3, grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); | ||
| 300 | } | ||
| 301 | ) | ||
| 302 | | | ||
| 303 | ( | ||
| 304 | ( | ||
| 305 | { | ||
| 306 | $current = forceCreateModelElement( | ||
| 307 | grammarAccess.getTruthValueAccess().getUnknownAction_2_0(), | ||
| 308 | $current); | ||
| 309 | } | ||
| 310 | ) | ||
| 311 | otherlv_5='unknown' | ||
| 312 | { | ||
| 313 | newLeafNode(otherlv_5, grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); | ||
| 314 | } | ||
| 315 | ) | ||
| 316 | | | ||
| 317 | ( | ||
| 318 | ( | ||
| 319 | { | ||
| 320 | $current = forceCreateModelElement( | ||
| 321 | grammarAccess.getTruthValueAccess().getErrorAction_3_0(), | ||
| 322 | $current); | ||
| 323 | } | ||
| 324 | ) | ||
| 325 | otherlv_7='error' | ||
| 326 | { | ||
| 327 | newLeafNode(otherlv_7, grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); | ||
| 328 | } | ||
| 329 | ) | ||
| 330 | ) | ||
| 331 | ; | ||
| 332 | |||
| 333 | // Entry rule entryRuleInterpretation | ||
| 334 | entryRuleInterpretation returns [EObject current=null]: | ||
| 335 | { newCompositeNode(grammarAccess.getInterpretationRule()); } | ||
| 336 | iv_ruleInterpretation=ruleInterpretation | ||
| 337 | { $current=$iv_ruleInterpretation.current; } | ||
| 338 | EOF; | ||
| 339 | |||
| 340 | // Rule Interpretation | ||
| 341 | ruleInterpretation returns [EObject current=null] | ||
| 342 | @init { | ||
| 343 | enterRule(); | ||
| 344 | } | ||
| 345 | @after { | ||
| 346 | leaveRule(); | ||
| 347 | }: | ||
| 348 | ( | ||
| 349 | { | ||
| 350 | newCompositeNode(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); | ||
| 351 | } | ||
| 352 | this_BasicInterpretation_0=ruleBasicInterpretation | ||
| 353 | { | ||
| 354 | $current = $this_BasicInterpretation_0.current; | ||
| 355 | afterParserOrEnumRuleCall(); | ||
| 356 | } | ||
| 357 | | | ||
| 358 | { | ||
| 359 | newCompositeNode(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); | ||
| 360 | } | ||
| 361 | this_DefaultInterpretation_1=ruleDefaultInterpretation | ||
| 362 | { | ||
| 363 | $current = $this_DefaultInterpretation_1.current; | ||
| 364 | afterParserOrEnumRuleCall(); | ||
| 365 | } | ||
| 366 | | | ||
| 367 | { | ||
| 368 | newCompositeNode(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); | ||
| 369 | } | ||
| 370 | this_CDInterpretation_2=ruleCDInterpretation | ||
| 371 | { | ||
| 372 | $current = $this_CDInterpretation_2.current; | ||
| 373 | afterParserOrEnumRuleCall(); | ||
| 374 | } | ||
| 375 | ) | ||
| 376 | ; | ||
| 377 | |||
| 378 | // Entry rule entryRuleBasicInterpretation | ||
| 379 | entryRuleBasicInterpretation returns [EObject current=null]: | ||
| 380 | { newCompositeNode(grammarAccess.getBasicInterpretationRule()); } | ||
| 381 | iv_ruleBasicInterpretation=ruleBasicInterpretation | ||
| 382 | { $current=$iv_ruleBasicInterpretation.current; } | ||
| 383 | EOF; | ||
| 384 | |||
| 385 | // Rule BasicInterpretation | ||
| 386 | ruleBasicInterpretation returns [EObject current=null] | ||
| 387 | @init { | ||
| 388 | enterRule(); | ||
| 389 | } | ||
| 390 | @after { | ||
| 391 | leaveRule(); | ||
| 392 | }: | ||
| 393 | ( | ||
| 394 | ( | ||
| 395 | ( | ||
| 396 | { | ||
| 397 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); | ||
| 398 | } | ||
| 399 | lv_symbol_0_0=ruleSymbol | ||
| 400 | { | ||
| 401 | if ($current==null) { | ||
| 402 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 403 | } | ||
| 404 | set( | ||
| 405 | $current, | ||
| 406 | "symbol", | ||
| 407 | lv_symbol_0_0, | ||
| 408 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 409 | afterParserOrEnumRuleCall(); | ||
| 410 | } | ||
| 411 | ) | ||
| 412 | ) | ||
| 413 | otherlv_1='(' | ||
| 414 | { | ||
| 415 | newLeafNode(otherlv_1, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1()); | ||
| 416 | } | ||
| 417 | ( | ||
| 418 | ( | ||
| 419 | { | ||
| 420 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_2_0()); | ||
| 421 | } | ||
| 422 | lv_objects_2_0=ruleComplexObject | ||
| 423 | { | ||
| 424 | if ($current==null) { | ||
| 425 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 426 | } | ||
| 427 | add( | ||
| 428 | $current, | ||
| 429 | "objects", | ||
| 430 | lv_objects_2_0, | ||
| 431 | "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); | ||
| 432 | afterParserOrEnumRuleCall(); | ||
| 433 | } | ||
| 434 | ) | ||
| 435 | )* | ||
| 436 | otherlv_3=')' | ||
| 437 | { | ||
| 438 | newLeafNode(otherlv_3, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_3()); | ||
| 439 | } | ||
| 440 | otherlv_4=':' | ||
| 441 | { | ||
| 442 | newLeafNode(otherlv_4, grammarAccess.getBasicInterpretationAccess().getColonKeyword_4()); | ||
| 443 | } | ||
| 444 | ( | ||
| 445 | ( | ||
| 446 | { | ||
| 447 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_5_0()); | ||
| 448 | } | ||
| 449 | lv_value_5_0=ruleTruthValue | ||
| 450 | { | ||
| 451 | if ($current==null) { | ||
| 452 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 453 | } | ||
| 454 | set( | ||
| 455 | $current, | ||
| 456 | "value", | ||
| 457 | lv_value_5_0, | ||
| 458 | "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue"); | ||
| 459 | afterParserOrEnumRuleCall(); | ||
| 460 | } | ||
| 461 | ) | ||
| 462 | ) | ||
| 463 | ) | ||
| 464 | ; | ||
| 465 | |||
| 466 | // Entry rule entryRuleSymbol | ||
| 467 | entryRuleSymbol returns [EObject current=null]: | ||
| 468 | { newCompositeNode(grammarAccess.getSymbolRule()); } | ||
| 469 | iv_ruleSymbol=ruleSymbol | ||
| 470 | { $current=$iv_ruleSymbol.current; } | ||
| 471 | EOF; | ||
| 472 | |||
| 473 | // Rule Symbol | ||
| 474 | ruleSymbol returns [EObject current=null] | ||
| 475 | @init { | ||
| 476 | enterRule(); | ||
| 477 | } | ||
| 478 | @after { | ||
| 479 | leaveRule(); | ||
| 480 | }: | ||
| 481 | ( | ||
| 482 | { | ||
| 483 | newCompositeNode(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); | ||
| 484 | } | ||
| 485 | this_ModelSymbol_0=ruleModelSymbol | ||
| 486 | { | ||
| 487 | $current = $this_ModelSymbol_0.current; | ||
| 488 | afterParserOrEnumRuleCall(); | ||
| 489 | } | ||
| 490 | | | ||
| 491 | { | ||
| 492 | newCompositeNode(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); | ||
| 493 | } | ||
| 494 | this_PartialitySymbol_1=rulePartialitySymbol | ||
| 495 | { | ||
| 496 | $current = $this_PartialitySymbol_1.current; | ||
| 497 | afterParserOrEnumRuleCall(); | ||
| 498 | } | ||
| 499 | | | ||
| 500 | { | ||
| 501 | newCompositeNode(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); | ||
| 502 | } | ||
| 503 | this_DataSymbol_2=ruleDataSymbol | ||
| 504 | { | ||
| 505 | $current = $this_DataSymbol_2.current; | ||
| 506 | afterParserOrEnumRuleCall(); | ||
| 507 | } | ||
| 508 | ) | ||
| 509 | ; | ||
| 510 | |||
| 511 | // Entry rule entryRuleModelSymbol | ||
| 512 | entryRuleModelSymbol returns [EObject current=null]: | ||
| 513 | { newCompositeNode(grammarAccess.getModelSymbolRule()); } | ||
| 514 | iv_ruleModelSymbol=ruleModelSymbol | ||
| 515 | { $current=$iv_ruleModelSymbol.current; } | ||
| 516 | EOF; | ||
| 517 | |||
| 518 | // Rule ModelSymbol | ||
| 519 | ruleModelSymbol returns [EObject current=null] | ||
| 520 | @init { | ||
| 521 | enterRule(); | ||
| 522 | } | ||
| 523 | @after { | ||
| 524 | leaveRule(); | ||
| 525 | }: | ||
| 526 | ( | ||
| 527 | ( | ||
| 528 | lv_name_0_0=RULE_ID | ||
| 529 | { | ||
| 530 | newLeafNode(lv_name_0_0, grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); | ||
| 531 | } | ||
| 532 | { | ||
| 533 | if ($current==null) { | ||
| 534 | $current = createModelElement(grammarAccess.getModelSymbolRule()); | ||
| 535 | } | ||
| 536 | setWithLastConsumed( | ||
| 537 | $current, | ||
| 538 | "name", | ||
| 539 | lv_name_0_0, | ||
| 540 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 541 | } | ||
| 542 | ) | ||
| 543 | ) | ||
| 544 | ; | ||
| 545 | |||
| 546 | // Entry rule entryRulePartialitySymbol | ||
| 547 | entryRulePartialitySymbol returns [EObject current=null]: | ||
| 548 | { newCompositeNode(grammarAccess.getPartialitySymbolRule()); } | ||
| 549 | iv_rulePartialitySymbol=rulePartialitySymbol | ||
| 550 | { $current=$iv_rulePartialitySymbol.current; } | ||
| 551 | EOF; | ||
| 552 | |||
| 553 | // Rule PartialitySymbol | ||
| 554 | rulePartialitySymbol returns [EObject current=null] | ||
| 555 | @init { | ||
| 556 | enterRule(); | ||
| 557 | } | ||
| 558 | @after { | ||
| 559 | leaveRule(); | ||
| 560 | }: | ||
| 561 | ( | ||
| 562 | { | ||
| 563 | newCompositeNode(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); | ||
| 564 | } | ||
| 565 | this_ExistSymbol_0=ruleExistSymbol | ||
| 566 | { | ||
| 567 | $current = $this_ExistSymbol_0.current; | ||
| 568 | afterParserOrEnumRuleCall(); | ||
| 569 | } | ||
| 570 | | | ||
| 571 | { | ||
| 572 | newCompositeNode(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); | ||
| 573 | } | ||
| 574 | this_EqualsSymbol_1=ruleEqualsSymbol | ||
| 575 | { | ||
| 576 | $current = $this_EqualsSymbol_1.current; | ||
| 577 | afterParserOrEnumRuleCall(); | ||
| 578 | } | ||
| 579 | ) | ||
| 580 | ; | ||
| 581 | |||
| 582 | // Entry rule entryRuleExistSymbol | ||
| 583 | entryRuleExistSymbol returns [EObject current=null]: | ||
| 584 | { newCompositeNode(grammarAccess.getExistSymbolRule()); } | ||
| 585 | iv_ruleExistSymbol=ruleExistSymbol | ||
| 586 | { $current=$iv_ruleExistSymbol.current; } | ||
| 587 | EOF; | ||
| 588 | |||
| 589 | // Rule ExistSymbol | ||
| 590 | ruleExistSymbol returns [EObject current=null] | ||
| 591 | @init { | ||
| 592 | enterRule(); | ||
| 593 | } | ||
| 594 | @after { | ||
| 595 | leaveRule(); | ||
| 596 | }: | ||
| 597 | ( | ||
| 598 | otherlv_0='exists' | ||
| 599 | { | ||
| 600 | newLeafNode(otherlv_0, grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); | ||
| 601 | } | ||
| 602 | ( | ||
| 603 | { | ||
| 604 | $current = forceCreateModelElement( | ||
| 605 | grammarAccess.getExistSymbolAccess().getExistSymbolAction_1(), | ||
| 606 | $current); | ||
| 607 | } | ||
| 608 | ) | ||
| 609 | ) | ||
| 610 | ; | ||
| 611 | |||
| 612 | // Entry rule entryRuleEqualsSymbol | ||
| 613 | entryRuleEqualsSymbol returns [EObject current=null]: | ||
| 614 | { newCompositeNode(grammarAccess.getEqualsSymbolRule()); } | ||
| 615 | iv_ruleEqualsSymbol=ruleEqualsSymbol | ||
| 616 | { $current=$iv_ruleEqualsSymbol.current; } | ||
| 617 | EOF; | ||
| 618 | |||
| 619 | // Rule EqualsSymbol | ||
| 620 | ruleEqualsSymbol returns [EObject current=null] | ||
| 621 | @init { | ||
| 622 | enterRule(); | ||
| 623 | } | ||
| 624 | @after { | ||
| 625 | leaveRule(); | ||
| 626 | }: | ||
| 627 | ( | ||
| 628 | otherlv_0='equals' | ||
| 629 | { | ||
| 630 | newLeafNode(otherlv_0, grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); | ||
| 631 | } | ||
| 632 | ( | ||
| 633 | { | ||
| 634 | $current = forceCreateModelElement( | ||
| 635 | grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1(), | ||
| 636 | $current); | ||
| 637 | } | ||
| 638 | ) | ||
| 639 | ) | ||
| 640 | ; | ||
| 641 | |||
| 642 | // Entry rule entryRuleDataSymbol | ||
| 643 | entryRuleDataSymbol returns [EObject current=null]: | ||
| 644 | { newCompositeNode(grammarAccess.getDataSymbolRule()); } | ||
| 645 | iv_ruleDataSymbol=ruleDataSymbol | ||
| 646 | { $current=$iv_ruleDataSymbol.current; } | ||
| 647 | EOF; | ||
| 648 | |||
| 649 | // Rule DataSymbol | ||
| 650 | ruleDataSymbol returns [EObject current=null] | ||
| 651 | @init { | ||
| 652 | enterRule(); | ||
| 653 | } | ||
| 654 | @after { | ||
| 655 | leaveRule(); | ||
| 656 | }: | ||
| 657 | ( | ||
| 658 | { | ||
| 659 | newCompositeNode(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); | ||
| 660 | } | ||
| 661 | this_BooleanSymbol_0=ruleBooleanSymbol | ||
| 662 | { | ||
| 663 | $current = $this_BooleanSymbol_0.current; | ||
| 664 | afterParserOrEnumRuleCall(); | ||
| 665 | } | ||
| 666 | | | ||
| 667 | { | ||
| 668 | newCompositeNode(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); | ||
| 669 | } | ||
| 670 | this_IntegerSymbol_1=ruleIntegerSymbol | ||
| 671 | { | ||
| 672 | $current = $this_IntegerSymbol_1.current; | ||
| 673 | afterParserOrEnumRuleCall(); | ||
| 674 | } | ||
| 675 | | | ||
| 676 | { | ||
| 677 | newCompositeNode(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); | ||
| 678 | } | ||
| 679 | this_RealSymbol_2=ruleRealSymbol | ||
| 680 | { | ||
| 681 | $current = $this_RealSymbol_2.current; | ||
| 682 | afterParserOrEnumRuleCall(); | ||
| 683 | } | ||
| 684 | | | ||
| 685 | { | ||
| 686 | newCompositeNode(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); | ||
| 687 | } | ||
| 688 | this_StringSymbol_3=ruleStringSymbol | ||
| 689 | { | ||
| 690 | $current = $this_StringSymbol_3.current; | ||
| 691 | afterParserOrEnumRuleCall(); | ||
| 692 | } | ||
| 693 | ) | ||
| 694 | ; | ||
| 695 | |||
| 696 | // Entry rule entryRuleBooleanSymbol | ||
| 697 | entryRuleBooleanSymbol returns [EObject current=null]: | ||
| 698 | { newCompositeNode(grammarAccess.getBooleanSymbolRule()); } | ||
| 699 | iv_ruleBooleanSymbol=ruleBooleanSymbol | ||
| 700 | { $current=$iv_ruleBooleanSymbol.current; } | ||
| 701 | EOF; | ||
| 702 | |||
| 703 | // Rule BooleanSymbol | ||
| 704 | ruleBooleanSymbol returns [EObject current=null] | ||
| 705 | @init { | ||
| 706 | enterRule(); | ||
| 707 | } | ||
| 708 | @after { | ||
| 709 | leaveRule(); | ||
| 710 | }: | ||
| 711 | ( | ||
| 712 | otherlv_0='bool' | ||
| 713 | { | ||
| 714 | newLeafNode(otherlv_0, grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); | ||
| 715 | } | ||
| 716 | ( | ||
| 717 | { | ||
| 718 | $current = forceCreateModelElement( | ||
| 719 | grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1(), | ||
| 720 | $current); | ||
| 721 | } | ||
| 722 | ) | ||
| 723 | ) | ||
| 724 | ; | ||
| 725 | |||
| 726 | // Entry rule entryRuleIntegerSymbol | ||
| 727 | entryRuleIntegerSymbol returns [EObject current=null]: | ||
| 728 | { newCompositeNode(grammarAccess.getIntegerSymbolRule()); } | ||
| 729 | iv_ruleIntegerSymbol=ruleIntegerSymbol | ||
| 730 | { $current=$iv_ruleIntegerSymbol.current; } | ||
| 731 | EOF; | ||
| 732 | |||
| 733 | // Rule IntegerSymbol | ||
| 734 | ruleIntegerSymbol returns [EObject current=null] | ||
| 735 | @init { | ||
| 736 | enterRule(); | ||
| 737 | } | ||
| 738 | @after { | ||
| 739 | leaveRule(); | ||
| 740 | }: | ||
| 741 | ( | ||
| 742 | otherlv_0='int' | ||
| 743 | { | ||
| 744 | newLeafNode(otherlv_0, grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); | ||
| 745 | } | ||
| 746 | ( | ||
| 747 | { | ||
| 748 | $current = forceCreateModelElement( | ||
| 749 | grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1(), | ||
| 750 | $current); | ||
| 751 | } | ||
| 752 | ) | ||
| 753 | ) | ||
| 754 | ; | ||
| 755 | |||
| 756 | // Entry rule entryRuleRealSymbol | ||
| 757 | entryRuleRealSymbol returns [EObject current=null]: | ||
| 758 | { newCompositeNode(grammarAccess.getRealSymbolRule()); } | ||
| 759 | iv_ruleRealSymbol=ruleRealSymbol | ||
| 760 | { $current=$iv_ruleRealSymbol.current; } | ||
| 761 | EOF; | ||
| 762 | |||
| 763 | // Rule RealSymbol | ||
| 764 | ruleRealSymbol returns [EObject current=null] | ||
| 765 | @init { | ||
| 766 | enterRule(); | ||
| 767 | } | ||
| 768 | @after { | ||
| 769 | leaveRule(); | ||
| 770 | }: | ||
| 771 | ( | ||
| 772 | otherlv_0='real' | ||
| 773 | { | ||
| 774 | newLeafNode(otherlv_0, grammarAccess.getRealSymbolAccess().getRealKeyword_0()); | ||
| 775 | } | ||
| 776 | ( | ||
| 777 | { | ||
| 778 | $current = forceCreateModelElement( | ||
| 779 | grammarAccess.getRealSymbolAccess().getRealSymbolAction_1(), | ||
| 780 | $current); | ||
| 781 | } | ||
| 782 | ) | ||
| 783 | ) | ||
| 784 | ; | ||
| 785 | |||
| 786 | // Entry rule entryRuleStringSymbol | ||
| 787 | entryRuleStringSymbol returns [EObject current=null]: | ||
| 788 | { newCompositeNode(grammarAccess.getStringSymbolRule()); } | ||
| 789 | iv_ruleStringSymbol=ruleStringSymbol | ||
| 790 | { $current=$iv_ruleStringSymbol.current; } | ||
| 791 | EOF; | ||
| 792 | |||
| 793 | // Rule StringSymbol | ||
| 794 | ruleStringSymbol returns [EObject current=null] | ||
| 795 | @init { | ||
| 796 | enterRule(); | ||
| 797 | } | ||
| 798 | @after { | ||
| 799 | leaveRule(); | ||
| 800 | }: | ||
| 801 | ( | ||
| 802 | otherlv_0='string' | ||
| 803 | { | ||
| 804 | newLeafNode(otherlv_0, grammarAccess.getStringSymbolAccess().getStringKeyword_0()); | ||
| 805 | } | ||
| 806 | ( | ||
| 807 | { | ||
| 808 | $current = forceCreateModelElement( | ||
| 809 | grammarAccess.getStringSymbolAccess().getStringSymbolAction_1(), | ||
| 810 | $current); | ||
| 811 | } | ||
| 812 | ) | ||
| 813 | ) | ||
| 814 | ; | ||
| 815 | |||
| 816 | // Entry rule entryRuleComplexObject | ||
| 817 | entryRuleComplexObject returns [EObject current=null]: | ||
| 818 | { newCompositeNode(grammarAccess.getComplexObjectRule()); } | ||
| 819 | iv_ruleComplexObject=ruleComplexObject | ||
| 820 | { $current=$iv_ruleComplexObject.current; } | ||
| 821 | EOF; | ||
| 822 | |||
| 823 | // Rule ComplexObject | ||
| 824 | ruleComplexObject returns [EObject current=null] | ||
| 825 | @init { | ||
| 826 | enterRule(); | ||
| 827 | } | ||
| 828 | @after { | ||
| 829 | leaveRule(); | ||
| 830 | }: | ||
| 831 | ( | ||
| 832 | { | ||
| 833 | newCompositeNode(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); | ||
| 834 | } | ||
| 835 | this_Object_0=ruleObject | ||
| 836 | { | ||
| 837 | $current = $this_Object_0.current; | ||
| 838 | afterParserOrEnumRuleCall(); | ||
| 839 | } | ||
| 840 | | | ||
| 841 | { | ||
| 842 | newCompositeNode(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); | ||
| 843 | } | ||
| 844 | this_AllInstances_1=ruleAllInstances | ||
| 845 | { | ||
| 846 | $current = $this_AllInstances_1.current; | ||
| 847 | afterParserOrEnumRuleCall(); | ||
| 848 | } | ||
| 849 | | | ||
| 850 | { | ||
| 851 | newCompositeNode(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); | ||
| 852 | } | ||
| 853 | this_AllObjects_2=ruleAllObjects | ||
| 854 | { | ||
| 855 | $current = $this_AllObjects_2.current; | ||
| 856 | afterParserOrEnumRuleCall(); | ||
| 857 | } | ||
| 858 | ) | ||
| 859 | ; | ||
| 860 | |||
| 861 | // Entry rule entryRuleObject | ||
| 862 | entryRuleObject returns [EObject current=null]: | ||
| 863 | { newCompositeNode(grammarAccess.getObjectRule()); } | ||
| 864 | iv_ruleObject=ruleObject | ||
| 865 | { $current=$iv_ruleObject.current; } | ||
| 866 | EOF; | ||
| 867 | |||
| 868 | // Rule Object | ||
| 869 | ruleObject returns [EObject current=null] | ||
| 870 | @init { | ||
| 871 | enterRule(); | ||
| 872 | } | ||
| 873 | @after { | ||
| 874 | leaveRule(); | ||
| 875 | }: | ||
| 876 | ( | ||
| 877 | { | ||
| 878 | newCompositeNode(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); | ||
| 879 | } | ||
| 880 | this_NamedObject_0=ruleNamedObject | ||
| 881 | { | ||
| 882 | $current = $this_NamedObject_0.current; | ||
| 883 | afterParserOrEnumRuleCall(); | ||
| 884 | } | ||
| 885 | | | ||
| 886 | { | ||
| 887 | newCompositeNode(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); | ||
| 888 | } | ||
| 889 | this_UnnamedObject_1=ruleUnnamedObject | ||
| 890 | { | ||
| 891 | $current = $this_UnnamedObject_1.current; | ||
| 892 | afterParserOrEnumRuleCall(); | ||
| 893 | } | ||
| 894 | | | ||
| 895 | { | ||
| 896 | newCompositeNode(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); | ||
| 897 | } | ||
| 898 | this_DataObject_2=ruleDataObject | ||
| 899 | { | ||
| 900 | $current = $this_DataObject_2.current; | ||
| 901 | afterParserOrEnumRuleCall(); | ||
| 902 | } | ||
| 903 | ) | ||
| 904 | ; | ||
| 905 | |||
| 906 | // Entry rule entryRuleNamedObject | ||
| 907 | entryRuleNamedObject returns [EObject current=null]: | ||
| 908 | { newCompositeNode(grammarAccess.getNamedObjectRule()); } | ||
| 909 | iv_ruleNamedObject=ruleNamedObject | ||
| 910 | { $current=$iv_ruleNamedObject.current; } | ||
| 911 | EOF; | ||
| 912 | |||
| 913 | // Rule NamedObject | ||
| 914 | ruleNamedObject returns [EObject current=null] | ||
| 915 | @init { | ||
| 916 | enterRule(); | ||
| 917 | } | ||
| 918 | @after { | ||
| 919 | leaveRule(); | ||
| 920 | }: | ||
| 921 | ( | ||
| 922 | otherlv_0='\'' | ||
| 923 | { | ||
| 924 | newLeafNode(otherlv_0, grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); | ||
| 925 | } | ||
| 926 | ( | ||
| 927 | ( | ||
| 928 | lv_name_1_0=RULE_ID | ||
| 929 | { | ||
| 930 | newLeafNode(lv_name_1_0, grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); | ||
| 931 | } | ||
| 932 | { | ||
| 933 | if ($current==null) { | ||
| 934 | $current = createModelElement(grammarAccess.getNamedObjectRule()); | ||
| 935 | } | ||
| 936 | setWithLastConsumed( | ||
| 937 | $current, | ||
| 938 | "name", | ||
| 939 | lv_name_1_0, | ||
| 940 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 941 | } | ||
| 942 | ) | ||
| 943 | ) | ||
| 944 | otherlv_2='\'' | ||
| 945 | { | ||
| 946 | newLeafNode(otherlv_2, grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); | ||
| 947 | } | ||
| 948 | ) | ||
| 949 | ; | ||
| 950 | |||
| 951 | // Entry rule entryRuleUnnamedObject | ||
| 952 | entryRuleUnnamedObject returns [EObject current=null]: | ||
| 953 | { newCompositeNode(grammarAccess.getUnnamedObjectRule()); } | ||
| 954 | iv_ruleUnnamedObject=ruleUnnamedObject | ||
| 955 | { $current=$iv_ruleUnnamedObject.current; } | ||
| 956 | EOF; | ||
| 957 | |||
| 958 | // Rule UnnamedObject | ||
| 959 | ruleUnnamedObject returns [EObject current=null] | ||
| 960 | @init { | ||
| 961 | enterRule(); | ||
| 962 | } | ||
| 963 | @after { | ||
| 964 | leaveRule(); | ||
| 965 | }: | ||
| 966 | ( | ||
| 967 | ( | ||
| 968 | lv_name_0_0=RULE_ID | ||
| 969 | { | ||
| 970 | newLeafNode(lv_name_0_0, grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); | ||
| 971 | } | ||
| 972 | { | ||
| 973 | if ($current==null) { | ||
| 974 | $current = createModelElement(grammarAccess.getUnnamedObjectRule()); | ||
| 975 | } | ||
| 976 | setWithLastConsumed( | ||
| 977 | $current, | ||
| 978 | "name", | ||
| 979 | lv_name_0_0, | ||
| 980 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 981 | } | ||
| 982 | ) | ||
| 983 | ) | ||
| 984 | ; | ||
| 985 | |||
| 986 | // Entry rule entryRuleDataObject | ||
| 987 | entryRuleDataObject returns [EObject current=null]: | ||
| 988 | { newCompositeNode(grammarAccess.getDataObjectRule()); } | ||
| 989 | iv_ruleDataObject=ruleDataObject | ||
| 990 | { $current=$iv_ruleDataObject.current; } | ||
| 991 | EOF; | ||
| 992 | |||
| 993 | // Rule DataObject | ||
| 994 | ruleDataObject returns [EObject current=null] | ||
| 995 | @init { | ||
| 996 | enterRule(); | ||
| 997 | } | ||
| 998 | @after { | ||
| 999 | leaveRule(); | ||
| 1000 | }: | ||
| 1001 | ( | ||
| 1002 | { | ||
| 1003 | newCompositeNode(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); | ||
| 1004 | } | ||
| 1005 | this_BooleanObject_0=ruleBooleanObject | ||
| 1006 | { | ||
| 1007 | $current = $this_BooleanObject_0.current; | ||
| 1008 | afterParserOrEnumRuleCall(); | ||
| 1009 | } | ||
| 1010 | | | ||
| 1011 | { | ||
| 1012 | newCompositeNode(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); | ||
| 1013 | } | ||
| 1014 | this_IntObject_1=ruleIntObject | ||
| 1015 | { | ||
| 1016 | $current = $this_IntObject_1.current; | ||
| 1017 | afterParserOrEnumRuleCall(); | ||
| 1018 | } | ||
| 1019 | | | ||
| 1020 | { | ||
| 1021 | newCompositeNode(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); | ||
| 1022 | } | ||
| 1023 | this_RealObject_2=ruleRealObject | ||
| 1024 | { | ||
| 1025 | $current = $this_RealObject_2.current; | ||
| 1026 | afterParserOrEnumRuleCall(); | ||
| 1027 | } | ||
| 1028 | | | ||
| 1029 | { | ||
| 1030 | newCompositeNode(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); | ||
| 1031 | } | ||
| 1032 | this_StringObject_3=ruleStringObject | ||
| 1033 | { | ||
| 1034 | $current = $this_StringObject_3.current; | ||
| 1035 | afterParserOrEnumRuleCall(); | ||
| 1036 | } | ||
| 1037 | ) | ||
| 1038 | ; | ||
| 1039 | |||
| 1040 | // Entry rule entryRuleBooleanObject | ||
| 1041 | entryRuleBooleanObject returns [EObject current=null]: | ||
| 1042 | { newCompositeNode(grammarAccess.getBooleanObjectRule()); } | ||
| 1043 | iv_ruleBooleanObject=ruleBooleanObject | ||
| 1044 | { $current=$iv_ruleBooleanObject.current; } | ||
| 1045 | EOF; | ||
| 1046 | |||
| 1047 | // Rule BooleanObject | ||
| 1048 | ruleBooleanObject returns [EObject current=null] | ||
| 1049 | @init { | ||
| 1050 | enterRule(); | ||
| 1051 | } | ||
| 1052 | @after { | ||
| 1053 | leaveRule(); | ||
| 1054 | }: | ||
| 1055 | ( | ||
| 1056 | ( | ||
| 1057 | { | ||
| 1058 | newCompositeNode(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); | ||
| 1059 | } | ||
| 1060 | lv_value_0_0=ruleBooleanValue | ||
| 1061 | { | ||
| 1062 | if ($current==null) { | ||
| 1063 | $current = createModelElementForParent(grammarAccess.getBooleanObjectRule()); | ||
| 1064 | } | ||
| 1065 | set( | ||
| 1066 | $current, | ||
| 1067 | "value", | ||
| 1068 | lv_value_0_0, | ||
| 1069 | "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue"); | ||
| 1070 | afterParserOrEnumRuleCall(); | ||
| 1071 | } | ||
| 1072 | ) | ||
| 1073 | ) | ||
| 1074 | ; | ||
| 1075 | |||
| 1076 | // Entry rule entryRuleIntObject | ||
| 1077 | entryRuleIntObject returns [EObject current=null]: | ||
| 1078 | { newCompositeNode(grammarAccess.getIntObjectRule()); } | ||
| 1079 | iv_ruleIntObject=ruleIntObject | ||
| 1080 | { $current=$iv_ruleIntObject.current; } | ||
| 1081 | EOF; | ||
| 1082 | |||
| 1083 | // Rule IntObject | ||
| 1084 | ruleIntObject returns [EObject current=null] | ||
| 1085 | @init { | ||
| 1086 | enterRule(); | ||
| 1087 | } | ||
| 1088 | @after { | ||
| 1089 | leaveRule(); | ||
| 1090 | }: | ||
| 1091 | ( | ||
| 1092 | ( | ||
| 1093 | { | ||
| 1094 | newCompositeNode(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); | ||
| 1095 | } | ||
| 1096 | lv_value_0_0=ruleINTLiteral | ||
| 1097 | { | ||
| 1098 | if ($current==null) { | ||
| 1099 | $current = createModelElementForParent(grammarAccess.getIntObjectRule()); | ||
| 1100 | } | ||
| 1101 | set( | ||
| 1102 | $current, | ||
| 1103 | "value", | ||
| 1104 | lv_value_0_0, | ||
| 1105 | "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral"); | ||
| 1106 | afterParserOrEnumRuleCall(); | ||
| 1107 | } | ||
| 1108 | ) | ||
| 1109 | ) | ||
| 1110 | ; | ||
| 1111 | |||
| 1112 | // Entry rule entryRuleRealObject | ||
| 1113 | entryRuleRealObject returns [EObject current=null]: | ||
| 1114 | { newCompositeNode(grammarAccess.getRealObjectRule()); } | ||
| 1115 | iv_ruleRealObject=ruleRealObject | ||
| 1116 | { $current=$iv_ruleRealObject.current; } | ||
| 1117 | EOF; | ||
| 1118 | |||
| 1119 | // Rule RealObject | ||
| 1120 | ruleRealObject returns [EObject current=null] | ||
| 1121 | @init { | ||
| 1122 | enterRule(); | ||
| 1123 | } | ||
| 1124 | @after { | ||
| 1125 | leaveRule(); | ||
| 1126 | }: | ||
| 1127 | ( | ||
| 1128 | ( | ||
| 1129 | { | ||
| 1130 | newCompositeNode(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); | ||
| 1131 | } | ||
| 1132 | lv_value_0_0=ruleREALLiteral | ||
| 1133 | { | ||
| 1134 | if ($current==null) { | ||
| 1135 | $current = createModelElementForParent(grammarAccess.getRealObjectRule()); | ||
| 1136 | } | ||
| 1137 | set( | ||
| 1138 | $current, | ||
| 1139 | "value", | ||
| 1140 | lv_value_0_0, | ||
| 1141 | "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral"); | ||
| 1142 | afterParserOrEnumRuleCall(); | ||
| 1143 | } | ||
| 1144 | ) | ||
| 1145 | ) | ||
| 1146 | ; | ||
| 1147 | |||
| 1148 | // Entry rule entryRuleStringObject | ||
| 1149 | entryRuleStringObject returns [EObject current=null]: | ||
| 1150 | { newCompositeNode(grammarAccess.getStringObjectRule()); } | ||
| 1151 | iv_ruleStringObject=ruleStringObject | ||
| 1152 | { $current=$iv_ruleStringObject.current; } | ||
| 1153 | EOF; | ||
| 1154 | |||
| 1155 | // Rule StringObject | ||
| 1156 | ruleStringObject returns [EObject current=null] | ||
| 1157 | @init { | ||
| 1158 | enterRule(); | ||
| 1159 | } | ||
| 1160 | @after { | ||
| 1161 | leaveRule(); | ||
| 1162 | }: | ||
| 1163 | ( | ||
| 1164 | ( | ||
| 1165 | lv_value_0_0=RULE_STRING | ||
| 1166 | { | ||
| 1167 | newLeafNode(lv_value_0_0, grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); | ||
| 1168 | } | ||
| 1169 | { | ||
| 1170 | if ($current==null) { | ||
| 1171 | $current = createModelElement(grammarAccess.getStringObjectRule()); | ||
| 1172 | } | ||
| 1173 | setWithLastConsumed( | ||
| 1174 | $current, | ||
| 1175 | "value", | ||
| 1176 | lv_value_0_0, | ||
| 1177 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
| 1178 | } | ||
| 1179 | ) | ||
| 1180 | ) | ||
| 1181 | ; | ||
| 1182 | |||
| 1183 | // Entry rule entryRulePredicate | ||
| 1184 | entryRulePredicate returns [EObject current=null]: | ||
| 1185 | { newCompositeNode(grammarAccess.getPredicateRule()); } | ||
| 1186 | iv_rulePredicate=rulePredicate | ||
| 1187 | { $current=$iv_rulePredicate.current; } | ||
| 1188 | EOF; | ||
| 1189 | |||
| 1190 | // Rule Predicate | ||
| 1191 | rulePredicate returns [EObject current=null] | ||
| 1192 | @init { | ||
| 1193 | enterRule(); | ||
| 1194 | } | ||
| 1195 | @after { | ||
| 1196 | leaveRule(); | ||
| 1197 | }: | ||
| 1198 | ( | ||
| 1199 | { | ||
| 1200 | newCompositeNode(grammarAccess.getPredicateAccess().getPredicateSymbolParserRuleCall_0()); | ||
| 1201 | } | ||
| 1202 | this_PredicateSymbol_0=rulePredicateSymbol | ||
| 1203 | { | ||
| 1204 | $current = $this_PredicateSymbol_0.current; | ||
| 1205 | afterParserOrEnumRuleCall(); | ||
| 1206 | } | ||
| 1207 | | | ||
| 1208 | { | ||
| 1209 | newCompositeNode(grammarAccess.getPredicateAccess().getErrorPredicateParserRuleCall_1()); | ||
| 1210 | } | ||
| 1211 | this_ErrorPredicate_1=ruleErrorPredicate | ||
| 1212 | { | ||
| 1213 | $current = $this_ErrorPredicate_1.current; | ||
| 1214 | afterParserOrEnumRuleCall(); | ||
| 1215 | } | ||
| 1216 | ) | ||
| 1217 | ; | ||
| 1218 | |||
| 1219 | // Entry rule entryRulePredicateSymbol | ||
| 1220 | entryRulePredicateSymbol returns [EObject current=null]: | ||
| 1221 | { newCompositeNode(grammarAccess.getPredicateSymbolRule()); } | ||
| 1222 | iv_rulePredicateSymbol=rulePredicateSymbol | ||
| 1223 | { $current=$iv_rulePredicateSymbol.current; } | ||
| 1224 | EOF; | ||
| 1225 | |||
| 1226 | // Rule PredicateSymbol | ||
| 1227 | rulePredicateSymbol returns [EObject current=null] | ||
| 1228 | @init { | ||
| 1229 | enterRule(); | ||
| 1230 | } | ||
| 1231 | @after { | ||
| 1232 | leaveRule(); | ||
| 1233 | }: | ||
| 1234 | ( | ||
| 1235 | otherlv_0='predicate' | ||
| 1236 | { | ||
| 1237 | newLeafNode(otherlv_0, grammarAccess.getPredicateSymbolAccess().getPredicateKeyword_0()); | ||
| 1238 | } | ||
| 1239 | ( | ||
| 1240 | ( | ||
| 1241 | { | ||
| 1242 | newCompositeNode(grammarAccess.getPredicateSymbolAccess().getSymbolModelSymbolParserRuleCall_1_0()); | ||
| 1243 | } | ||
| 1244 | lv_symbol_1_0=ruleModelSymbol | ||
| 1245 | { | ||
| 1246 | if ($current==null) { | ||
| 1247 | $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); | ||
| 1248 | } | ||
| 1249 | set( | ||
| 1250 | $current, | ||
| 1251 | "symbol", | ||
| 1252 | lv_symbol_1_0, | ||
| 1253 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 1254 | afterParserOrEnumRuleCall(); | ||
| 1255 | } | ||
| 1256 | ) | ||
| 1257 | ) | ||
| 1258 | otherlv_2='(' | ||
| 1259 | { | ||
| 1260 | newLeafNode(otherlv_2, grammarAccess.getPredicateSymbolAccess().getLeftParenthesisKeyword_2()); | ||
| 1261 | } | ||
| 1262 | ( | ||
| 1263 | ( | ||
| 1264 | { | ||
| 1265 | newCompositeNode(grammarAccess.getPredicateSymbolAccess().getParametersParameterParserRuleCall_3_0()); | ||
| 1266 | } | ||
| 1267 | lv_parameters_3_0=ruleParameter | ||
| 1268 | { | ||
| 1269 | if ($current==null) { | ||
| 1270 | $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); | ||
| 1271 | } | ||
| 1272 | add( | ||
| 1273 | $current, | ||
| 1274 | "parameters", | ||
| 1275 | lv_parameters_3_0, | ||
| 1276 | "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | ||
| 1277 | afterParserOrEnumRuleCall(); | ||
| 1278 | } | ||
| 1279 | ) | ||
| 1280 | )* | ||
| 1281 | otherlv_4=')' | ||
| 1282 | { | ||
| 1283 | newLeafNode(otherlv_4, grammarAccess.getPredicateSymbolAccess().getRightParenthesisKeyword_4()); | ||
| 1284 | } | ||
| 1285 | otherlv_5=':' | ||
| 1286 | { | ||
| 1287 | newLeafNode(otherlv_5, grammarAccess.getPredicateSymbolAccess().getColonKeyword_5()); | ||
| 1288 | } | ||
| 1289 | ( | ||
| 1290 | otherlv_6='false' | ||
| 1291 | { | ||
| 1292 | newLeafNode(otherlv_6, grammarAccess.getPredicateSymbolAccess().getFalseKeyword_6_0()); | ||
| 1293 | } | ||
| 1294 | | | ||
| 1295 | ( | ||
| 1296 | ( | ||
| 1297 | ( | ||
| 1298 | { | ||
| 1299 | newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_0_0()); | ||
| 1300 | } | ||
| 1301 | lv_bodies_7_0=rulePatternBody | ||
| 1302 | { | ||
| 1303 | if ($current==null) { | ||
| 1304 | $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); | ||
| 1305 | } | ||
| 1306 | add( | ||
| 1307 | $current, | ||
| 1308 | "bodies", | ||
| 1309 | lv_bodies_7_0, | ||
| 1310 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | ||
| 1311 | afterParserOrEnumRuleCall(); | ||
| 1312 | } | ||
| 1313 | ) | ||
| 1314 | ) | ||
| 1315 | ( | ||
| 1316 | otherlv_8='|' | ||
| 1317 | { | ||
| 1318 | newLeafNode(otherlv_8, grammarAccess.getPredicateSymbolAccess().getVerticalLineKeyword_6_1_1_0()); | ||
| 1319 | } | ||
| 1320 | ( | ||
| 1321 | ( | ||
| 1322 | { | ||
| 1323 | newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_1_1_0()); | ||
| 1324 | } | ||
| 1325 | lv_bodies_9_0=rulePatternBody | ||
| 1326 | { | ||
| 1327 | if ($current==null) { | ||
| 1328 | $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); | ||
| 1329 | } | ||
| 1330 | add( | ||
| 1331 | $current, | ||
| 1332 | "bodies", | ||
| 1333 | lv_bodies_9_0, | ||
| 1334 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | ||
| 1335 | afterParserOrEnumRuleCall(); | ||
| 1336 | } | ||
| 1337 | ) | ||
| 1338 | ) | ||
| 1339 | )* | ||
| 1340 | ) | ||
| 1341 | ) | ||
| 1342 | otherlv_10='.' | ||
| 1343 | { | ||
| 1344 | newLeafNode(otherlv_10, grammarAccess.getPredicateSymbolAccess().getFullStopKeyword_7()); | ||
| 1345 | } | ||
| 1346 | ) | ||
| 1347 | ; | ||
| 1348 | |||
| 1349 | // Entry rule entryRuleErrorPredicate | ||
| 1350 | entryRuleErrorPredicate returns [EObject current=null]: | ||
| 1351 | { newCompositeNode(grammarAccess.getErrorPredicateRule()); } | ||
| 1352 | iv_ruleErrorPredicate=ruleErrorPredicate | ||
| 1353 | { $current=$iv_ruleErrorPredicate.current; } | ||
| 1354 | EOF; | ||
| 1355 | |||
| 1356 | // Rule ErrorPredicate | ||
| 1357 | ruleErrorPredicate returns [EObject current=null] | ||
| 1358 | @init { | ||
| 1359 | enterRule(); | ||
| 1360 | } | ||
| 1361 | @after { | ||
| 1362 | leaveRule(); | ||
| 1363 | }: | ||
| 1364 | ( | ||
| 1365 | ( | ||
| 1366 | { | ||
| 1367 | $current = forceCreateModelElement( | ||
| 1368 | grammarAccess.getErrorPredicateAccess().getErrorPredicateAction_0(), | ||
| 1369 | $current); | ||
| 1370 | } | ||
| 1371 | ) | ||
| 1372 | otherlv_1='error' | ||
| 1373 | { | ||
| 1374 | newLeafNode(otherlv_1, grammarAccess.getErrorPredicateAccess().getErrorKeyword_1()); | ||
| 1375 | } | ||
| 1376 | ( | ||
| 1377 | ( | ||
| 1378 | lv_name_2_0=RULE_ID | ||
| 1379 | { | ||
| 1380 | newLeafNode(lv_name_2_0, grammarAccess.getErrorPredicateAccess().getNameIDTerminalRuleCall_2_0()); | ||
| 1381 | } | ||
| 1382 | { | ||
| 1383 | if ($current==null) { | ||
| 1384 | $current = createModelElement(grammarAccess.getErrorPredicateRule()); | ||
| 1385 | } | ||
| 1386 | setWithLastConsumed( | ||
| 1387 | $current, | ||
| 1388 | "name", | ||
| 1389 | lv_name_2_0, | ||
| 1390 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 1391 | } | ||
| 1392 | ) | ||
| 1393 | )? | ||
| 1394 | ( | ||
| 1395 | otherlv_3='(' | ||
| 1396 | { | ||
| 1397 | newLeafNode(otherlv_3, grammarAccess.getErrorPredicateAccess().getLeftParenthesisKeyword_3_0()); | ||
| 1398 | } | ||
| 1399 | ( | ||
| 1400 | ( | ||
| 1401 | { | ||
| 1402 | newCompositeNode(grammarAccess.getErrorPredicateAccess().getParametersParameterParserRuleCall_3_1_0()); | ||
| 1403 | } | ||
| 1404 | lv_parameters_4_0=ruleParameter | ||
| 1405 | { | ||
| 1406 | if ($current==null) { | ||
| 1407 | $current = createModelElementForParent(grammarAccess.getErrorPredicateRule()); | ||
| 1408 | } | ||
| 1409 | add( | ||
| 1410 | $current, | ||
| 1411 | "parameters", | ||
| 1412 | lv_parameters_4_0, | ||
| 1413 | "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | ||
| 1414 | afterParserOrEnumRuleCall(); | ||
| 1415 | } | ||
| 1416 | ) | ||
| 1417 | )* | ||
| 1418 | otherlv_5=')' | ||
| 1419 | { | ||
| 1420 | newLeafNode(otherlv_5, grammarAccess.getErrorPredicateAccess().getRightParenthesisKeyword_3_2()); | ||
| 1421 | } | ||
| 1422 | ) | ||
| 1423 | otherlv_6=':' | ||
| 1424 | { | ||
| 1425 | newLeafNode(otherlv_6, grammarAccess.getErrorPredicateAccess().getColonKeyword_4()); | ||
| 1426 | } | ||
| 1427 | ( | ||
| 1428 | otherlv_7='false' | ||
| 1429 | { | ||
| 1430 | newLeafNode(otherlv_7, grammarAccess.getErrorPredicateAccess().getFalseKeyword_5_0()); | ||
| 1431 | } | ||
| 1432 | | | ||
| 1433 | ( | ||
| 1434 | ( | ||
| 1435 | ( | ||
| 1436 | { | ||
| 1437 | newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_0_0()); | ||
| 1438 | } | ||
| 1439 | lv_bodies_8_0=rulePatternBody | ||
| 1440 | { | ||
| 1441 | if ($current==null) { | ||
| 1442 | $current = createModelElementForParent(grammarAccess.getErrorPredicateRule()); | ||
| 1443 | } | ||
| 1444 | add( | ||
| 1445 | $current, | ||
| 1446 | "bodies", | ||
| 1447 | lv_bodies_8_0, | ||
| 1448 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | ||
| 1449 | afterParserOrEnumRuleCall(); | ||
| 1450 | } | ||
| 1451 | ) | ||
| 1452 | ) | ||
| 1453 | ( | ||
| 1454 | otherlv_9='|' | ||
| 1455 | { | ||
| 1456 | newLeafNode(otherlv_9, grammarAccess.getErrorPredicateAccess().getVerticalLineKeyword_5_1_1_0()); | ||
| 1457 | } | ||
| 1458 | ( | ||
| 1459 | ( | ||
| 1460 | { | ||
| 1461 | newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_1_1_0()); | ||
| 1462 | } | ||
| 1463 | lv_bodies_10_0=rulePatternBody | ||
| 1464 | { | ||
| 1465 | if ($current==null) { | ||
| 1466 | $current = createModelElementForParent(grammarAccess.getErrorPredicateRule()); | ||
| 1467 | } | ||
| 1468 | add( | ||
| 1469 | $current, | ||
| 1470 | "bodies", | ||
| 1471 | lv_bodies_10_0, | ||
| 1472 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | ||
| 1473 | afterParserOrEnumRuleCall(); | ||
| 1474 | } | ||
| 1475 | ) | ||
| 1476 | ) | ||
| 1477 | )* | ||
| 1478 | ) | ||
| 1479 | ) | ||
| 1480 | otherlv_11='.' | ||
| 1481 | { | ||
| 1482 | newLeafNode(otherlv_11, grammarAccess.getErrorPredicateAccess().getFullStopKeyword_6()); | ||
| 1483 | } | ||
| 1484 | ) | ||
| 1485 | ; | ||
| 1486 | |||
| 1487 | // Entry rule entryRuleParameter | ||
| 1488 | entryRuleParameter returns [EObject current=null]: | ||
| 1489 | { newCompositeNode(grammarAccess.getParameterRule()); } | ||
| 1490 | iv_ruleParameter=ruleParameter | ||
| 1491 | { $current=$iv_ruleParameter.current; } | ||
| 1492 | EOF; | ||
| 1493 | |||
| 1494 | // Rule Parameter | ||
| 1495 | ruleParameter returns [EObject current=null] | ||
| 1496 | @init { | ||
| 1497 | enterRule(); | ||
| 1498 | } | ||
| 1499 | @after { | ||
| 1500 | leaveRule(); | ||
| 1501 | }: | ||
| 1502 | ( | ||
| 1503 | ( | ||
| 1504 | ( | ||
| 1505 | { | ||
| 1506 | newCompositeNode(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); | ||
| 1507 | } | ||
| 1508 | lv_variable_0_0=ruleVariable | ||
| 1509 | { | ||
| 1510 | if ($current==null) { | ||
| 1511 | $current = createModelElementForParent(grammarAccess.getParameterRule()); | ||
| 1512 | } | ||
| 1513 | set( | ||
| 1514 | $current, | ||
| 1515 | "variable", | ||
| 1516 | lv_variable_0_0, | ||
| 1517 | "org.eclipse.viatra.solver.language.SolverLanguage.Variable"); | ||
| 1518 | afterParserOrEnumRuleCall(); | ||
| 1519 | } | ||
| 1520 | ) | ||
| 1521 | ) | ||
| 1522 | ( | ||
| 1523 | otherlv_1=':' | ||
| 1524 | { | ||
| 1525 | newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getColonKeyword_1_0()); | ||
| 1526 | } | ||
| 1527 | ( | ||
| 1528 | ( | ||
| 1529 | { | ||
| 1530 | newCompositeNode(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); | ||
| 1531 | } | ||
| 1532 | lv_type_2_0=ruleSymbol | ||
| 1533 | { | ||
| 1534 | if ($current==null) { | ||
| 1535 | $current = createModelElementForParent(grammarAccess.getParameterRule()); | ||
| 1536 | } | ||
| 1537 | set( | ||
| 1538 | $current, | ||
| 1539 | "type", | ||
| 1540 | lv_type_2_0, | ||
| 1541 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 1542 | afterParserOrEnumRuleCall(); | ||
| 1543 | } | ||
| 1544 | ) | ||
| 1545 | ) | ||
| 1546 | )? | ||
| 1547 | ) | ||
| 1548 | ; | ||
| 1549 | |||
| 1550 | // Entry rule entryRulePatternBody | ||
| 1551 | entryRulePatternBody returns [EObject current=null]: | ||
| 1552 | { newCompositeNode(grammarAccess.getPatternBodyRule()); } | ||
| 1553 | iv_rulePatternBody=rulePatternBody | ||
| 1554 | { $current=$iv_rulePatternBody.current; } | ||
| 1555 | EOF; | ||
| 1556 | |||
| 1557 | // Rule PatternBody | ||
| 1558 | rulePatternBody returns [EObject current=null] | ||
| 1559 | @init { | ||
| 1560 | enterRule(); | ||
| 1561 | } | ||
| 1562 | @after { | ||
| 1563 | leaveRule(); | ||
| 1564 | }: | ||
| 1565 | ( | ||
| 1566 | ( | ||
| 1567 | { | ||
| 1568 | $current = forceCreateModelElement( | ||
| 1569 | grammarAccess.getPatternBodyAccess().getPatternBodyAction_0(), | ||
| 1570 | $current); | ||
| 1571 | } | ||
| 1572 | ) | ||
| 1573 | ( | ||
| 1574 | otherlv_1='true' | ||
| 1575 | { | ||
| 1576 | newLeafNode(otherlv_1, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); | ||
| 1577 | } | ||
| 1578 | | | ||
| 1579 | ( | ||
| 1580 | ( | ||
| 1581 | { | ||
| 1582 | newCompositeNode(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); | ||
| 1583 | } | ||
| 1584 | lv_constraints_2_0=ruleConstraint | ||
| 1585 | { | ||
| 1586 | if ($current==null) { | ||
| 1587 | $current = createModelElementForParent(grammarAccess.getPatternBodyRule()); | ||
| 1588 | } | ||
| 1589 | add( | ||
| 1590 | $current, | ||
| 1591 | "constraints", | ||
| 1592 | lv_constraints_2_0, | ||
| 1593 | "org.eclipse.viatra.solver.language.SolverLanguage.Constraint"); | ||
| 1594 | afterParserOrEnumRuleCall(); | ||
| 1595 | } | ||
| 1596 | ) | ||
| 1597 | )* | ||
| 1598 | ) | ||
| 1599 | ) | ||
| 1600 | ; | ||
| 1601 | |||
| 1602 | // Entry rule entryRulePolarity | ||
| 1603 | entryRulePolarity returns [EObject current=null]: | ||
| 1604 | { newCompositeNode(grammarAccess.getPolarityRule()); } | ||
| 1605 | iv_rulePolarity=rulePolarity | ||
| 1606 | { $current=$iv_rulePolarity.current; } | ||
| 1607 | EOF; | ||
| 1608 | |||
| 1609 | // Rule Polarity | ||
| 1610 | rulePolarity returns [EObject current=null] | ||
| 1611 | @init { | ||
| 1612 | enterRule(); | ||
| 1613 | } | ||
| 1614 | @after { | ||
| 1615 | leaveRule(); | ||
| 1616 | }: | ||
| 1617 | ( | ||
| 1618 | ( | ||
| 1619 | ( | ||
| 1620 | { | ||
| 1621 | $current = forceCreateModelElement( | ||
| 1622 | grammarAccess.getPolarityAccess().getPositiveAction_0_0(), | ||
| 1623 | $current); | ||
| 1624 | } | ||
| 1625 | ) | ||
| 1626 | otherlv_1='+' | ||
| 1627 | { | ||
| 1628 | newLeafNode(otherlv_1, grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); | ||
| 1629 | } | ||
| 1630 | ) | ||
| 1631 | | | ||
| 1632 | ( | ||
| 1633 | ( | ||
| 1634 | { | ||
| 1635 | $current = forceCreateModelElement( | ||
| 1636 | grammarAccess.getPolarityAccess().getNegativeAction_1_0(), | ||
| 1637 | $current); | ||
| 1638 | } | ||
| 1639 | ) | ||
| 1640 | otherlv_3='-' | ||
| 1641 | { | ||
| 1642 | newLeafNode(otherlv_3, grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); | ||
| 1643 | } | ||
| 1644 | ) | ||
| 1645 | ) | ||
| 1646 | ; | ||
| 1647 | |||
| 1648 | // Entry rule entryRuleConstraint | ||
| 1649 | entryRuleConstraint returns [EObject current=null]: | ||
| 1650 | { newCompositeNode(grammarAccess.getConstraintRule()); } | ||
| 1651 | iv_ruleConstraint=ruleConstraint | ||
| 1652 | { $current=$iv_ruleConstraint.current; } | ||
| 1653 | EOF; | ||
| 1654 | |||
| 1655 | // Rule Constraint | ||
| 1656 | ruleConstraint returns [EObject current=null] | ||
| 1657 | @init { | ||
| 1658 | enterRule(); | ||
| 1659 | } | ||
| 1660 | @after { | ||
| 1661 | leaveRule(); | ||
| 1662 | }: | ||
| 1663 | ( | ||
| 1664 | ( | ||
| 1665 | ( | ||
| 1666 | { | ||
| 1667 | newCompositeNode(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0()); | ||
| 1668 | } | ||
| 1669 | lv_polarity_0_0=rulePolarity | ||
| 1670 | { | ||
| 1671 | if ($current==null) { | ||
| 1672 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1673 | } | ||
| 1674 | set( | ||
| 1675 | $current, | ||
| 1676 | "polarity", | ||
| 1677 | lv_polarity_0_0, | ||
| 1678 | "org.eclipse.viatra.solver.language.SolverLanguage.Polarity"); | ||
| 1679 | afterParserOrEnumRuleCall(); | ||
| 1680 | } | ||
| 1681 | ) | ||
| 1682 | )? | ||
| 1683 | ( | ||
| 1684 | ( | ||
| 1685 | { | ||
| 1686 | newCompositeNode(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_1_0()); | ||
| 1687 | } | ||
| 1688 | lv_symbol_1_0=ruleModelSymbol | ||
| 1689 | { | ||
| 1690 | if ($current==null) { | ||
| 1691 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1692 | } | ||
| 1693 | set( | ||
| 1694 | $current, | ||
| 1695 | "symbol", | ||
| 1696 | lv_symbol_1_0, | ||
| 1697 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 1698 | afterParserOrEnumRuleCall(); | ||
| 1699 | } | ||
| 1700 | ) | ||
| 1701 | ) | ||
| 1702 | ( | ||
| 1703 | ( | ||
| 1704 | otherlv_2='(' | ||
| 1705 | { | ||
| 1706 | newLeafNode(otherlv_2, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_0_0()); | ||
| 1707 | } | ||
| 1708 | ( | ||
| 1709 | ( | ||
| 1710 | { | ||
| 1711 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_0_1_0()); | ||
| 1712 | } | ||
| 1713 | lv_params_3_0=ruleLiteral | ||
| 1714 | { | ||
| 1715 | if ($current==null) { | ||
| 1716 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1717 | } | ||
| 1718 | add( | ||
| 1719 | $current, | ||
| 1720 | "params", | ||
| 1721 | lv_params_3_0, | ||
| 1722 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 1723 | afterParserOrEnumRuleCall(); | ||
| 1724 | } | ||
| 1725 | ) | ||
| 1726 | )* | ||
| 1727 | otherlv_4=')' | ||
| 1728 | { | ||
| 1729 | newLeafNode(otherlv_4, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_0_2()); | ||
| 1730 | } | ||
| 1731 | ) | ||
| 1732 | | | ||
| 1733 | ( | ||
| 1734 | ( | ||
| 1735 | ( | ||
| 1736 | { | ||
| 1737 | newCompositeNode(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_2_1_0_0()); | ||
| 1738 | } | ||
| 1739 | lv_closureType_5_0=ruleClosureType | ||
| 1740 | { | ||
| 1741 | if ($current==null) { | ||
| 1742 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1743 | } | ||
| 1744 | set( | ||
| 1745 | $current, | ||
| 1746 | "closureType", | ||
| 1747 | lv_closureType_5_0, | ||
| 1748 | "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType"); | ||
| 1749 | afterParserOrEnumRuleCall(); | ||
| 1750 | } | ||
| 1751 | ) | ||
| 1752 | ) | ||
| 1753 | otherlv_6='(' | ||
| 1754 | { | ||
| 1755 | newLeafNode(otherlv_6, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_1_1()); | ||
| 1756 | } | ||
| 1757 | ( | ||
| 1758 | ( | ||
| 1759 | { | ||
| 1760 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_2_0()); | ||
| 1761 | } | ||
| 1762 | lv_params_7_0=ruleLiteral | ||
| 1763 | { | ||
| 1764 | if ($current==null) { | ||
| 1765 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1766 | } | ||
| 1767 | add( | ||
| 1768 | $current, | ||
| 1769 | "params", | ||
| 1770 | lv_params_7_0, | ||
| 1771 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 1772 | afterParserOrEnumRuleCall(); | ||
| 1773 | } | ||
| 1774 | ) | ||
| 1775 | ) | ||
| 1776 | ( | ||
| 1777 | ( | ||
| 1778 | { | ||
| 1779 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_3_0()); | ||
| 1780 | } | ||
| 1781 | lv_params_8_0=ruleLiteral | ||
| 1782 | { | ||
| 1783 | if ($current==null) { | ||
| 1784 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1785 | } | ||
| 1786 | add( | ||
| 1787 | $current, | ||
| 1788 | "params", | ||
| 1789 | lv_params_8_0, | ||
| 1790 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 1791 | afterParserOrEnumRuleCall(); | ||
| 1792 | } | ||
| 1793 | ) | ||
| 1794 | ) | ||
| 1795 | otherlv_9=')' | ||
| 1796 | { | ||
| 1797 | newLeafNode(otherlv_9, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_1_4()); | ||
| 1798 | } | ||
| 1799 | ) | ||
| 1800 | ) | ||
| 1801 | ) | ||
| 1802 | ; | ||
| 1803 | |||
| 1804 | // Entry rule entryRuleClosureType | ||
| 1805 | entryRuleClosureType returns [EObject current=null]: | ||
| 1806 | { newCompositeNode(grammarAccess.getClosureTypeRule()); } | ||
| 1807 | iv_ruleClosureType=ruleClosureType | ||
| 1808 | { $current=$iv_ruleClosureType.current; } | ||
| 1809 | EOF; | ||
| 1810 | |||
| 1811 | // Rule ClosureType | ||
| 1812 | ruleClosureType returns [EObject current=null] | ||
| 1813 | @init { | ||
| 1814 | enterRule(); | ||
| 1815 | } | ||
| 1816 | @after { | ||
| 1817 | leaveRule(); | ||
| 1818 | }: | ||
| 1819 | ( | ||
| 1820 | ( | ||
| 1821 | ( | ||
| 1822 | { | ||
| 1823 | $current = forceCreateModelElement( | ||
| 1824 | grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0(), | ||
| 1825 | $current); | ||
| 1826 | } | ||
| 1827 | ) | ||
| 1828 | otherlv_1='*' | ||
| 1829 | { | ||
| 1830 | newLeafNode(otherlv_1, grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); | ||
| 1831 | } | ||
| 1832 | ) | ||
| 1833 | | | ||
| 1834 | ( | ||
| 1835 | ( | ||
| 1836 | { | ||
| 1837 | $current = forceCreateModelElement( | ||
| 1838 | grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0(), | ||
| 1839 | $current); | ||
| 1840 | } | ||
| 1841 | ) | ||
| 1842 | otherlv_3='+' | ||
| 1843 | { | ||
| 1844 | newLeafNode(otherlv_3, grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); | ||
| 1845 | } | ||
| 1846 | ) | ||
| 1847 | ) | ||
| 1848 | ; | ||
| 1849 | |||
| 1850 | // Entry rule entryRuleLiteral | ||
| 1851 | entryRuleLiteral returns [EObject current=null]: | ||
| 1852 | { newCompositeNode(grammarAccess.getLiteralRule()); } | ||
| 1853 | iv_ruleLiteral=ruleLiteral | ||
| 1854 | { $current=$iv_ruleLiteral.current; } | ||
| 1855 | EOF; | ||
| 1856 | |||
| 1857 | // Rule Literal | ||
| 1858 | ruleLiteral returns [EObject current=null] | ||
| 1859 | @init { | ||
| 1860 | enterRule(); | ||
| 1861 | } | ||
| 1862 | @after { | ||
| 1863 | leaveRule(); | ||
| 1864 | }: | ||
| 1865 | ( | ||
| 1866 | { | ||
| 1867 | newCompositeNode(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); | ||
| 1868 | } | ||
| 1869 | this_Variable_0=ruleVariable | ||
| 1870 | { | ||
| 1871 | $current = $this_Variable_0.current; | ||
| 1872 | afterParserOrEnumRuleCall(); | ||
| 1873 | } | ||
| 1874 | | | ||
| 1875 | { | ||
| 1876 | newCompositeNode(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); | ||
| 1877 | } | ||
| 1878 | this_DataObject_1=ruleDataObject | ||
| 1879 | { | ||
| 1880 | $current = $this_DataObject_1.current; | ||
| 1881 | afterParserOrEnumRuleCall(); | ||
| 1882 | } | ||
| 1883 | ) | ||
| 1884 | ; | ||
| 1885 | |||
| 1886 | // Entry rule entryRuleVariable | ||
| 1887 | entryRuleVariable returns [EObject current=null]: | ||
| 1888 | { newCompositeNode(grammarAccess.getVariableRule()); } | ||
| 1889 | iv_ruleVariable=ruleVariable | ||
| 1890 | { $current=$iv_ruleVariable.current; } | ||
| 1891 | EOF; | ||
| 1892 | |||
| 1893 | // Rule Variable | ||
| 1894 | ruleVariable returns [EObject current=null] | ||
| 1895 | @init { | ||
| 1896 | enterRule(); | ||
| 1897 | } | ||
| 1898 | @after { | ||
| 1899 | leaveRule(); | ||
| 1900 | }: | ||
| 1901 | ( | ||
| 1902 | ( | ||
| 1903 | lv_name_0_0=RULE_ID | ||
| 1904 | { | ||
| 1905 | newLeafNode(lv_name_0_0, grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); | ||
| 1906 | } | ||
| 1907 | { | ||
| 1908 | if ($current==null) { | ||
| 1909 | $current = createModelElement(grammarAccess.getVariableRule()); | ||
| 1910 | } | ||
| 1911 | setWithLastConsumed( | ||
| 1912 | $current, | ||
| 1913 | "name", | ||
| 1914 | lv_name_0_0, | ||
| 1915 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 1916 | } | ||
| 1917 | ) | ||
| 1918 | ) | ||
| 1919 | ; | ||
| 1920 | |||
| 1921 | // Entry rule entryRuleAllInstances | ||
| 1922 | entryRuleAllInstances returns [EObject current=null]: | ||
| 1923 | { newCompositeNode(grammarAccess.getAllInstancesRule()); } | ||
| 1924 | iv_ruleAllInstances=ruleAllInstances | ||
| 1925 | { $current=$iv_ruleAllInstances.current; } | ||
| 1926 | EOF; | ||
| 1927 | |||
| 1928 | // Rule AllInstances | ||
| 1929 | ruleAllInstances returns [EObject current=null] | ||
| 1930 | @init { | ||
| 1931 | enterRule(); | ||
| 1932 | } | ||
| 1933 | @after { | ||
| 1934 | leaveRule(); | ||
| 1935 | }: | ||
| 1936 | ( | ||
| 1937 | otherlv_0=':' | ||
| 1938 | { | ||
| 1939 | newLeafNode(otherlv_0, grammarAccess.getAllInstancesAccess().getColonKeyword_0()); | ||
| 1940 | } | ||
| 1941 | ( | ||
| 1942 | ( | ||
| 1943 | { | ||
| 1944 | newCompositeNode(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); | ||
| 1945 | } | ||
| 1946 | lv_symbol_1_0=ruleSymbol | ||
| 1947 | { | ||
| 1948 | if ($current==null) { | ||
| 1949 | $current = createModelElementForParent(grammarAccess.getAllInstancesRule()); | ||
| 1950 | } | ||
| 1951 | set( | ||
| 1952 | $current, | ||
| 1953 | "symbol", | ||
| 1954 | lv_symbol_1_0, | ||
| 1955 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 1956 | afterParserOrEnumRuleCall(); | ||
| 1957 | } | ||
| 1958 | ) | ||
| 1959 | ) | ||
| 1960 | ) | ||
| 1961 | ; | ||
| 1962 | |||
| 1963 | // Entry rule entryRuleAllObjects | ||
| 1964 | entryRuleAllObjects returns [EObject current=null]: | ||
| 1965 | { newCompositeNode(grammarAccess.getAllObjectsRule()); } | ||
| 1966 | iv_ruleAllObjects=ruleAllObjects | ||
| 1967 | { $current=$iv_ruleAllObjects.current; } | ||
| 1968 | EOF; | ||
| 1969 | |||
| 1970 | // Rule AllObjects | ||
| 1971 | ruleAllObjects returns [EObject current=null] | ||
| 1972 | @init { | ||
| 1973 | enterRule(); | ||
| 1974 | } | ||
| 1975 | @after { | ||
| 1976 | leaveRule(); | ||
| 1977 | }: | ||
| 1978 | ( | ||
| 1979 | ( | ||
| 1980 | { | ||
| 1981 | $current = forceCreateModelElement( | ||
| 1982 | grammarAccess.getAllObjectsAccess().getAllObjectsAction_0(), | ||
| 1983 | $current); | ||
| 1984 | } | ||
| 1985 | ) | ||
| 1986 | otherlv_1='*' | ||
| 1987 | { | ||
| 1988 | newLeafNode(otherlv_1, grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); | ||
| 1989 | } | ||
| 1990 | ) | ||
| 1991 | ; | ||
| 1992 | |||
| 1993 | // Entry rule entryRuleDefaultInterpretation | ||
| 1994 | entryRuleDefaultInterpretation returns [EObject current=null]: | ||
| 1995 | { newCompositeNode(grammarAccess.getDefaultInterpretationRule()); } | ||
| 1996 | iv_ruleDefaultInterpretation=ruleDefaultInterpretation | ||
| 1997 | { $current=$iv_ruleDefaultInterpretation.current; } | ||
| 1998 | EOF; | ||
| 1999 | |||
| 2000 | // Rule DefaultInterpretation | ||
| 2001 | ruleDefaultInterpretation returns [EObject current=null] | ||
| 2002 | @init { | ||
| 2003 | enterRule(); | ||
| 2004 | } | ||
| 2005 | @after { | ||
| 2006 | leaveRule(); | ||
| 2007 | }: | ||
| 2008 | ( | ||
| 2009 | otherlv_0='default' | ||
| 2010 | { | ||
| 2011 | newLeafNode(otherlv_0, grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); | ||
| 2012 | } | ||
| 2013 | ( | ||
| 2014 | ( | ||
| 2015 | { | ||
| 2016 | newCompositeNode(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); | ||
| 2017 | } | ||
| 2018 | lv_interpretation_1_0=ruleBasicInterpretation | ||
| 2019 | { | ||
| 2020 | if ($current==null) { | ||
| 2021 | $current = createModelElementForParent(grammarAccess.getDefaultInterpretationRule()); | ||
| 2022 | } | ||
| 2023 | set( | ||
| 2024 | $current, | ||
| 2025 | "interpretation", | ||
| 2026 | lv_interpretation_1_0, | ||
| 2027 | "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation"); | ||
| 2028 | afterParserOrEnumRuleCall(); | ||
| 2029 | } | ||
| 2030 | ) | ||
| 2031 | ) | ||
| 2032 | ) | ||
| 2033 | ; | ||
| 2034 | |||
| 2035 | // Entry rule entryRuleCDInterpretation | ||
| 2036 | entryRuleCDInterpretation returns [EObject current=null]: | ||
| 2037 | { newCompositeNode(grammarAccess.getCDInterpretationRule()); } | ||
| 2038 | iv_ruleCDInterpretation=ruleCDInterpretation | ||
| 2039 | { $current=$iv_ruleCDInterpretation.current; } | ||
| 2040 | EOF; | ||
| 2041 | |||
| 2042 | // Rule CDInterpretation | ||
| 2043 | ruleCDInterpretation returns [EObject current=null] | ||
| 2044 | @init { | ||
| 2045 | enterRule(); | ||
| 2046 | } | ||
| 2047 | @after { | ||
| 2048 | leaveRule(); | ||
| 2049 | }: | ||
| 2050 | ( | ||
| 2051 | { | ||
| 2052 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); | ||
| 2053 | } | ||
| 2054 | this_ClassInterpretation_0=ruleClassInterpretation | ||
| 2055 | { | ||
| 2056 | $current = $this_ClassInterpretation_0.current; | ||
| 2057 | afterParserOrEnumRuleCall(); | ||
| 2058 | } | ||
| 2059 | | | ||
| 2060 | { | ||
| 2061 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); | ||
| 2062 | } | ||
| 2063 | this_EnumInterpretation_1=ruleEnumInterpretation | ||
| 2064 | { | ||
| 2065 | $current = $this_EnumInterpretation_1.current; | ||
| 2066 | afterParserOrEnumRuleCall(); | ||
| 2067 | } | ||
| 2068 | | | ||
| 2069 | { | ||
| 2070 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); | ||
| 2071 | } | ||
| 2072 | this_GlobalRelationInterpretation_2=ruleGlobalRelationInterpretation | ||
| 2073 | { | ||
| 2074 | $current = $this_GlobalRelationInterpretation_2.current; | ||
| 2075 | afterParserOrEnumRuleCall(); | ||
| 2076 | } | ||
| 2077 | ) | ||
| 2078 | ; | ||
| 2079 | |||
| 2080 | // Entry rule entryRuleClassInterpretation | ||
| 2081 | entryRuleClassInterpretation returns [EObject current=null]: | ||
| 2082 | { newCompositeNode(grammarAccess.getClassInterpretationRule()); } | ||
| 2083 | iv_ruleClassInterpretation=ruleClassInterpretation | ||
| 2084 | { $current=$iv_ruleClassInterpretation.current; } | ||
| 2085 | EOF; | ||
| 2086 | |||
| 2087 | // Rule ClassInterpretation | ||
| 2088 | ruleClassInterpretation returns [EObject current=null] | ||
| 2089 | @init { | ||
| 2090 | enterRule(); | ||
| 2091 | } | ||
| 2092 | @after { | ||
| 2093 | leaveRule(); | ||
| 2094 | }: | ||
| 2095 | ( | ||
| 2096 | ( | ||
| 2097 | ( | ||
| 2098 | lv_abstract_0_0='abstract' | ||
| 2099 | { | ||
| 2100 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); | ||
| 2101 | } | ||
| 2102 | { | ||
| 2103 | if ($current==null) { | ||
| 2104 | $current = createModelElement(grammarAccess.getClassInterpretationRule()); | ||
| 2105 | } | ||
| 2106 | setWithLastConsumed($current, "abstract", true, "abstract"); | ||
| 2107 | } | ||
| 2108 | ) | ||
| 2109 | ) | ||
| 2110 | otherlv_1='class' | ||
| 2111 | { | ||
| 2112 | newLeafNode(otherlv_1, grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); | ||
| 2113 | } | ||
| 2114 | ( | ||
| 2115 | ( | ||
| 2116 | { | ||
| 2117 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); | ||
| 2118 | } | ||
| 2119 | lv_symbol_2_0=ruleModelSymbol | ||
| 2120 | { | ||
| 2121 | if ($current==null) { | ||
| 2122 | $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 2123 | } | ||
| 2124 | set( | ||
| 2125 | $current, | ||
| 2126 | "symbol", | ||
| 2127 | lv_symbol_2_0, | ||
| 2128 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2129 | afterParserOrEnumRuleCall(); | ||
| 2130 | } | ||
| 2131 | ) | ||
| 2132 | ) | ||
| 2133 | ( | ||
| 2134 | otherlv_3='extends' | ||
| 2135 | { | ||
| 2136 | newLeafNode(otherlv_3, grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); | ||
| 2137 | } | ||
| 2138 | ( | ||
| 2139 | ( | ||
| 2140 | { | ||
| 2141 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); | ||
| 2142 | } | ||
| 2143 | lv_supertypes_4_0=ruleModelSymbol | ||
| 2144 | { | ||
| 2145 | if ($current==null) { | ||
| 2146 | $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 2147 | } | ||
| 2148 | add( | ||
| 2149 | $current, | ||
| 2150 | "supertypes", | ||
| 2151 | lv_supertypes_4_0, | ||
| 2152 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2153 | afterParserOrEnumRuleCall(); | ||
| 2154 | } | ||
| 2155 | ) | ||
| 2156 | )+ | ||
| 2157 | )? | ||
| 2158 | otherlv_5='{' | ||
| 2159 | { | ||
| 2160 | newLeafNode(otherlv_5, grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); | ||
| 2161 | } | ||
| 2162 | ( | ||
| 2163 | ( | ||
| 2164 | { | ||
| 2165 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); | ||
| 2166 | } | ||
| 2167 | lv_fielt_6_0=ruleFieldRelationInterpretation | ||
| 2168 | { | ||
| 2169 | if ($current==null) { | ||
| 2170 | $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 2171 | } | ||
| 2172 | add( | ||
| 2173 | $current, | ||
| 2174 | "fielt", | ||
| 2175 | lv_fielt_6_0, | ||
| 2176 | "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation"); | ||
| 2177 | afterParserOrEnumRuleCall(); | ||
| 2178 | } | ||
| 2179 | ) | ||
| 2180 | )* | ||
| 2181 | otherlv_7='}' | ||
| 2182 | { | ||
| 2183 | newLeafNode(otherlv_7, grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); | ||
| 2184 | } | ||
| 2185 | ) | ||
| 2186 | ; | ||
| 2187 | |||
| 2188 | // Entry rule entryRuleEnumInterpretation | ||
| 2189 | entryRuleEnumInterpretation returns [EObject current=null]: | ||
| 2190 | { newCompositeNode(grammarAccess.getEnumInterpretationRule()); } | ||
| 2191 | iv_ruleEnumInterpretation=ruleEnumInterpretation | ||
| 2192 | { $current=$iv_ruleEnumInterpretation.current; } | ||
| 2193 | EOF; | ||
| 2194 | |||
| 2195 | // Rule EnumInterpretation | ||
| 2196 | ruleEnumInterpretation returns [EObject current=null] | ||
| 2197 | @init { | ||
| 2198 | enterRule(); | ||
| 2199 | } | ||
| 2200 | @after { | ||
| 2201 | leaveRule(); | ||
| 2202 | }: | ||
| 2203 | ( | ||
| 2204 | otherlv_0='enum' | ||
| 2205 | { | ||
| 2206 | newLeafNode(otherlv_0, grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); | ||
| 2207 | } | ||
| 2208 | ( | ||
| 2209 | ( | ||
| 2210 | { | ||
| 2211 | newCompositeNode(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); | ||
| 2212 | } | ||
| 2213 | lv_Symbol_1_0=ruleModelSymbol | ||
| 2214 | { | ||
| 2215 | if ($current==null) { | ||
| 2216 | $current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); | ||
| 2217 | } | ||
| 2218 | set( | ||
| 2219 | $current, | ||
| 2220 | "Symbol", | ||
| 2221 | lv_Symbol_1_0, | ||
| 2222 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2223 | afterParserOrEnumRuleCall(); | ||
| 2224 | } | ||
| 2225 | ) | ||
| 2226 | ) | ||
| 2227 | otherlv_2='{' | ||
| 2228 | { | ||
| 2229 | newLeafNode(otherlv_2, grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); | ||
| 2230 | } | ||
| 2231 | ( | ||
| 2232 | ( | ||
| 2233 | { | ||
| 2234 | newCompositeNode(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); | ||
| 2235 | } | ||
| 2236 | lv_objects_3_0=ruleNamedObject | ||
| 2237 | { | ||
| 2238 | if ($current==null) { | ||
| 2239 | $current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); | ||
| 2240 | } | ||
| 2241 | add( | ||
| 2242 | $current, | ||
| 2243 | "objects", | ||
| 2244 | lv_objects_3_0, | ||
| 2245 | "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject"); | ||
| 2246 | afterParserOrEnumRuleCall(); | ||
| 2247 | } | ||
| 2248 | ) | ||
| 2249 | )+ | ||
| 2250 | otherlv_4='}' | ||
| 2251 | { | ||
| 2252 | newLeafNode(otherlv_4, grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); | ||
| 2253 | } | ||
| 2254 | ) | ||
| 2255 | ; | ||
| 2256 | |||
| 2257 | // Entry rule entryRuleFieldRelationInterpretation | ||
| 2258 | entryRuleFieldRelationInterpretation returns [EObject current=null]: | ||
| 2259 | { newCompositeNode(grammarAccess.getFieldRelationInterpretationRule()); } | ||
| 2260 | iv_ruleFieldRelationInterpretation=ruleFieldRelationInterpretation | ||
| 2261 | { $current=$iv_ruleFieldRelationInterpretation.current; } | ||
| 2262 | EOF; | ||
| 2263 | |||
| 2264 | // Rule FieldRelationInterpretation | ||
| 2265 | ruleFieldRelationInterpretation returns [EObject current=null] | ||
| 2266 | @init { | ||
| 2267 | enterRule(); | ||
| 2268 | } | ||
| 2269 | @after { | ||
| 2270 | leaveRule(); | ||
| 2271 | }: | ||
| 2272 | ( | ||
| 2273 | ( | ||
| 2274 | ( | ||
| 2275 | lv_containment_0_0='containment' | ||
| 2276 | { | ||
| 2277 | newLeafNode(lv_containment_0_0, grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); | ||
| 2278 | } | ||
| 2279 | { | ||
| 2280 | if ($current==null) { | ||
| 2281 | $current = createModelElement(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2282 | } | ||
| 2283 | setWithLastConsumed($current, "containment", true, "containment"); | ||
| 2284 | } | ||
| 2285 | ) | ||
| 2286 | ) | ||
| 2287 | ( | ||
| 2288 | ( | ||
| 2289 | { | ||
| 2290 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); | ||
| 2291 | } | ||
| 2292 | lv_symbol_1_0=ruleModelSymbol | ||
| 2293 | { | ||
| 2294 | if ($current==null) { | ||
| 2295 | $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2296 | } | ||
| 2297 | set( | ||
| 2298 | $current, | ||
| 2299 | "symbol", | ||
| 2300 | lv_symbol_1_0, | ||
| 2301 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2302 | afterParserOrEnumRuleCall(); | ||
| 2303 | } | ||
| 2304 | ) | ||
| 2305 | ) | ||
| 2306 | otherlv_2=':' | ||
| 2307 | { | ||
| 2308 | newLeafNode(otherlv_2, grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); | ||
| 2309 | } | ||
| 2310 | ( | ||
| 2311 | ( | ||
| 2312 | { | ||
| 2313 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); | ||
| 2314 | } | ||
| 2315 | lv_multiplicity_3_0=ruleMultiplicityDefinition | ||
| 2316 | { | ||
| 2317 | if ($current==null) { | ||
| 2318 | $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2319 | } | ||
| 2320 | set( | ||
| 2321 | $current, | ||
| 2322 | "multiplicity", | ||
| 2323 | lv_multiplicity_3_0, | ||
| 2324 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 2325 | afterParserOrEnumRuleCall(); | ||
| 2326 | } | ||
| 2327 | ) | ||
| 2328 | )? | ||
| 2329 | ( | ||
| 2330 | ( | ||
| 2331 | { | ||
| 2332 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); | ||
| 2333 | } | ||
| 2334 | lv_target_4_0=ruleSymbol | ||
| 2335 | { | ||
| 2336 | if ($current==null) { | ||
| 2337 | $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2338 | } | ||
| 2339 | set( | ||
| 2340 | $current, | ||
| 2341 | "target", | ||
| 2342 | lv_target_4_0, | ||
| 2343 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 2344 | afterParserOrEnumRuleCall(); | ||
| 2345 | } | ||
| 2346 | ) | ||
| 2347 | ) | ||
| 2348 | ) | ||
| 2349 | ; | ||
| 2350 | |||
| 2351 | // Entry rule entryRuleGlobalRelationInterpretation | ||
| 2352 | entryRuleGlobalRelationInterpretation returns [EObject current=null]: | ||
| 2353 | { newCompositeNode(grammarAccess.getGlobalRelationInterpretationRule()); } | ||
| 2354 | iv_ruleGlobalRelationInterpretation=ruleGlobalRelationInterpretation | ||
| 2355 | { $current=$iv_ruleGlobalRelationInterpretation.current; } | ||
| 2356 | EOF; | ||
| 2357 | |||
| 2358 | // Rule GlobalRelationInterpretation | ||
| 2359 | ruleGlobalRelationInterpretation returns [EObject current=null] | ||
| 2360 | @init { | ||
| 2361 | enterRule(); | ||
| 2362 | } | ||
| 2363 | @after { | ||
| 2364 | leaveRule(); | ||
| 2365 | }: | ||
| 2366 | ( | ||
| 2367 | ( | ||
| 2368 | ( | ||
| 2369 | lv_containment_0_0='containment' | ||
| 2370 | { | ||
| 2371 | newLeafNode(lv_containment_0_0, grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); | ||
| 2372 | } | ||
| 2373 | { | ||
| 2374 | if ($current==null) { | ||
| 2375 | $current = createModelElement(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2376 | } | ||
| 2377 | setWithLastConsumed($current, "containment", true, "containment"); | ||
| 2378 | } | ||
| 2379 | ) | ||
| 2380 | ) | ||
| 2381 | otherlv_1='relation' | ||
| 2382 | { | ||
| 2383 | newLeafNode(otherlv_1, grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); | ||
| 2384 | } | ||
| 2385 | ( | ||
| 2386 | ( | ||
| 2387 | { | ||
| 2388 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); | ||
| 2389 | } | ||
| 2390 | lv_symbol_2_0=ruleModelSymbol | ||
| 2391 | { | ||
| 2392 | if ($current==null) { | ||
| 2393 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2394 | } | ||
| 2395 | set( | ||
| 2396 | $current, | ||
| 2397 | "symbol", | ||
| 2398 | lv_symbol_2_0, | ||
| 2399 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2400 | afterParserOrEnumRuleCall(); | ||
| 2401 | } | ||
| 2402 | ) | ||
| 2403 | ) | ||
| 2404 | otherlv_3=':' | ||
| 2405 | { | ||
| 2406 | newLeafNode(otherlv_3, grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); | ||
| 2407 | } | ||
| 2408 | ( | ||
| 2409 | ( | ||
| 2410 | { | ||
| 2411 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); | ||
| 2412 | } | ||
| 2413 | lv_sourceMultiplicity_4_0=ruleMultiplicityDefinition | ||
| 2414 | { | ||
| 2415 | if ($current==null) { | ||
| 2416 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2417 | } | ||
| 2418 | set( | ||
| 2419 | $current, | ||
| 2420 | "sourceMultiplicity", | ||
| 2421 | lv_sourceMultiplicity_4_0, | ||
| 2422 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 2423 | afterParserOrEnumRuleCall(); | ||
| 2424 | } | ||
| 2425 | ) | ||
| 2426 | )? | ||
| 2427 | ( | ||
| 2428 | ( | ||
| 2429 | { | ||
| 2430 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); | ||
| 2431 | } | ||
| 2432 | lv_source_5_0=ruleSymbol | ||
| 2433 | { | ||
| 2434 | if ($current==null) { | ||
| 2435 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2436 | } | ||
| 2437 | set( | ||
| 2438 | $current, | ||
| 2439 | "source", | ||
| 2440 | lv_source_5_0, | ||
| 2441 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 2442 | afterParserOrEnumRuleCall(); | ||
| 2443 | } | ||
| 2444 | ) | ||
| 2445 | ) | ||
| 2446 | ( | ||
| 2447 | ( | ||
| 2448 | { | ||
| 2449 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); | ||
| 2450 | } | ||
| 2451 | lv_targetMultiplicity_6_0=ruleMultiplicityDefinition | ||
| 2452 | { | ||
| 2453 | if ($current==null) { | ||
| 2454 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2455 | } | ||
| 2456 | set( | ||
| 2457 | $current, | ||
| 2458 | "targetMultiplicity", | ||
| 2459 | lv_targetMultiplicity_6_0, | ||
| 2460 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 2461 | afterParserOrEnumRuleCall(); | ||
| 2462 | } | ||
| 2463 | ) | ||
| 2464 | )? | ||
| 2465 | ( | ||
| 2466 | ( | ||
| 2467 | { | ||
| 2468 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); | ||
| 2469 | } | ||
| 2470 | lv_target_7_0=ruleSymbol | ||
| 2471 | { | ||
| 2472 | if ($current==null) { | ||
| 2473 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2474 | } | ||
| 2475 | set( | ||
| 2476 | $current, | ||
| 2477 | "target", | ||
| 2478 | lv_target_7_0, | ||
| 2479 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 2480 | afterParserOrEnumRuleCall(); | ||
| 2481 | } | ||
| 2482 | ) | ||
| 2483 | ) | ||
| 2484 | ) | ||
| 2485 | ; | ||
| 2486 | |||
| 2487 | // Entry rule entryRuleMultiplicityDefinition | ||
| 2488 | entryRuleMultiplicityDefinition returns [EObject current=null]: | ||
| 2489 | { newCompositeNode(grammarAccess.getMultiplicityDefinitionRule()); } | ||
| 2490 | iv_ruleMultiplicityDefinition=ruleMultiplicityDefinition | ||
| 2491 | { $current=$iv_ruleMultiplicityDefinition.current; } | ||
| 2492 | EOF; | ||
| 2493 | |||
| 2494 | // Rule MultiplicityDefinition | ||
| 2495 | ruleMultiplicityDefinition returns [EObject current=null] | ||
| 2496 | @init { | ||
| 2497 | enterRule(); | ||
| 2498 | } | ||
| 2499 | @after { | ||
| 2500 | leaveRule(); | ||
| 2501 | }: | ||
| 2502 | ( | ||
| 2503 | ( | ||
| 2504 | ( | ||
| 2505 | lv_lower_0_0=RULE_INT | ||
| 2506 | { | ||
| 2507 | newLeafNode(lv_lower_0_0, grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); | ||
| 2508 | } | ||
| 2509 | { | ||
| 2510 | if ($current==null) { | ||
| 2511 | $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 2512 | } | ||
| 2513 | setWithLastConsumed( | ||
| 2514 | $current, | ||
| 2515 | "lower", | ||
| 2516 | lv_lower_0_0, | ||
| 2517 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 2518 | } | ||
| 2519 | ) | ||
| 2520 | ) | ||
| 2521 | otherlv_1='..' | ||
| 2522 | { | ||
| 2523 | newLeafNode(otherlv_1, grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); | ||
| 2524 | } | ||
| 2525 | ( | ||
| 2526 | ( | ||
| 2527 | ( | ||
| 2528 | lv_upper_2_0=RULE_INT | ||
| 2529 | { | ||
| 2530 | newLeafNode(lv_upper_2_0, grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); | ||
| 2531 | } | ||
| 2532 | { | ||
| 2533 | if ($current==null) { | ||
| 2534 | $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 2535 | } | ||
| 2536 | setWithLastConsumed( | ||
| 2537 | $current, | ||
| 2538 | "upper", | ||
| 2539 | lv_upper_2_0, | ||
| 2540 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 2541 | } | ||
| 2542 | ) | ||
| 2543 | ) | ||
| 2544 | | | ||
| 2545 | ( | ||
| 2546 | ( | ||
| 2547 | lv_unlimitedUpper_3_0='*' | ||
| 2548 | { | ||
| 2549 | newLeafNode(lv_unlimitedUpper_3_0, grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); | ||
| 2550 | } | ||
| 2551 | { | ||
| 2552 | if ($current==null) { | ||
| 2553 | $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 2554 | } | ||
| 2555 | setWithLastConsumed($current, "unlimitedUpper", true, "*"); | ||
| 2556 | } | ||
| 2557 | ) | ||
| 2558 | ) | ||
| 2559 | ) | ||
| 2560 | ) | ||
| 2561 | ; | ||
| 2562 | |||
| 2563 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; | ||
| 2564 | |||
| 2565 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
| 2566 | |||
| 2567 | RULE_INT : ('0'..'9')+; | ||
| 2568 | |||
| 2569 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | ||
| 2570 | |||
| 2571 | RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; | ||
| 2572 | |||
| 2573 | RULE_WS : (' '|'\t'|'\r'|'\n')+; | ||
| 2574 | |||
| 2575 | RULE_ANY_OTHER : .; | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens new file mode 100644 index 00000000..1abe7de4 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens | |||
| @@ -0,0 +1,67 @@ | |||
| 1 | '('=17 | ||
| 2 | ')'=18 | ||
| 3 | '*'=30 | ||
| 4 | '+'=29 | ||
| 5 | '-'=11 | ||
| 6 | '.'=12 | ||
| 7 | '..'=40 | ||
| 8 | ':'=19 | ||
| 9 | '\''=26 | ||
| 10 | 'abstract'=32 | ||
| 11 | 'bool'=22 | ||
| 12 | 'class'=33 | ||
| 13 | 'containment'=38 | ||
| 14 | 'default'=31 | ||
| 15 | 'enum'=37 | ||
| 16 | 'equals'=21 | ||
| 17 | 'error'=16 | ||
| 18 | 'exists'=20 | ||
| 19 | 'extends'=34 | ||
| 20 | 'false'=14 | ||
| 21 | 'int'=23 | ||
| 22 | 'predicate'=27 | ||
| 23 | 'real'=24 | ||
| 24 | 'relation'=39 | ||
| 25 | 'string'=25 | ||
| 26 | 'true'=13 | ||
| 27 | 'unknown'=15 | ||
| 28 | '{'=35 | ||
| 29 | '|'=28 | ||
| 30 | '}'=36 | ||
| 31 | RULE_ANY_OTHER=10 | ||
| 32 | RULE_ID=5 | ||
| 33 | RULE_INT=4 | ||
| 34 | RULE_ML_COMMENT=7 | ||
| 35 | RULE_SL_COMMENT=8 | ||
| 36 | RULE_STRING=6 | ||
| 37 | RULE_WS=9 | ||
| 38 | T__11=11 | ||
| 39 | T__12=12 | ||
| 40 | T__13=13 | ||
| 41 | T__14=14 | ||
| 42 | T__15=15 | ||
| 43 | T__16=16 | ||
| 44 | T__17=17 | ||
| 45 | T__18=18 | ||
| 46 | T__19=19 | ||
| 47 | T__20=20 | ||
| 48 | T__21=21 | ||
| 49 | T__22=22 | ||
| 50 | T__23=23 | ||
| 51 | T__24=24 | ||
| 52 | T__25=25 | ||
| 53 | T__26=26 | ||
| 54 | T__27=27 | ||
| 55 | T__28=28 | ||
| 56 | T__29=29 | ||
| 57 | T__30=30 | ||
| 58 | T__31=31 | ||
| 59 | T__32=32 | ||
| 60 | T__33=33 | ||
| 61 | T__34=34 | ||
| 62 | T__35=35 | ||
| 63 | T__36=36 | ||
| 64 | T__37=37 | ||
| 65 | T__38=38 | ||
| 66 | T__39=39 | ||
| 67 | T__40=40 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java new file mode 100644 index 00000000..f8cb627c --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java | |||
| @@ -0,0 +1,1669 @@ | |||
| 1 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
| 2 | |||
| 3 | // Hack: Use our own Lexer superclass by means of import. | ||
| 4 | // Currently there is no other way to specify the superclass for the lexer. | ||
| 5 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
| 6 | |||
| 7 | |||
| 8 | import org.antlr.runtime.*; | ||
| 9 | import java.util.Stack; | ||
| 10 | import java.util.List; | ||
| 11 | import java.util.ArrayList; | ||
| 12 | |||
| 13 | @SuppressWarnings("all") | ||
| 14 | public class InternalSolverLanguageLexer extends Lexer { | ||
| 15 | public static final int RULE_STRING=6; | ||
| 16 | public static final int RULE_SL_COMMENT=8; | ||
| 17 | public static final int T__19=19; | ||
| 18 | public static final int T__15=15; | ||
| 19 | public static final int T__37=37; | ||
| 20 | public static final int T__16=16; | ||
| 21 | public static final int T__38=38; | ||
| 22 | public static final int T__17=17; | ||
| 23 | public static final int T__39=39; | ||
| 24 | public static final int T__18=18; | ||
| 25 | public static final int T__11=11; | ||
| 26 | public static final int T__33=33; | ||
| 27 | public static final int T__12=12; | ||
| 28 | public static final int T__34=34; | ||
| 29 | public static final int T__13=13; | ||
| 30 | public static final int T__35=35; | ||
| 31 | public static final int T__14=14; | ||
| 32 | public static final int T__36=36; | ||
| 33 | public static final int EOF=-1; | ||
| 34 | public static final int T__30=30; | ||
| 35 | public static final int T__31=31; | ||
| 36 | public static final int T__32=32; | ||
| 37 | public static final int RULE_ID=5; | ||
| 38 | public static final int RULE_WS=9; | ||
| 39 | public static final int RULE_ANY_OTHER=10; | ||
| 40 | public static final int T__26=26; | ||
| 41 | public static final int T__27=27; | ||
| 42 | public static final int T__28=28; | ||
| 43 | public static final int RULE_INT=4; | ||
| 44 | public static final int T__29=29; | ||
| 45 | public static final int T__22=22; | ||
| 46 | public static final int RULE_ML_COMMENT=7; | ||
| 47 | public static final int T__23=23; | ||
| 48 | public static final int T__24=24; | ||
| 49 | public static final int T__25=25; | ||
| 50 | public static final int T__40=40; | ||
| 51 | public static final int T__20=20; | ||
| 52 | public static final int T__21=21; | ||
| 53 | |||
| 54 | // delegates | ||
| 55 | // delegators | ||
| 56 | |||
| 57 | public InternalSolverLanguageLexer() {;} | ||
| 58 | public InternalSolverLanguageLexer(CharStream input) { | ||
| 59 | this(input, new RecognizerSharedState()); | ||
| 60 | } | ||
| 61 | public InternalSolverLanguageLexer(CharStream input, RecognizerSharedState state) { | ||
| 62 | super(input,state); | ||
| 63 | |||
| 64 | } | ||
| 65 | public String getGrammarFileName() { return "InternalSolverLanguage.g"; } | ||
| 66 | |||
| 67 | // $ANTLR start "T__11" | ||
| 68 | public final void mT__11() throws RecognitionException { | ||
| 69 | try { | ||
| 70 | int _type = T__11; | ||
| 71 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 72 | // InternalSolverLanguage.g:11:7: ( '-' ) | ||
| 73 | // InternalSolverLanguage.g:11:9: '-' | ||
| 74 | { | ||
| 75 | match('-'); | ||
| 76 | |||
| 77 | } | ||
| 78 | |||
| 79 | state.type = _type; | ||
| 80 | state.channel = _channel; | ||
| 81 | } | ||
| 82 | finally { | ||
| 83 | } | ||
| 84 | } | ||
| 85 | // $ANTLR end "T__11" | ||
| 86 | |||
| 87 | // $ANTLR start "T__12" | ||
| 88 | public final void mT__12() throws RecognitionException { | ||
| 89 | try { | ||
| 90 | int _type = T__12; | ||
| 91 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 92 | // InternalSolverLanguage.g:12:7: ( '.' ) | ||
| 93 | // InternalSolverLanguage.g:12:9: '.' | ||
| 94 | { | ||
| 95 | match('.'); | ||
| 96 | |||
| 97 | } | ||
| 98 | |||
| 99 | state.type = _type; | ||
| 100 | state.channel = _channel; | ||
| 101 | } | ||
| 102 | finally { | ||
| 103 | } | ||
| 104 | } | ||
| 105 | // $ANTLR end "T__12" | ||
| 106 | |||
| 107 | // $ANTLR start "T__13" | ||
| 108 | public final void mT__13() throws RecognitionException { | ||
| 109 | try { | ||
| 110 | int _type = T__13; | ||
| 111 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 112 | // InternalSolverLanguage.g:13:7: ( 'true' ) | ||
| 113 | // InternalSolverLanguage.g:13:9: 'true' | ||
| 114 | { | ||
| 115 | match("true"); | ||
| 116 | |||
| 117 | |||
| 118 | } | ||
| 119 | |||
| 120 | state.type = _type; | ||
| 121 | state.channel = _channel; | ||
| 122 | } | ||
| 123 | finally { | ||
| 124 | } | ||
| 125 | } | ||
| 126 | // $ANTLR end "T__13" | ||
| 127 | |||
| 128 | // $ANTLR start "T__14" | ||
| 129 | public final void mT__14() throws RecognitionException { | ||
| 130 | try { | ||
| 131 | int _type = T__14; | ||
| 132 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 133 | // InternalSolverLanguage.g:14:7: ( 'false' ) | ||
| 134 | // InternalSolverLanguage.g:14:9: 'false' | ||
| 135 | { | ||
| 136 | match("false"); | ||
| 137 | |||
| 138 | |||
| 139 | } | ||
| 140 | |||
| 141 | state.type = _type; | ||
| 142 | state.channel = _channel; | ||
| 143 | } | ||
| 144 | finally { | ||
| 145 | } | ||
| 146 | } | ||
| 147 | // $ANTLR end "T__14" | ||
| 148 | |||
| 149 | // $ANTLR start "T__15" | ||
| 150 | public final void mT__15() throws RecognitionException { | ||
| 151 | try { | ||
| 152 | int _type = T__15; | ||
| 153 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 154 | // InternalSolverLanguage.g:15:7: ( 'unknown' ) | ||
| 155 | // InternalSolverLanguage.g:15:9: 'unknown' | ||
| 156 | { | ||
| 157 | match("unknown"); | ||
| 158 | |||
| 159 | |||
| 160 | } | ||
| 161 | |||
| 162 | state.type = _type; | ||
| 163 | state.channel = _channel; | ||
| 164 | } | ||
| 165 | finally { | ||
| 166 | } | ||
| 167 | } | ||
| 168 | // $ANTLR end "T__15" | ||
| 169 | |||
| 170 | // $ANTLR start "T__16" | ||
| 171 | public final void mT__16() throws RecognitionException { | ||
| 172 | try { | ||
| 173 | int _type = T__16; | ||
| 174 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 175 | // InternalSolverLanguage.g:16:7: ( 'error' ) | ||
| 176 | // InternalSolverLanguage.g:16:9: 'error' | ||
| 177 | { | ||
| 178 | match("error"); | ||
| 179 | |||
| 180 | |||
| 181 | } | ||
| 182 | |||
| 183 | state.type = _type; | ||
| 184 | state.channel = _channel; | ||
| 185 | } | ||
| 186 | finally { | ||
| 187 | } | ||
| 188 | } | ||
| 189 | // $ANTLR end "T__16" | ||
| 190 | |||
| 191 | // $ANTLR start "T__17" | ||
| 192 | public final void mT__17() throws RecognitionException { | ||
| 193 | try { | ||
| 194 | int _type = T__17; | ||
| 195 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 196 | // InternalSolverLanguage.g:17:7: ( '(' ) | ||
| 197 | // InternalSolverLanguage.g:17:9: '(' | ||
| 198 | { | ||
| 199 | match('('); | ||
| 200 | |||
| 201 | } | ||
| 202 | |||
| 203 | state.type = _type; | ||
| 204 | state.channel = _channel; | ||
| 205 | } | ||
| 206 | finally { | ||
| 207 | } | ||
| 208 | } | ||
| 209 | // $ANTLR end "T__17" | ||
| 210 | |||
| 211 | // $ANTLR start "T__18" | ||
| 212 | public final void mT__18() throws RecognitionException { | ||
| 213 | try { | ||
| 214 | int _type = T__18; | ||
| 215 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 216 | // InternalSolverLanguage.g:18:7: ( ')' ) | ||
| 217 | // InternalSolverLanguage.g:18:9: ')' | ||
| 218 | { | ||
| 219 | match(')'); | ||
| 220 | |||
| 221 | } | ||
| 222 | |||
| 223 | state.type = _type; | ||
| 224 | state.channel = _channel; | ||
| 225 | } | ||
| 226 | finally { | ||
| 227 | } | ||
| 228 | } | ||
| 229 | // $ANTLR end "T__18" | ||
| 230 | |||
| 231 | // $ANTLR start "T__19" | ||
| 232 | public final void mT__19() throws RecognitionException { | ||
| 233 | try { | ||
| 234 | int _type = T__19; | ||
| 235 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 236 | // InternalSolverLanguage.g:19:7: ( ':' ) | ||
| 237 | // InternalSolverLanguage.g:19:9: ':' | ||
| 238 | { | ||
| 239 | match(':'); | ||
| 240 | |||
| 241 | } | ||
| 242 | |||
| 243 | state.type = _type; | ||
| 244 | state.channel = _channel; | ||
| 245 | } | ||
| 246 | finally { | ||
| 247 | } | ||
| 248 | } | ||
| 249 | // $ANTLR end "T__19" | ||
| 250 | |||
| 251 | // $ANTLR start "T__20" | ||
| 252 | public final void mT__20() throws RecognitionException { | ||
| 253 | try { | ||
| 254 | int _type = T__20; | ||
| 255 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 256 | // InternalSolverLanguage.g:20:7: ( 'exists' ) | ||
| 257 | // InternalSolverLanguage.g:20:9: 'exists' | ||
| 258 | { | ||
| 259 | match("exists"); | ||
| 260 | |||
| 261 | |||
| 262 | } | ||
| 263 | |||
| 264 | state.type = _type; | ||
| 265 | state.channel = _channel; | ||
| 266 | } | ||
| 267 | finally { | ||
| 268 | } | ||
| 269 | } | ||
| 270 | // $ANTLR end "T__20" | ||
| 271 | |||
| 272 | // $ANTLR start "T__21" | ||
| 273 | public final void mT__21() throws RecognitionException { | ||
| 274 | try { | ||
| 275 | int _type = T__21; | ||
| 276 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 277 | // InternalSolverLanguage.g:21:7: ( 'equals' ) | ||
| 278 | // InternalSolverLanguage.g:21:9: 'equals' | ||
| 279 | { | ||
| 280 | match("equals"); | ||
| 281 | |||
| 282 | |||
| 283 | } | ||
| 284 | |||
| 285 | state.type = _type; | ||
| 286 | state.channel = _channel; | ||
| 287 | } | ||
| 288 | finally { | ||
| 289 | } | ||
| 290 | } | ||
| 291 | // $ANTLR end "T__21" | ||
| 292 | |||
| 293 | // $ANTLR start "T__22" | ||
| 294 | public final void mT__22() throws RecognitionException { | ||
| 295 | try { | ||
| 296 | int _type = T__22; | ||
| 297 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 298 | // InternalSolverLanguage.g:22:7: ( 'bool' ) | ||
| 299 | // InternalSolverLanguage.g:22:9: 'bool' | ||
| 300 | { | ||
| 301 | match("bool"); | ||
| 302 | |||
| 303 | |||
| 304 | } | ||
| 305 | |||
| 306 | state.type = _type; | ||
| 307 | state.channel = _channel; | ||
| 308 | } | ||
| 309 | finally { | ||
| 310 | } | ||
| 311 | } | ||
| 312 | // $ANTLR end "T__22" | ||
| 313 | |||
| 314 | // $ANTLR start "T__23" | ||
| 315 | public final void mT__23() throws RecognitionException { | ||
| 316 | try { | ||
| 317 | int _type = T__23; | ||
| 318 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 319 | // InternalSolverLanguage.g:23:7: ( 'int' ) | ||
| 320 | // InternalSolverLanguage.g:23:9: 'int' | ||
| 321 | { | ||
| 322 | match("int"); | ||
| 323 | |||
| 324 | |||
| 325 | } | ||
| 326 | |||
| 327 | state.type = _type; | ||
| 328 | state.channel = _channel; | ||
| 329 | } | ||
| 330 | finally { | ||
| 331 | } | ||
| 332 | } | ||
| 333 | // $ANTLR end "T__23" | ||
| 334 | |||
| 335 | // $ANTLR start "T__24" | ||
| 336 | public final void mT__24() throws RecognitionException { | ||
| 337 | try { | ||
| 338 | int _type = T__24; | ||
| 339 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 340 | // InternalSolverLanguage.g:24:7: ( 'real' ) | ||
| 341 | // InternalSolverLanguage.g:24:9: 'real' | ||
| 342 | { | ||
| 343 | match("real"); | ||
| 344 | |||
| 345 | |||
| 346 | } | ||
| 347 | |||
| 348 | state.type = _type; | ||
| 349 | state.channel = _channel; | ||
| 350 | } | ||
| 351 | finally { | ||
| 352 | } | ||
| 353 | } | ||
| 354 | // $ANTLR end "T__24" | ||
| 355 | |||
| 356 | // $ANTLR start "T__25" | ||
| 357 | public final void mT__25() throws RecognitionException { | ||
| 358 | try { | ||
| 359 | int _type = T__25; | ||
| 360 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 361 | // InternalSolverLanguage.g:25:7: ( 'string' ) | ||
| 362 | // InternalSolverLanguage.g:25:9: 'string' | ||
| 363 | { | ||
| 364 | match("string"); | ||
| 365 | |||
| 366 | |||
| 367 | } | ||
| 368 | |||
| 369 | state.type = _type; | ||
| 370 | state.channel = _channel; | ||
| 371 | } | ||
| 372 | finally { | ||
| 373 | } | ||
| 374 | } | ||
| 375 | // $ANTLR end "T__25" | ||
| 376 | |||
| 377 | // $ANTLR start "T__26" | ||
| 378 | public final void mT__26() throws RecognitionException { | ||
| 379 | try { | ||
| 380 | int _type = T__26; | ||
| 381 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 382 | // InternalSolverLanguage.g:26:7: ( '\\'' ) | ||
| 383 | // InternalSolverLanguage.g:26:9: '\\'' | ||
| 384 | { | ||
| 385 | match('\''); | ||
| 386 | |||
| 387 | } | ||
| 388 | |||
| 389 | state.type = _type; | ||
| 390 | state.channel = _channel; | ||
| 391 | } | ||
| 392 | finally { | ||
| 393 | } | ||
| 394 | } | ||
| 395 | // $ANTLR end "T__26" | ||
| 396 | |||
| 397 | // $ANTLR start "T__27" | ||
| 398 | public final void mT__27() throws RecognitionException { | ||
| 399 | try { | ||
| 400 | int _type = T__27; | ||
| 401 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 402 | // InternalSolverLanguage.g:27:7: ( 'predicate' ) | ||
| 403 | // InternalSolverLanguage.g:27:9: 'predicate' | ||
| 404 | { | ||
| 405 | match("predicate"); | ||
| 406 | |||
| 407 | |||
| 408 | } | ||
| 409 | |||
| 410 | state.type = _type; | ||
| 411 | state.channel = _channel; | ||
| 412 | } | ||
| 413 | finally { | ||
| 414 | } | ||
| 415 | } | ||
| 416 | // $ANTLR end "T__27" | ||
| 417 | |||
| 418 | // $ANTLR start "T__28" | ||
| 419 | public final void mT__28() throws RecognitionException { | ||
| 420 | try { | ||
| 421 | int _type = T__28; | ||
| 422 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 423 | // InternalSolverLanguage.g:28:7: ( '|' ) | ||
| 424 | // InternalSolverLanguage.g:28:9: '|' | ||
| 425 | { | ||
| 426 | match('|'); | ||
| 427 | |||
| 428 | } | ||
| 429 | |||
| 430 | state.type = _type; | ||
| 431 | state.channel = _channel; | ||
| 432 | } | ||
| 433 | finally { | ||
| 434 | } | ||
| 435 | } | ||
| 436 | // $ANTLR end "T__28" | ||
| 437 | |||
| 438 | // $ANTLR start "T__29" | ||
| 439 | public final void mT__29() throws RecognitionException { | ||
| 440 | try { | ||
| 441 | int _type = T__29; | ||
| 442 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 443 | // InternalSolverLanguage.g:29:7: ( '+' ) | ||
| 444 | // InternalSolverLanguage.g:29:9: '+' | ||
| 445 | { | ||
| 446 | match('+'); | ||
| 447 | |||
| 448 | } | ||
| 449 | |||
| 450 | state.type = _type; | ||
| 451 | state.channel = _channel; | ||
| 452 | } | ||
| 453 | finally { | ||
| 454 | } | ||
| 455 | } | ||
| 456 | // $ANTLR end "T__29" | ||
| 457 | |||
| 458 | // $ANTLR start "T__30" | ||
| 459 | public final void mT__30() throws RecognitionException { | ||
| 460 | try { | ||
| 461 | int _type = T__30; | ||
| 462 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 463 | // InternalSolverLanguage.g:30:7: ( '*' ) | ||
| 464 | // InternalSolverLanguage.g:30:9: '*' | ||
| 465 | { | ||
| 466 | match('*'); | ||
| 467 | |||
| 468 | } | ||
| 469 | |||
| 470 | state.type = _type; | ||
| 471 | state.channel = _channel; | ||
| 472 | } | ||
| 473 | finally { | ||
| 474 | } | ||
| 475 | } | ||
| 476 | // $ANTLR end "T__30" | ||
| 477 | |||
| 478 | // $ANTLR start "T__31" | ||
| 479 | public final void mT__31() throws RecognitionException { | ||
| 480 | try { | ||
| 481 | int _type = T__31; | ||
| 482 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 483 | // InternalSolverLanguage.g:31:7: ( 'default' ) | ||
| 484 | // InternalSolverLanguage.g:31:9: 'default' | ||
| 485 | { | ||
| 486 | match("default"); | ||
| 487 | |||
| 488 | |||
| 489 | } | ||
| 490 | |||
| 491 | state.type = _type; | ||
| 492 | state.channel = _channel; | ||
| 493 | } | ||
| 494 | finally { | ||
| 495 | } | ||
| 496 | } | ||
| 497 | // $ANTLR end "T__31" | ||
| 498 | |||
| 499 | // $ANTLR start "T__32" | ||
| 500 | public final void mT__32() throws RecognitionException { | ||
| 501 | try { | ||
| 502 | int _type = T__32; | ||
| 503 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 504 | // InternalSolverLanguage.g:32:7: ( 'abstract' ) | ||
| 505 | // InternalSolverLanguage.g:32:9: 'abstract' | ||
| 506 | { | ||
| 507 | match("abstract"); | ||
| 508 | |||
| 509 | |||
| 510 | } | ||
| 511 | |||
| 512 | state.type = _type; | ||
| 513 | state.channel = _channel; | ||
| 514 | } | ||
| 515 | finally { | ||
| 516 | } | ||
| 517 | } | ||
| 518 | // $ANTLR end "T__32" | ||
| 519 | |||
| 520 | // $ANTLR start "T__33" | ||
| 521 | public final void mT__33() throws RecognitionException { | ||
| 522 | try { | ||
| 523 | int _type = T__33; | ||
| 524 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 525 | // InternalSolverLanguage.g:33:7: ( 'class' ) | ||
| 526 | // InternalSolverLanguage.g:33:9: 'class' | ||
| 527 | { | ||
| 528 | match("class"); | ||
| 529 | |||
| 530 | |||
| 531 | } | ||
| 532 | |||
| 533 | state.type = _type; | ||
| 534 | state.channel = _channel; | ||
| 535 | } | ||
| 536 | finally { | ||
| 537 | } | ||
| 538 | } | ||
| 539 | // $ANTLR end "T__33" | ||
| 540 | |||
| 541 | // $ANTLR start "T__34" | ||
| 542 | public final void mT__34() throws RecognitionException { | ||
| 543 | try { | ||
| 544 | int _type = T__34; | ||
| 545 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 546 | // InternalSolverLanguage.g:34:7: ( 'extends' ) | ||
| 547 | // InternalSolverLanguage.g:34:9: 'extends' | ||
| 548 | { | ||
| 549 | match("extends"); | ||
| 550 | |||
| 551 | |||
| 552 | } | ||
| 553 | |||
| 554 | state.type = _type; | ||
| 555 | state.channel = _channel; | ||
| 556 | } | ||
| 557 | finally { | ||
| 558 | } | ||
| 559 | } | ||
| 560 | // $ANTLR end "T__34" | ||
| 561 | |||
| 562 | // $ANTLR start "T__35" | ||
| 563 | public final void mT__35() throws RecognitionException { | ||
| 564 | try { | ||
| 565 | int _type = T__35; | ||
| 566 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 567 | // InternalSolverLanguage.g:35:7: ( '{' ) | ||
| 568 | // InternalSolverLanguage.g:35:9: '{' | ||
| 569 | { | ||
| 570 | match('{'); | ||
| 571 | |||
| 572 | } | ||
| 573 | |||
| 574 | state.type = _type; | ||
| 575 | state.channel = _channel; | ||
| 576 | } | ||
| 577 | finally { | ||
| 578 | } | ||
| 579 | } | ||
| 580 | // $ANTLR end "T__35" | ||
| 581 | |||
| 582 | // $ANTLR start "T__36" | ||
| 583 | public final void mT__36() throws RecognitionException { | ||
| 584 | try { | ||
| 585 | int _type = T__36; | ||
| 586 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 587 | // InternalSolverLanguage.g:36:7: ( '}' ) | ||
| 588 | // InternalSolverLanguage.g:36:9: '}' | ||
| 589 | { | ||
| 590 | match('}'); | ||
| 591 | |||
| 592 | } | ||
| 593 | |||
| 594 | state.type = _type; | ||
| 595 | state.channel = _channel; | ||
| 596 | } | ||
| 597 | finally { | ||
| 598 | } | ||
| 599 | } | ||
| 600 | // $ANTLR end "T__36" | ||
| 601 | |||
| 602 | // $ANTLR start "T__37" | ||
| 603 | public final void mT__37() throws RecognitionException { | ||
| 604 | try { | ||
| 605 | int _type = T__37; | ||
| 606 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 607 | // InternalSolverLanguage.g:37:7: ( 'enum' ) | ||
| 608 | // InternalSolverLanguage.g:37:9: 'enum' | ||
| 609 | { | ||
| 610 | match("enum"); | ||
| 611 | |||
| 612 | |||
| 613 | } | ||
| 614 | |||
| 615 | state.type = _type; | ||
| 616 | state.channel = _channel; | ||
| 617 | } | ||
| 618 | finally { | ||
| 619 | } | ||
| 620 | } | ||
| 621 | // $ANTLR end "T__37" | ||
| 622 | |||
| 623 | // $ANTLR start "T__38" | ||
| 624 | public final void mT__38() throws RecognitionException { | ||
| 625 | try { | ||
| 626 | int _type = T__38; | ||
| 627 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 628 | // InternalSolverLanguage.g:38:7: ( 'containment' ) | ||
| 629 | // InternalSolverLanguage.g:38:9: 'containment' | ||
| 630 | { | ||
| 631 | match("containment"); | ||
| 632 | |||
| 633 | |||
| 634 | } | ||
| 635 | |||
| 636 | state.type = _type; | ||
| 637 | state.channel = _channel; | ||
| 638 | } | ||
| 639 | finally { | ||
| 640 | } | ||
| 641 | } | ||
| 642 | // $ANTLR end "T__38" | ||
| 643 | |||
| 644 | // $ANTLR start "T__39" | ||
| 645 | public final void mT__39() throws RecognitionException { | ||
| 646 | try { | ||
| 647 | int _type = T__39; | ||
| 648 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 649 | // InternalSolverLanguage.g:39:7: ( 'relation' ) | ||
| 650 | // InternalSolverLanguage.g:39:9: 'relation' | ||
| 651 | { | ||
| 652 | match("relation"); | ||
| 653 | |||
| 654 | |||
| 655 | } | ||
| 656 | |||
| 657 | state.type = _type; | ||
| 658 | state.channel = _channel; | ||
| 659 | } | ||
| 660 | finally { | ||
| 661 | } | ||
| 662 | } | ||
| 663 | // $ANTLR end "T__39" | ||
| 664 | |||
| 665 | // $ANTLR start "T__40" | ||
| 666 | public final void mT__40() throws RecognitionException { | ||
| 667 | try { | ||
| 668 | int _type = T__40; | ||
| 669 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 670 | // InternalSolverLanguage.g:40:7: ( '..' ) | ||
| 671 | // InternalSolverLanguage.g:40:9: '..' | ||
| 672 | { | ||
| 673 | match(".."); | ||
| 674 | |||
| 675 | |||
| 676 | } | ||
| 677 | |||
| 678 | state.type = _type; | ||
| 679 | state.channel = _channel; | ||
| 680 | } | ||
| 681 | finally { | ||
| 682 | } | ||
| 683 | } | ||
| 684 | // $ANTLR end "T__40" | ||
| 685 | |||
| 686 | // $ANTLR start "RULE_STRING" | ||
| 687 | public final void mRULE_STRING() throws RecognitionException { | ||
| 688 | try { | ||
| 689 | int _type = RULE_STRING; | ||
| 690 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 691 | // InternalSolverLanguage.g:2563:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | ||
| 692 | // InternalSolverLanguage.g:2563:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | ||
| 693 | { | ||
| 694 | match('\"'); | ||
| 695 | // InternalSolverLanguage.g:2563:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | ||
| 696 | loop1: | ||
| 697 | do { | ||
| 698 | int alt1=3; | ||
| 699 | int LA1_0 = input.LA(1); | ||
| 700 | |||
| 701 | if ( (LA1_0=='\\') ) { | ||
| 702 | alt1=1; | ||
| 703 | } | ||
| 704 | else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { | ||
| 705 | alt1=2; | ||
| 706 | } | ||
| 707 | |||
| 708 | |||
| 709 | switch (alt1) { | ||
| 710 | case 1 : | ||
| 711 | // InternalSolverLanguage.g:2563:20: '\\\\' . | ||
| 712 | { | ||
| 713 | match('\\'); | ||
| 714 | matchAny(); | ||
| 715 | |||
| 716 | } | ||
| 717 | break; | ||
| 718 | case 2 : | ||
| 719 | // InternalSolverLanguage.g:2563:27: ~ ( ( '\\\\' | '\"' ) ) | ||
| 720 | { | ||
| 721 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
| 722 | input.consume(); | ||
| 723 | |||
| 724 | } | ||
| 725 | else { | ||
| 726 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 727 | recover(mse); | ||
| 728 | throw mse;} | ||
| 729 | |||
| 730 | |||
| 731 | } | ||
| 732 | break; | ||
| 733 | |||
| 734 | default : | ||
| 735 | break loop1; | ||
| 736 | } | ||
| 737 | } while (true); | ||
| 738 | |||
| 739 | match('\"'); | ||
| 740 | |||
| 741 | } | ||
| 742 | |||
| 743 | state.type = _type; | ||
| 744 | state.channel = _channel; | ||
| 745 | } | ||
| 746 | finally { | ||
| 747 | } | ||
| 748 | } | ||
| 749 | // $ANTLR end "RULE_STRING" | ||
| 750 | |||
| 751 | // $ANTLR start "RULE_ID" | ||
| 752 | public final void mRULE_ID() throws RecognitionException { | ||
| 753 | try { | ||
| 754 | int _type = RULE_ID; | ||
| 755 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 756 | // InternalSolverLanguage.g:2565:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | ||
| 757 | // InternalSolverLanguage.g:2565:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
| 758 | { | ||
| 759 | // InternalSolverLanguage.g:2565:11: ( '^' )? | ||
| 760 | int alt2=2; | ||
| 761 | int LA2_0 = input.LA(1); | ||
| 762 | |||
| 763 | if ( (LA2_0=='^') ) { | ||
| 764 | alt2=1; | ||
| 765 | } | ||
| 766 | switch (alt2) { | ||
| 767 | case 1 : | ||
| 768 | // InternalSolverLanguage.g:2565:11: '^' | ||
| 769 | { | ||
| 770 | match('^'); | ||
| 771 | |||
| 772 | } | ||
| 773 | break; | ||
| 774 | |||
| 775 | } | ||
| 776 | |||
| 777 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
| 778 | input.consume(); | ||
| 779 | |||
| 780 | } | ||
| 781 | else { | ||
| 782 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 783 | recover(mse); | ||
| 784 | throw mse;} | ||
| 785 | |||
| 786 | // InternalSolverLanguage.g:2565:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
| 787 | loop3: | ||
| 788 | do { | ||
| 789 | int alt3=2; | ||
| 790 | int LA3_0 = input.LA(1); | ||
| 791 | |||
| 792 | if ( ((LA3_0>='0' && LA3_0<='9')||(LA3_0>='A' && LA3_0<='Z')||LA3_0=='_'||(LA3_0>='a' && LA3_0<='z')) ) { | ||
| 793 | alt3=1; | ||
| 794 | } | ||
| 795 | |||
| 796 | |||
| 797 | switch (alt3) { | ||
| 798 | case 1 : | ||
| 799 | // InternalSolverLanguage.g: | ||
| 800 | { | ||
| 801 | if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
| 802 | input.consume(); | ||
| 803 | |||
| 804 | } | ||
| 805 | else { | ||
| 806 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 807 | recover(mse); | ||
| 808 | throw mse;} | ||
| 809 | |||
| 810 | |||
| 811 | } | ||
| 812 | break; | ||
| 813 | |||
| 814 | default : | ||
| 815 | break loop3; | ||
| 816 | } | ||
| 817 | } while (true); | ||
| 818 | |||
| 819 | |||
| 820 | } | ||
| 821 | |||
| 822 | state.type = _type; | ||
| 823 | state.channel = _channel; | ||
| 824 | } | ||
| 825 | finally { | ||
| 826 | } | ||
| 827 | } | ||
| 828 | // $ANTLR end "RULE_ID" | ||
| 829 | |||
| 830 | // $ANTLR start "RULE_INT" | ||
| 831 | public final void mRULE_INT() throws RecognitionException { | ||
| 832 | try { | ||
| 833 | int _type = RULE_INT; | ||
| 834 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 835 | // InternalSolverLanguage.g:2567:10: ( ( '0' .. '9' )+ ) | ||
| 836 | // InternalSolverLanguage.g:2567:12: ( '0' .. '9' )+ | ||
| 837 | { | ||
| 838 | // InternalSolverLanguage.g:2567:12: ( '0' .. '9' )+ | ||
| 839 | int cnt4=0; | ||
| 840 | loop4: | ||
| 841 | do { | ||
| 842 | int alt4=2; | ||
| 843 | int LA4_0 = input.LA(1); | ||
| 844 | |||
| 845 | if ( ((LA4_0>='0' && LA4_0<='9')) ) { | ||
| 846 | alt4=1; | ||
| 847 | } | ||
| 848 | |||
| 849 | |||
| 850 | switch (alt4) { | ||
| 851 | case 1 : | ||
| 852 | // InternalSolverLanguage.g:2567:13: '0' .. '9' | ||
| 853 | { | ||
| 854 | matchRange('0','9'); | ||
| 855 | |||
| 856 | } | ||
| 857 | break; | ||
| 858 | |||
| 859 | default : | ||
| 860 | if ( cnt4 >= 1 ) break loop4; | ||
| 861 | EarlyExitException eee = | ||
| 862 | new EarlyExitException(4, input); | ||
| 863 | throw eee; | ||
| 864 | } | ||
| 865 | cnt4++; | ||
| 866 | } while (true); | ||
| 867 | |||
| 868 | |||
| 869 | } | ||
| 870 | |||
| 871 | state.type = _type; | ||
| 872 | state.channel = _channel; | ||
| 873 | } | ||
| 874 | finally { | ||
| 875 | } | ||
| 876 | } | ||
| 877 | // $ANTLR end "RULE_INT" | ||
| 878 | |||
| 879 | // $ANTLR start "RULE_ML_COMMENT" | ||
| 880 | public final void mRULE_ML_COMMENT() throws RecognitionException { | ||
| 881 | try { | ||
| 882 | int _type = RULE_ML_COMMENT; | ||
| 883 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 884 | // InternalSolverLanguage.g:2569:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | ||
| 885 | // InternalSolverLanguage.g:2569:19: '/*' ( options {greedy=false; } : . )* '*/' | ||
| 886 | { | ||
| 887 | match("/*"); | ||
| 888 | |||
| 889 | // InternalSolverLanguage.g:2569:24: ( options {greedy=false; } : . )* | ||
| 890 | loop5: | ||
| 891 | do { | ||
| 892 | int alt5=2; | ||
| 893 | int LA5_0 = input.LA(1); | ||
| 894 | |||
| 895 | if ( (LA5_0=='*') ) { | ||
| 896 | int LA5_1 = input.LA(2); | ||
| 897 | |||
| 898 | if ( (LA5_1=='/') ) { | ||
| 899 | alt5=2; | ||
| 900 | } | ||
| 901 | else if ( ((LA5_1>='\u0000' && LA5_1<='.')||(LA5_1>='0' && LA5_1<='\uFFFF')) ) { | ||
| 902 | alt5=1; | ||
| 903 | } | ||
| 904 | |||
| 905 | |||
| 906 | } | ||
| 907 | else if ( ((LA5_0>='\u0000' && LA5_0<=')')||(LA5_0>='+' && LA5_0<='\uFFFF')) ) { | ||
| 908 | alt5=1; | ||
| 909 | } | ||
| 910 | |||
| 911 | |||
| 912 | switch (alt5) { | ||
| 913 | case 1 : | ||
| 914 | // InternalSolverLanguage.g:2569:52: . | ||
| 915 | { | ||
| 916 | matchAny(); | ||
| 917 | |||
| 918 | } | ||
| 919 | break; | ||
| 920 | |||
| 921 | default : | ||
| 922 | break loop5; | ||
| 923 | } | ||
| 924 | } while (true); | ||
| 925 | |||
| 926 | match("*/"); | ||
| 927 | |||
| 928 | |||
| 929 | } | ||
| 930 | |||
| 931 | state.type = _type; | ||
| 932 | state.channel = _channel; | ||
| 933 | } | ||
| 934 | finally { | ||
| 935 | } | ||
| 936 | } | ||
| 937 | // $ANTLR end "RULE_ML_COMMENT" | ||
| 938 | |||
| 939 | // $ANTLR start "RULE_SL_COMMENT" | ||
| 940 | public final void mRULE_SL_COMMENT() throws RecognitionException { | ||
| 941 | try { | ||
| 942 | int _type = RULE_SL_COMMENT; | ||
| 943 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 944 | // InternalSolverLanguage.g:2571:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | ||
| 945 | // InternalSolverLanguage.g:2571:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | ||
| 946 | { | ||
| 947 | match("//"); | ||
| 948 | |||
| 949 | // InternalSolverLanguage.g:2571:24: (~ ( ( '\\n' | '\\r' ) ) )* | ||
| 950 | loop6: | ||
| 951 | do { | ||
| 952 | int alt6=2; | ||
| 953 | int LA6_0 = input.LA(1); | ||
| 954 | |||
| 955 | if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) { | ||
| 956 | alt6=1; | ||
| 957 | } | ||
| 958 | |||
| 959 | |||
| 960 | switch (alt6) { | ||
| 961 | case 1 : | ||
| 962 | // InternalSolverLanguage.g:2571:24: ~ ( ( '\\n' | '\\r' ) ) | ||
| 963 | { | ||
| 964 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { | ||
| 965 | input.consume(); | ||
| 966 | |||
| 967 | } | ||
| 968 | else { | ||
| 969 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 970 | recover(mse); | ||
| 971 | throw mse;} | ||
| 972 | |||
| 973 | |||
| 974 | } | ||
| 975 | break; | ||
| 976 | |||
| 977 | default : | ||
| 978 | break loop6; | ||
| 979 | } | ||
| 980 | } while (true); | ||
| 981 | |||
| 982 | // InternalSolverLanguage.g:2571:40: ( ( '\\r' )? '\\n' )? | ||
| 983 | int alt8=2; | ||
| 984 | int LA8_0 = input.LA(1); | ||
| 985 | |||
| 986 | if ( (LA8_0=='\n'||LA8_0=='\r') ) { | ||
| 987 | alt8=1; | ||
| 988 | } | ||
| 989 | switch (alt8) { | ||
| 990 | case 1 : | ||
| 991 | // InternalSolverLanguage.g:2571:41: ( '\\r' )? '\\n' | ||
| 992 | { | ||
| 993 | // InternalSolverLanguage.g:2571:41: ( '\\r' )? | ||
| 994 | int alt7=2; | ||
| 995 | int LA7_0 = input.LA(1); | ||
| 996 | |||
| 997 | if ( (LA7_0=='\r') ) { | ||
| 998 | alt7=1; | ||
| 999 | } | ||
| 1000 | switch (alt7) { | ||
| 1001 | case 1 : | ||
| 1002 | // InternalSolverLanguage.g:2571:41: '\\r' | ||
| 1003 | { | ||
| 1004 | match('\r'); | ||
| 1005 | |||
| 1006 | } | ||
| 1007 | break; | ||
| 1008 | |||
| 1009 | } | ||
| 1010 | |||
| 1011 | match('\n'); | ||
| 1012 | |||
| 1013 | } | ||
| 1014 | break; | ||
| 1015 | |||
| 1016 | } | ||
| 1017 | |||
| 1018 | |||
| 1019 | } | ||
| 1020 | |||
| 1021 | state.type = _type; | ||
| 1022 | state.channel = _channel; | ||
| 1023 | } | ||
| 1024 | finally { | ||
| 1025 | } | ||
| 1026 | } | ||
| 1027 | // $ANTLR end "RULE_SL_COMMENT" | ||
| 1028 | |||
| 1029 | // $ANTLR start "RULE_WS" | ||
| 1030 | public final void mRULE_WS() throws RecognitionException { | ||
| 1031 | try { | ||
| 1032 | int _type = RULE_WS; | ||
| 1033 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1034 | // InternalSolverLanguage.g:2573:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | ||
| 1035 | // InternalSolverLanguage.g:2573:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
| 1036 | { | ||
| 1037 | // InternalSolverLanguage.g:2573:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
| 1038 | int cnt9=0; | ||
| 1039 | loop9: | ||
| 1040 | do { | ||
| 1041 | int alt9=2; | ||
| 1042 | int LA9_0 = input.LA(1); | ||
| 1043 | |||
| 1044 | if ( ((LA9_0>='\t' && LA9_0<='\n')||LA9_0=='\r'||LA9_0==' ') ) { | ||
| 1045 | alt9=1; | ||
| 1046 | } | ||
| 1047 | |||
| 1048 | |||
| 1049 | switch (alt9) { | ||
| 1050 | case 1 : | ||
| 1051 | // InternalSolverLanguage.g: | ||
| 1052 | { | ||
| 1053 | if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { | ||
| 1054 | input.consume(); | ||
| 1055 | |||
| 1056 | } | ||
| 1057 | else { | ||
| 1058 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 1059 | recover(mse); | ||
| 1060 | throw mse;} | ||
| 1061 | |||
| 1062 | |||
| 1063 | } | ||
| 1064 | break; | ||
| 1065 | |||
| 1066 | default : | ||
| 1067 | if ( cnt9 >= 1 ) break loop9; | ||
| 1068 | EarlyExitException eee = | ||
| 1069 | new EarlyExitException(9, input); | ||
| 1070 | throw eee; | ||
| 1071 | } | ||
| 1072 | cnt9++; | ||
| 1073 | } while (true); | ||
| 1074 | |||
| 1075 | |||
| 1076 | } | ||
| 1077 | |||
| 1078 | state.type = _type; | ||
| 1079 | state.channel = _channel; | ||
| 1080 | } | ||
| 1081 | finally { | ||
| 1082 | } | ||
| 1083 | } | ||
| 1084 | // $ANTLR end "RULE_WS" | ||
| 1085 | |||
| 1086 | // $ANTLR start "RULE_ANY_OTHER" | ||
| 1087 | public final void mRULE_ANY_OTHER() throws RecognitionException { | ||
| 1088 | try { | ||
| 1089 | int _type = RULE_ANY_OTHER; | ||
| 1090 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1091 | // InternalSolverLanguage.g:2575:16: ( . ) | ||
| 1092 | // InternalSolverLanguage.g:2575:18: . | ||
| 1093 | { | ||
| 1094 | matchAny(); | ||
| 1095 | |||
| 1096 | } | ||
| 1097 | |||
| 1098 | state.type = _type; | ||
| 1099 | state.channel = _channel; | ||
| 1100 | } | ||
| 1101 | finally { | ||
| 1102 | } | ||
| 1103 | } | ||
| 1104 | // $ANTLR end "RULE_ANY_OTHER" | ||
| 1105 | |||
| 1106 | public void mTokens() throws RecognitionException { | ||
| 1107 | // InternalSolverLanguage.g:1:8: ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) | ||
| 1108 | int alt10=37; | ||
| 1109 | alt10 = dfa10.predict(input); | ||
| 1110 | switch (alt10) { | ||
| 1111 | case 1 : | ||
| 1112 | // InternalSolverLanguage.g:1:10: T__11 | ||
| 1113 | { | ||
| 1114 | mT__11(); | ||
| 1115 | |||
| 1116 | } | ||
| 1117 | break; | ||
| 1118 | case 2 : | ||
| 1119 | // InternalSolverLanguage.g:1:16: T__12 | ||
| 1120 | { | ||
| 1121 | mT__12(); | ||
| 1122 | |||
| 1123 | } | ||
| 1124 | break; | ||
| 1125 | case 3 : | ||
| 1126 | // InternalSolverLanguage.g:1:22: T__13 | ||
| 1127 | { | ||
| 1128 | mT__13(); | ||
| 1129 | |||
| 1130 | } | ||
| 1131 | break; | ||
| 1132 | case 4 : | ||
| 1133 | // InternalSolverLanguage.g:1:28: T__14 | ||
| 1134 | { | ||
| 1135 | mT__14(); | ||
| 1136 | |||
| 1137 | } | ||
| 1138 | break; | ||
| 1139 | case 5 : | ||
| 1140 | // InternalSolverLanguage.g:1:34: T__15 | ||
| 1141 | { | ||
| 1142 | mT__15(); | ||
| 1143 | |||
| 1144 | } | ||
| 1145 | break; | ||
| 1146 | case 6 : | ||
| 1147 | // InternalSolverLanguage.g:1:40: T__16 | ||
| 1148 | { | ||
| 1149 | mT__16(); | ||
| 1150 | |||
| 1151 | } | ||
| 1152 | break; | ||
| 1153 | case 7 : | ||
| 1154 | // InternalSolverLanguage.g:1:46: T__17 | ||
| 1155 | { | ||
| 1156 | mT__17(); | ||
| 1157 | |||
| 1158 | } | ||
| 1159 | break; | ||
| 1160 | case 8 : | ||
| 1161 | // InternalSolverLanguage.g:1:52: T__18 | ||
| 1162 | { | ||
| 1163 | mT__18(); | ||
| 1164 | |||
| 1165 | } | ||
| 1166 | break; | ||
| 1167 | case 9 : | ||
| 1168 | // InternalSolverLanguage.g:1:58: T__19 | ||
| 1169 | { | ||
| 1170 | mT__19(); | ||
| 1171 | |||
| 1172 | } | ||
| 1173 | break; | ||
| 1174 | case 10 : | ||
| 1175 | // InternalSolverLanguage.g:1:64: T__20 | ||
| 1176 | { | ||
| 1177 | mT__20(); | ||
| 1178 | |||
| 1179 | } | ||
| 1180 | break; | ||
| 1181 | case 11 : | ||
| 1182 | // InternalSolverLanguage.g:1:70: T__21 | ||
| 1183 | { | ||
| 1184 | mT__21(); | ||
| 1185 | |||
| 1186 | } | ||
| 1187 | break; | ||
| 1188 | case 12 : | ||
| 1189 | // InternalSolverLanguage.g:1:76: T__22 | ||
| 1190 | { | ||
| 1191 | mT__22(); | ||
| 1192 | |||
| 1193 | } | ||
| 1194 | break; | ||
| 1195 | case 13 : | ||
| 1196 | // InternalSolverLanguage.g:1:82: T__23 | ||
| 1197 | { | ||
| 1198 | mT__23(); | ||
| 1199 | |||
| 1200 | } | ||
| 1201 | break; | ||
| 1202 | case 14 : | ||
| 1203 | // InternalSolverLanguage.g:1:88: T__24 | ||
| 1204 | { | ||
| 1205 | mT__24(); | ||
| 1206 | |||
| 1207 | } | ||
| 1208 | break; | ||
| 1209 | case 15 : | ||
| 1210 | // InternalSolverLanguage.g:1:94: T__25 | ||
| 1211 | { | ||
| 1212 | mT__25(); | ||
| 1213 | |||
| 1214 | } | ||
| 1215 | break; | ||
| 1216 | case 16 : | ||
| 1217 | // InternalSolverLanguage.g:1:100: T__26 | ||
| 1218 | { | ||
| 1219 | mT__26(); | ||
| 1220 | |||
| 1221 | } | ||
| 1222 | break; | ||
| 1223 | case 17 : | ||
| 1224 | // InternalSolverLanguage.g:1:106: T__27 | ||
| 1225 | { | ||
| 1226 | mT__27(); | ||
| 1227 | |||
| 1228 | } | ||
| 1229 | break; | ||
| 1230 | case 18 : | ||
| 1231 | // InternalSolverLanguage.g:1:112: T__28 | ||
| 1232 | { | ||
| 1233 | mT__28(); | ||
| 1234 | |||
| 1235 | } | ||
| 1236 | break; | ||
| 1237 | case 19 : | ||
| 1238 | // InternalSolverLanguage.g:1:118: T__29 | ||
| 1239 | { | ||
| 1240 | mT__29(); | ||
| 1241 | |||
| 1242 | } | ||
| 1243 | break; | ||
| 1244 | case 20 : | ||
| 1245 | // InternalSolverLanguage.g:1:124: T__30 | ||
| 1246 | { | ||
| 1247 | mT__30(); | ||
| 1248 | |||
| 1249 | } | ||
| 1250 | break; | ||
| 1251 | case 21 : | ||
| 1252 | // InternalSolverLanguage.g:1:130: T__31 | ||
| 1253 | { | ||
| 1254 | mT__31(); | ||
| 1255 | |||
| 1256 | } | ||
| 1257 | break; | ||
| 1258 | case 22 : | ||
| 1259 | // InternalSolverLanguage.g:1:136: T__32 | ||
| 1260 | { | ||
| 1261 | mT__32(); | ||
| 1262 | |||
| 1263 | } | ||
| 1264 | break; | ||
| 1265 | case 23 : | ||
| 1266 | // InternalSolverLanguage.g:1:142: T__33 | ||
| 1267 | { | ||
| 1268 | mT__33(); | ||
| 1269 | |||
| 1270 | } | ||
| 1271 | break; | ||
| 1272 | case 24 : | ||
| 1273 | // InternalSolverLanguage.g:1:148: T__34 | ||
| 1274 | { | ||
| 1275 | mT__34(); | ||
| 1276 | |||
| 1277 | } | ||
| 1278 | break; | ||
| 1279 | case 25 : | ||
| 1280 | // InternalSolverLanguage.g:1:154: T__35 | ||
| 1281 | { | ||
| 1282 | mT__35(); | ||
| 1283 | |||
| 1284 | } | ||
| 1285 | break; | ||
| 1286 | case 26 : | ||
| 1287 | // InternalSolverLanguage.g:1:160: T__36 | ||
| 1288 | { | ||
| 1289 | mT__36(); | ||
| 1290 | |||
| 1291 | } | ||
| 1292 | break; | ||
| 1293 | case 27 : | ||
| 1294 | // InternalSolverLanguage.g:1:166: T__37 | ||
| 1295 | { | ||
| 1296 | mT__37(); | ||
| 1297 | |||
| 1298 | } | ||
| 1299 | break; | ||
| 1300 | case 28 : | ||
| 1301 | // InternalSolverLanguage.g:1:172: T__38 | ||
| 1302 | { | ||
| 1303 | mT__38(); | ||
| 1304 | |||
| 1305 | } | ||
| 1306 | break; | ||
| 1307 | case 29 : | ||
| 1308 | // InternalSolverLanguage.g:1:178: T__39 | ||
| 1309 | { | ||
| 1310 | mT__39(); | ||
| 1311 | |||
| 1312 | } | ||
| 1313 | break; | ||
| 1314 | case 30 : | ||
| 1315 | // InternalSolverLanguage.g:1:184: T__40 | ||
| 1316 | { | ||
| 1317 | mT__40(); | ||
| 1318 | |||
| 1319 | } | ||
| 1320 | break; | ||
| 1321 | case 31 : | ||
| 1322 | // InternalSolverLanguage.g:1:190: RULE_STRING | ||
| 1323 | { | ||
| 1324 | mRULE_STRING(); | ||
| 1325 | |||
| 1326 | } | ||
| 1327 | break; | ||
| 1328 | case 32 : | ||
| 1329 | // InternalSolverLanguage.g:1:202: RULE_ID | ||
| 1330 | { | ||
| 1331 | mRULE_ID(); | ||
| 1332 | |||
| 1333 | } | ||
| 1334 | break; | ||
| 1335 | case 33 : | ||
| 1336 | // InternalSolverLanguage.g:1:210: RULE_INT | ||
| 1337 | { | ||
| 1338 | mRULE_INT(); | ||
| 1339 | |||
| 1340 | } | ||
| 1341 | break; | ||
| 1342 | case 34 : | ||
| 1343 | // InternalSolverLanguage.g:1:219: RULE_ML_COMMENT | ||
| 1344 | { | ||
| 1345 | mRULE_ML_COMMENT(); | ||
| 1346 | |||
| 1347 | } | ||
| 1348 | break; | ||
| 1349 | case 35 : | ||
| 1350 | // InternalSolverLanguage.g:1:235: RULE_SL_COMMENT | ||
| 1351 | { | ||
| 1352 | mRULE_SL_COMMENT(); | ||
| 1353 | |||
| 1354 | } | ||
| 1355 | break; | ||
| 1356 | case 36 : | ||
| 1357 | // InternalSolverLanguage.g:1:251: RULE_WS | ||
| 1358 | { | ||
| 1359 | mRULE_WS(); | ||
| 1360 | |||
| 1361 | } | ||
| 1362 | break; | ||
| 1363 | case 37 : | ||
| 1364 | // InternalSolverLanguage.g:1:259: RULE_ANY_OTHER | ||
| 1365 | { | ||
| 1366 | mRULE_ANY_OTHER(); | ||
| 1367 | |||
| 1368 | } | ||
| 1369 | break; | ||
| 1370 | |||
| 1371 | } | ||
| 1372 | |||
| 1373 | } | ||
| 1374 | |||
| 1375 | |||
| 1376 | protected DFA10 dfa10 = new DFA10(this); | ||
| 1377 | static final String DFA10_eotS = | ||
| 1378 | "\2\uffff\1\41\4\43\3\uffff\4\43\1\uffff\1\43\3\uffff\3\43\2\uffff\2\36\2\uffff\1\36\5\uffff\1\43\1\uffff\6\43\3\uffff\4\43\1\uffff\1\43\3\uffff\4\43\7\uffff\11\43\1\134\10\43\1\145\6\43\1\154\1\155\1\uffff\1\156\7\43\1\uffff\1\166\1\43\1\170\3\43\3\uffff\5\43\1\u0081\1\43\1\uffff\1\43\1\uffff\1\u0084\1\43\1\u0086\1\43\1\u0088\3\43\1\uffff\1\43\1\u008d\1\uffff\1\u008e\1\uffff\1\43\1\uffff\1\43\1\u0091\2\43\2\uffff\1\u0094\1\43\1\uffff\1\u0096\1\43\1\uffff\1\u0098\1\uffff\1\43\1\uffff\1\43\1\u009b\1\uffff"; | ||
| 1379 | static final String DFA10_eofS = | ||
| 1380 | "\u009c\uffff"; | ||
| 1381 | static final String DFA10_minS = | ||
| 1382 | "\1\0\1\uffff\1\56\1\162\1\141\2\156\3\uffff\1\157\1\156\1\145\1\164\1\uffff\1\162\3\uffff\1\145\1\142\1\154\2\uffff\1\0\1\101\2\uffff\1\52\5\uffff\1\165\1\uffff\1\154\1\153\1\162\1\151\2\165\3\uffff\1\157\1\164\1\141\1\162\1\uffff\1\145\3\uffff\1\146\1\163\1\141\1\156\7\uffff\1\145\1\163\1\156\1\157\1\163\1\145\1\141\1\155\1\154\1\60\1\154\1\141\1\151\1\144\1\141\1\164\1\163\1\164\1\60\1\145\1\157\1\162\1\164\1\156\1\154\2\60\1\uffff\1\60\1\164\1\156\1\151\1\165\1\162\1\163\1\141\1\uffff\1\60\1\167\1\60\1\163\1\144\1\163\3\uffff\1\151\1\147\1\143\1\154\1\141\1\60\1\151\1\uffff\1\156\1\uffff\1\60\1\163\1\60\1\157\1\60\1\141\1\164\1\143\1\uffff\1\156\1\60\1\uffff\1\60\1\uffff\1\156\1\uffff\1\164\1\60\1\164\1\155\2\uffff\1\60\1\145\1\uffff\1\60\1\145\1\uffff\1\60\1\uffff\1\156\1\uffff\1\164\1\60\1\uffff"; | ||
| 1383 | static final String DFA10_maxS = | ||
| 1384 | "\1\uffff\1\uffff\1\56\1\162\1\141\1\156\1\170\3\uffff\1\157\1\156\1\145\1\164\1\uffff\1\162\3\uffff\1\145\1\142\1\157\2\uffff\1\uffff\1\172\2\uffff\1\57\5\uffff\1\165\1\uffff\1\154\1\153\1\162\1\164\2\165\3\uffff\1\157\1\164\1\154\1\162\1\uffff\1\145\3\uffff\1\146\1\163\1\141\1\156\7\uffff\1\145\1\163\1\156\1\157\1\163\1\145\1\141\1\155\1\154\1\172\1\154\1\141\1\151\1\144\1\141\1\164\1\163\1\164\1\172\1\145\1\157\1\162\1\164\1\156\1\154\2\172\1\uffff\1\172\1\164\1\156\1\151\1\165\1\162\1\163\1\141\1\uffff\1\172\1\167\1\172\1\163\1\144\1\163\3\uffff\1\151\1\147\1\143\1\154\1\141\1\172\1\151\1\uffff\1\156\1\uffff\1\172\1\163\1\172\1\157\1\172\1\141\1\164\1\143\1\uffff\1\156\1\172\1\uffff\1\172\1\uffff\1\156\1\uffff\1\164\1\172\1\164\1\155\2\uffff\1\172\1\145\1\uffff\1\172\1\145\1\uffff\1\172\1\uffff\1\156\1\uffff\1\164\1\172\1\uffff"; | ||
| 1385 | static final String DFA10_acceptS = | ||
| 1386 | "\1\uffff\1\1\5\uffff\1\7\1\10\1\11\4\uffff\1\20\1\uffff\1\22\1\23\1\24\3\uffff\1\31\1\32\2\uffff\1\40\1\41\1\uffff\1\44\1\45\1\1\1\36\1\2\1\uffff\1\40\6\uffff\1\7\1\10\1\11\4\uffff\1\20\1\uffff\1\22\1\23\1\24\4\uffff\1\31\1\32\1\37\1\41\1\42\1\43\1\44\33\uffff\1\15\10\uffff\1\3\6\uffff\1\33\1\14\1\16\7\uffff\1\4\1\uffff\1\6\10\uffff\1\27\2\uffff\1\12\1\uffff\1\13\1\uffff\1\17\4\uffff\1\5\1\30\2\uffff\1\25\2\uffff\1\35\1\uffff\1\26\1\uffff\1\21\2\uffff\1\34"; | ||
| 1387 | static final String DFA10_specialS = | ||
| 1388 | "\1\1\27\uffff\1\0\u0083\uffff}>"; | ||
| 1389 | static final String[] DFA10_transitionS = { | ||
| 1390 | "\11\36\2\35\2\36\1\35\22\36\1\35\1\36\1\30\4\36\1\16\1\7\1\10\1\22\1\21\1\36\1\1\1\2\1\34\12\33\1\11\6\36\32\32\3\36\1\31\1\32\1\36\1\24\1\12\1\25\1\23\1\6\1\4\2\32\1\13\6\32\1\17\1\32\1\14\1\15\1\3\1\5\5\32\1\26\1\20\1\27\uff82\36", | ||
| 1391 | "", | ||
| 1392 | "\1\40", | ||
| 1393 | "\1\42", | ||
| 1394 | "\1\44", | ||
| 1395 | "\1\45", | ||
| 1396 | "\1\51\2\uffff\1\50\1\46\5\uffff\1\47", | ||
| 1397 | "", | ||
| 1398 | "", | ||
| 1399 | "", | ||
| 1400 | "\1\55", | ||
| 1401 | "\1\56", | ||
| 1402 | "\1\57", | ||
| 1403 | "\1\60", | ||
| 1404 | "", | ||
| 1405 | "\1\62", | ||
| 1406 | "", | ||
| 1407 | "", | ||
| 1408 | "", | ||
| 1409 | "\1\66", | ||
| 1410 | "\1\67", | ||
| 1411 | "\1\70\2\uffff\1\71", | ||
| 1412 | "", | ||
| 1413 | "", | ||
| 1414 | "\0\74", | ||
| 1415 | "\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1416 | "", | ||
| 1417 | "", | ||
| 1418 | "\1\76\4\uffff\1\77", | ||
| 1419 | "", | ||
| 1420 | "", | ||
| 1421 | "", | ||
| 1422 | "", | ||
| 1423 | "", | ||
| 1424 | "\1\101", | ||
| 1425 | "", | ||
| 1426 | "\1\102", | ||
| 1427 | "\1\103", | ||
| 1428 | "\1\104", | ||
| 1429 | "\1\105\12\uffff\1\106", | ||
| 1430 | "\1\107", | ||
| 1431 | "\1\110", | ||
| 1432 | "", | ||
| 1433 | "", | ||
| 1434 | "", | ||
| 1435 | "\1\111", | ||
| 1436 | "\1\112", | ||
| 1437 | "\1\113\12\uffff\1\114", | ||
| 1438 | "\1\115", | ||
| 1439 | "", | ||
| 1440 | "\1\116", | ||
| 1441 | "", | ||
| 1442 | "", | ||
| 1443 | "", | ||
| 1444 | "\1\117", | ||
| 1445 | "\1\120", | ||
| 1446 | "\1\121", | ||
| 1447 | "\1\122", | ||
| 1448 | "", | ||
| 1449 | "", | ||
| 1450 | "", | ||
| 1451 | "", | ||
| 1452 | "", | ||
| 1453 | "", | ||
| 1454 | "", | ||
| 1455 | "\1\123", | ||
| 1456 | "\1\124", | ||
| 1457 | "\1\125", | ||
| 1458 | "\1\126", | ||
| 1459 | "\1\127", | ||
| 1460 | "\1\130", | ||
| 1461 | "\1\131", | ||
| 1462 | "\1\132", | ||
| 1463 | "\1\133", | ||
| 1464 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1465 | "\1\135", | ||
| 1466 | "\1\136", | ||
| 1467 | "\1\137", | ||
| 1468 | "\1\140", | ||
| 1469 | "\1\141", | ||
| 1470 | "\1\142", | ||
| 1471 | "\1\143", | ||
| 1472 | "\1\144", | ||
| 1473 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1474 | "\1\146", | ||
| 1475 | "\1\147", | ||
| 1476 | "\1\150", | ||
| 1477 | "\1\151", | ||
| 1478 | "\1\152", | ||
| 1479 | "\1\153", | ||
| 1480 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1481 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1482 | "", | ||
| 1483 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1484 | "\1\157", | ||
| 1485 | "\1\160", | ||
| 1486 | "\1\161", | ||
| 1487 | "\1\162", | ||
| 1488 | "\1\163", | ||
| 1489 | "\1\164", | ||
| 1490 | "\1\165", | ||
| 1491 | "", | ||
| 1492 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1493 | "\1\167", | ||
| 1494 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1495 | "\1\171", | ||
| 1496 | "\1\172", | ||
| 1497 | "\1\173", | ||
| 1498 | "", | ||
| 1499 | "", | ||
| 1500 | "", | ||
| 1501 | "\1\174", | ||
| 1502 | "\1\175", | ||
| 1503 | "\1\176", | ||
| 1504 | "\1\177", | ||
| 1505 | "\1\u0080", | ||
| 1506 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1507 | "\1\u0082", | ||
| 1508 | "", | ||
| 1509 | "\1\u0083", | ||
| 1510 | "", | ||
| 1511 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1512 | "\1\u0085", | ||
| 1513 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1514 | "\1\u0087", | ||
| 1515 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1516 | "\1\u0089", | ||
| 1517 | "\1\u008a", | ||
| 1518 | "\1\u008b", | ||
| 1519 | "", | ||
| 1520 | "\1\u008c", | ||
| 1521 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1522 | "", | ||
| 1523 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1524 | "", | ||
| 1525 | "\1\u008f", | ||
| 1526 | "", | ||
| 1527 | "\1\u0090", | ||
| 1528 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1529 | "\1\u0092", | ||
| 1530 | "\1\u0093", | ||
| 1531 | "", | ||
| 1532 | "", | ||
| 1533 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1534 | "\1\u0095", | ||
| 1535 | "", | ||
| 1536 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1537 | "\1\u0097", | ||
| 1538 | "", | ||
| 1539 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1540 | "", | ||
| 1541 | "\1\u0099", | ||
| 1542 | "", | ||
| 1543 | "\1\u009a", | ||
| 1544 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1545 | "" | ||
| 1546 | }; | ||
| 1547 | |||
| 1548 | static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS); | ||
| 1549 | static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS); | ||
| 1550 | static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS); | ||
| 1551 | static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS); | ||
| 1552 | static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS); | ||
| 1553 | static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS); | ||
| 1554 | static final short[][] DFA10_transition; | ||
| 1555 | |||
| 1556 | static { | ||
| 1557 | int numStates = DFA10_transitionS.length; | ||
| 1558 | DFA10_transition = new short[numStates][]; | ||
| 1559 | for (int i=0; i<numStates; i++) { | ||
| 1560 | DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]); | ||
| 1561 | } | ||
| 1562 | } | ||
| 1563 | |||
| 1564 | class DFA10 extends DFA { | ||
| 1565 | |||
| 1566 | public DFA10(BaseRecognizer recognizer) { | ||
| 1567 | this.recognizer = recognizer; | ||
| 1568 | this.decisionNumber = 10; | ||
| 1569 | this.eot = DFA10_eot; | ||
| 1570 | this.eof = DFA10_eof; | ||
| 1571 | this.min = DFA10_min; | ||
| 1572 | this.max = DFA10_max; | ||
| 1573 | this.accept = DFA10_accept; | ||
| 1574 | this.special = DFA10_special; | ||
| 1575 | this.transition = DFA10_transition; | ||
| 1576 | } | ||
| 1577 | public String getDescription() { | ||
| 1578 | return "1:1: Tokens : ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | ||
| 1579 | } | ||
| 1580 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | ||
| 1581 | IntStream input = _input; | ||
| 1582 | int _s = s; | ||
| 1583 | switch ( s ) { | ||
| 1584 | case 0 : | ||
| 1585 | int LA10_24 = input.LA(1); | ||
| 1586 | |||
| 1587 | s = -1; | ||
| 1588 | if ( ((LA10_24>='\u0000' && LA10_24<='\uFFFF')) ) {s = 60;} | ||
| 1589 | |||
| 1590 | else s = 30; | ||
| 1591 | |||
| 1592 | if ( s>=0 ) return s; | ||
| 1593 | break; | ||
| 1594 | case 1 : | ||
| 1595 | int LA10_0 = input.LA(1); | ||
| 1596 | |||
| 1597 | s = -1; | ||
| 1598 | if ( (LA10_0=='-') ) {s = 1;} | ||
| 1599 | |||
| 1600 | else if ( (LA10_0=='.') ) {s = 2;} | ||
| 1601 | |||
| 1602 | else if ( (LA10_0=='t') ) {s = 3;} | ||
| 1603 | |||
| 1604 | else if ( (LA10_0=='f') ) {s = 4;} | ||
| 1605 | |||
| 1606 | else if ( (LA10_0=='u') ) {s = 5;} | ||
| 1607 | |||
| 1608 | else if ( (LA10_0=='e') ) {s = 6;} | ||
| 1609 | |||
| 1610 | else if ( (LA10_0=='(') ) {s = 7;} | ||
| 1611 | |||
| 1612 | else if ( (LA10_0==')') ) {s = 8;} | ||
| 1613 | |||
| 1614 | else if ( (LA10_0==':') ) {s = 9;} | ||
| 1615 | |||
| 1616 | else if ( (LA10_0=='b') ) {s = 10;} | ||
| 1617 | |||
| 1618 | else if ( (LA10_0=='i') ) {s = 11;} | ||
| 1619 | |||
| 1620 | else if ( (LA10_0=='r') ) {s = 12;} | ||
| 1621 | |||
| 1622 | else if ( (LA10_0=='s') ) {s = 13;} | ||
| 1623 | |||
| 1624 | else if ( (LA10_0=='\'') ) {s = 14;} | ||
| 1625 | |||
| 1626 | else if ( (LA10_0=='p') ) {s = 15;} | ||
| 1627 | |||
| 1628 | else if ( (LA10_0=='|') ) {s = 16;} | ||
| 1629 | |||
| 1630 | else if ( (LA10_0=='+') ) {s = 17;} | ||
| 1631 | |||
| 1632 | else if ( (LA10_0=='*') ) {s = 18;} | ||
| 1633 | |||
| 1634 | else if ( (LA10_0=='d') ) {s = 19;} | ||
| 1635 | |||
| 1636 | else if ( (LA10_0=='a') ) {s = 20;} | ||
| 1637 | |||
| 1638 | else if ( (LA10_0=='c') ) {s = 21;} | ||
| 1639 | |||
| 1640 | else if ( (LA10_0=='{') ) {s = 22;} | ||
| 1641 | |||
| 1642 | else if ( (LA10_0=='}') ) {s = 23;} | ||
| 1643 | |||
| 1644 | else if ( (LA10_0=='\"') ) {s = 24;} | ||
| 1645 | |||
| 1646 | else if ( (LA10_0=='^') ) {s = 25;} | ||
| 1647 | |||
| 1648 | else if ( ((LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='g' && LA10_0<='h')||(LA10_0>='j' && LA10_0<='o')||LA10_0=='q'||(LA10_0>='v' && LA10_0<='z')) ) {s = 26;} | ||
| 1649 | |||
| 1650 | else if ( ((LA10_0>='0' && LA10_0<='9')) ) {s = 27;} | ||
| 1651 | |||
| 1652 | else if ( (LA10_0=='/') ) {s = 28;} | ||
| 1653 | |||
| 1654 | else if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {s = 29;} | ||
| 1655 | |||
| 1656 | else if ( ((LA10_0>='\u0000' && LA10_0<='\b')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\u001F')||LA10_0=='!'||(LA10_0>='#' && LA10_0<='&')||LA10_0==','||(LA10_0>=';' && LA10_0<='@')||(LA10_0>='[' && LA10_0<=']')||LA10_0=='`'||(LA10_0>='~' && LA10_0<='\uFFFF')) ) {s = 30;} | ||
| 1657 | |||
| 1658 | if ( s>=0 ) return s; | ||
| 1659 | break; | ||
| 1660 | } | ||
| 1661 | NoViableAltException nvae = | ||
| 1662 | new NoViableAltException(getDescription(), 10, _s, input); | ||
| 1663 | error(nvae); | ||
| 1664 | throw nvae; | ||
| 1665 | } | ||
| 1666 | } | ||
| 1667 | |||
| 1668 | |||
| 1669 | } \ No newline at end of file | ||
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 @@ | |||
| 1 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
| 2 | |||
| 3 | import org.eclipse.xtext.*; | ||
| 4 | import org.eclipse.xtext.parser.*; | ||
| 5 | import org.eclipse.xtext.parser.impl.*; | ||
| 6 | import org.eclipse.emf.ecore.util.EcoreUtil; | ||
| 7 | import org.eclipse.emf.ecore.EObject; | ||
| 8 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; | ||
| 9 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
| 10 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | ||
| 11 | import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; | ||
| 12 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
| 13 | |||
| 14 | |||
| 15 | |||
| 16 | import org.antlr.runtime.*; | ||
| 17 | import java.util.Stack; | ||
| 18 | import java.util.List; | ||
| 19 | import java.util.ArrayList; | ||
| 20 | |||
| 21 | @SuppressWarnings("all") | ||
| 22 | public 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 | ||