diff options
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal')
4 files changed, 12445 insertions, 5490 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g index 501e2e59..3fac9254 100644 --- 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 | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | grammar InternalSolverLanguage; | 4 | grammar InternalSolverLanguage; |
| 5 | 5 | ||
| @@ -23,6 +23,7 @@ import org.eclipse.xtext.parser.*; | |||
| 23 | import org.eclipse.xtext.parser.impl.*; | 23 | import org.eclipse.xtext.parser.impl.*; |
| 24 | import org.eclipse.emf.ecore.util.EcoreUtil; | 24 | import org.eclipse.emf.ecore.util.EcoreUtil; |
| 25 | import org.eclipse.emf.ecore.EObject; | 25 | import org.eclipse.emf.ecore.EObject; |
| 26 | import org.eclipse.emf.common.util.Enumerator; | ||
| 26 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; | 27 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; |
| 27 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | 28 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; |
| 28 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | 29 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; |
| @@ -112,35 +113,242 @@ ruleStatement returns [EObject current=null] | |||
| 112 | leaveRule(); | 113 | leaveRule(); |
| 113 | }: | 114 | }: |
| 114 | ( | 115 | ( |
| 116 | ( | ||
| 117 | { | ||
| 118 | newCompositeNode(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); | ||
| 119 | } | ||
| 120 | this_AssertionOrDefinition_0=ruleAssertionOrDefinition | ||
| 121 | { | ||
| 122 | $current = $this_AssertionOrDefinition_0.current; | ||
| 123 | afterParserOrEnumRuleCall(); | ||
| 124 | } | ||
| 125 | | | ||
| 126 | { | ||
| 127 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); | ||
| 128 | } | ||
| 129 | this_PredicateDefinition_1=rulePredicateDefinition | ||
| 130 | { | ||
| 131 | $current = $this_PredicateDefinition_1.current; | ||
| 132 | afterParserOrEnumRuleCall(); | ||
| 133 | } | ||
| 134 | | | ||
| 135 | { | ||
| 136 | newCompositeNode(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); | ||
| 137 | } | ||
| 138 | this_UnnamedErrorPrediateDefinition_2=ruleUnnamedErrorPrediateDefinition | ||
| 139 | { | ||
| 140 | $current = $this_UnnamedErrorPrediateDefinition_2.current; | ||
| 141 | afterParserOrEnumRuleCall(); | ||
| 142 | } | ||
| 143 | | | ||
| 144 | { | ||
| 145 | newCompositeNode(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); | ||
| 146 | } | ||
| 147 | this_DefaultDefinition_3=ruleDefaultDefinition | ||
| 148 | { | ||
| 149 | $current = $this_DefaultDefinition_3.current; | ||
| 150 | afterParserOrEnumRuleCall(); | ||
| 151 | } | ||
| 152 | | | ||
| 153 | { | ||
| 154 | newCompositeNode(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); | ||
| 155 | } | ||
| 156 | this_ExternPredicateDefinition_4=ruleExternPredicateDefinition | ||
| 157 | { | ||
| 158 | $current = $this_ExternPredicateDefinition_4.current; | ||
| 159 | afterParserOrEnumRuleCall(); | ||
| 160 | } | ||
| 161 | | | ||
| 162 | { | ||
| 163 | newCompositeNode(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); | ||
| 164 | } | ||
| 165 | this_MetricDefinition_5=ruleMetricDefinition | ||
| 166 | { | ||
| 167 | $current = $this_MetricDefinition_5.current; | ||
| 168 | afterParserOrEnumRuleCall(); | ||
| 169 | } | ||
| 170 | | | ||
| 171 | { | ||
| 172 | newCompositeNode(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); | ||
| 173 | } | ||
| 174 | this_ExternMetricDefinition_6=ruleExternMetricDefinition | ||
| 175 | { | ||
| 176 | $current = $this_ExternMetricDefinition_6.current; | ||
| 177 | afterParserOrEnumRuleCall(); | ||
| 178 | } | ||
| 179 | | | ||
| 180 | { | ||
| 181 | newCompositeNode(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); | ||
| 182 | } | ||
| 183 | this_ClassDefinition_7=ruleClassDefinition | ||
| 184 | { | ||
| 185 | $current = $this_ClassDefinition_7.current; | ||
| 186 | afterParserOrEnumRuleCall(); | ||
| 187 | } | ||
| 188 | | | ||
| 189 | { | ||
| 190 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); | ||
| 191 | } | ||
| 192 | this_ScopeDefinition_8=ruleScopeDefinition | ||
| 193 | { | ||
| 194 | $current = $this_ScopeDefinition_8.current; | ||
| 195 | afterParserOrEnumRuleCall(); | ||
| 196 | } | ||
| 197 | | | ||
| 198 | { | ||
| 199 | newCompositeNode(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); | ||
| 200 | } | ||
| 201 | this_ObjectiveDefinition_9=ruleObjectiveDefinition | ||
| 202 | { | ||
| 203 | $current = $this_ObjectiveDefinition_9.current; | ||
| 204 | afterParserOrEnumRuleCall(); | ||
| 205 | } | ||
| 206 | ) | ||
| 207 | this_DOT_10=RULE_DOT | ||
| 115 | { | 208 | { |
| 116 | newCompositeNode(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); | 209 | newLeafNode(this_DOT_10, grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1()); |
| 117 | } | ||
| 118 | this_Interpretation_0=ruleInterpretation | ||
| 119 | { | ||
| 120 | $current = $this_Interpretation_0.current; | ||
| 121 | afterParserOrEnumRuleCall(); | ||
| 122 | } | 210 | } |
| 123 | | | 211 | ) |
| 212 | ; | ||
| 213 | |||
| 214 | // Entry rule entryRuleAssertionOrDefinition | ||
| 215 | entryRuleAssertionOrDefinition returns [EObject current=null]: | ||
| 216 | { newCompositeNode(grammarAccess.getAssertionOrDefinitionRule()); } | ||
| 217 | iv_ruleAssertionOrDefinition=ruleAssertionOrDefinition | ||
| 218 | { $current=$iv_ruleAssertionOrDefinition.current; } | ||
| 219 | EOF; | ||
| 220 | |||
| 221 | // Rule AssertionOrDefinition | ||
| 222 | ruleAssertionOrDefinition returns [EObject current=null] | ||
| 223 | @init { | ||
| 224 | enterRule(); | ||
| 225 | } | ||
| 226 | @after { | ||
| 227 | leaveRule(); | ||
| 228 | }: | ||
| 229 | ( | ||
| 124 | { | 230 | { |
| 125 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); | 231 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); |
| 126 | } | 232 | } |
| 127 | this_Predicate_1=rulePredicate | 233 | this_Expression_0=ruleExpression |
| 128 | { | 234 | { |
| 129 | $current = $this_Predicate_1.current; | 235 | $current = $this_Expression_0.current; |
| 130 | afterParserOrEnumRuleCall(); | 236 | afterParserOrEnumRuleCall(); |
| 131 | } | 237 | } |
| 238 | ( | ||
| 239 | ( | ||
| 240 | ( | ||
| 241 | { | ||
| 242 | $current = forceCreateModelElementAndSet( | ||
| 243 | grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0(), | ||
| 244 | $current); | ||
| 245 | } | ||
| 246 | ) | ||
| 247 | ( | ||
| 248 | otherlv_2=':' | ||
| 249 | { | ||
| 250 | newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); | ||
| 251 | } | ||
| 252 | ( | ||
| 253 | ( | ||
| 254 | { | ||
| 255 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); | ||
| 256 | } | ||
| 257 | lv_range_3_0=ruleExpression | ||
| 258 | { | ||
| 259 | if ($current==null) { | ||
| 260 | $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 261 | } | ||
| 262 | set( | ||
| 263 | $current, | ||
| 264 | "range", | ||
| 265 | lv_range_3_0, | ||
| 266 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 267 | afterParserOrEnumRuleCall(); | ||
| 268 | } | ||
| 269 | ) | ||
| 270 | ) | ||
| 271 | )? | ||
| 272 | ) | ||
| 273 | | | ||
| 274 | ( | ||
| 275 | ( | ||
| 276 | { | ||
| 277 | $current = forceCreateModelElementAndSet( | ||
| 278 | grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), | ||
| 279 | $current); | ||
| 280 | } | ||
| 281 | ) | ||
| 282 | otherlv_5=':-' | ||
| 283 | { | ||
| 284 | newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); | ||
| 285 | } | ||
| 286 | ( | ||
| 287 | ( | ||
| 288 | { | ||
| 289 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); | ||
| 290 | } | ||
| 291 | lv_body_6_0=ruleExpression | ||
| 292 | { | ||
| 293 | if ($current==null) { | ||
| 294 | $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 295 | } | ||
| 296 | set( | ||
| 297 | $current, | ||
| 298 | "body", | ||
| 299 | lv_body_6_0, | ||
| 300 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 301 | afterParserOrEnumRuleCall(); | ||
| 302 | } | ||
| 303 | ) | ||
| 304 | ) | ||
| 305 | ) | ||
| 306 | | | ||
| 307 | ( | ||
| 308 | ( | ||
| 309 | { | ||
| 310 | $current = forceCreateModelElementAndSet( | ||
| 311 | grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(), | ||
| 312 | $current); | ||
| 313 | } | ||
| 314 | ) | ||
| 315 | otherlv_8='=' | ||
| 316 | { | ||
| 317 | newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); | ||
| 318 | } | ||
| 319 | ( | ||
| 320 | ( | ||
| 321 | { | ||
| 322 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); | ||
| 323 | } | ||
| 324 | lv_body_9_0=ruleExpression | ||
| 325 | { | ||
| 326 | if ($current==null) { | ||
| 327 | $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 328 | } | ||
| 329 | set( | ||
| 330 | $current, | ||
| 331 | "body", | ||
| 332 | lv_body_9_0, | ||
| 333 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 334 | afterParserOrEnumRuleCall(); | ||
| 335 | } | ||
| 336 | ) | ||
| 337 | ) | ||
| 338 | ) | ||
| 339 | ) | ||
| 132 | ) | 340 | ) |
| 133 | ; | 341 | ; |
| 134 | 342 | ||
| 135 | // Entry rule entryRuleREALLiteral | 343 | // Entry rule entryRulePredicateDefinition |
| 136 | entryRuleREALLiteral returns [String current=null]: | 344 | entryRulePredicateDefinition returns [EObject current=null]: |
| 137 | { newCompositeNode(grammarAccess.getREALLiteralRule()); } | 345 | { newCompositeNode(grammarAccess.getPredicateDefinitionRule()); } |
| 138 | iv_ruleREALLiteral=ruleREALLiteral | 346 | iv_rulePredicateDefinition=rulePredicateDefinition |
| 139 | { $current=$iv_ruleREALLiteral.current.getText(); } | 347 | { $current=$iv_rulePredicateDefinition.current; } |
| 140 | EOF; | 348 | EOF; |
| 141 | 349 | ||
| 142 | // Rule REALLiteral | 350 | // Rule PredicateDefinition |
| 143 | ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | 351 | rulePredicateDefinition returns [EObject current=null] |
| 144 | @init { | 352 | @init { |
| 145 | enterRule(); | 353 | enterRule(); |
| 146 | } | 354 | } |
| @@ -149,43 +357,122 @@ ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleTok | |||
| 149 | }: | 357 | }: |
| 150 | ( | 358 | ( |
| 151 | ( | 359 | ( |
| 152 | kw='-' | 360 | ( |
| 153 | { | 361 | ( |
| 154 | $current.merge(kw); | 362 | ( |
| 155 | newLeafNode(kw, grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); | 363 | lv_functional_0_0='functional' |
| 156 | } | 364 | { |
| 157 | )? | 365 | newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); |
| 158 | this_INT_1=RULE_INT | 366 | } |
| 159 | { | 367 | { |
| 160 | $current.merge(this_INT_1); | 368 | if ($current==null) { |
| 161 | } | 369 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); |
| 162 | { | 370 | } |
| 163 | newLeafNode(this_INT_1, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); | 371 | setWithLastConsumed($current, "functional", true, "functional"); |
| 164 | } | 372 | } |
| 165 | kw='.' | 373 | ) |
| 166 | { | 374 | ) |
| 167 | $current.merge(kw); | 375 | ( |
| 168 | newLeafNode(kw, grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); | 376 | ( |
| 169 | } | 377 | lv_error_1_0='error' |
| 170 | this_INT_3=RULE_INT | 378 | { |
| 171 | { | 379 | newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); |
| 172 | $current.merge(this_INT_3); | 380 | } |
| 173 | } | 381 | { |
| 382 | if ($current==null) { | ||
| 383 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 384 | } | ||
| 385 | setWithLastConsumed($current, "error", true, "error"); | ||
| 386 | } | ||
| 387 | ) | ||
| 388 | )? | ||
| 389 | ) | ||
| 390 | | | ||
| 391 | ( | ||
| 392 | ( | ||
| 393 | ( | ||
| 394 | lv_error_2_0='error' | ||
| 395 | { | ||
| 396 | newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); | ||
| 397 | } | ||
| 398 | { | ||
| 399 | if ($current==null) { | ||
| 400 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 401 | } | ||
| 402 | setWithLastConsumed($current, "error", true, "error"); | ||
| 403 | } | ||
| 404 | ) | ||
| 405 | ) | ||
| 406 | ( | ||
| 407 | ( | ||
| 408 | lv_functional_3_0='functional' | ||
| 409 | { | ||
| 410 | newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); | ||
| 411 | } | ||
| 412 | { | ||
| 413 | if ($current==null) { | ||
| 414 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 415 | } | ||
| 416 | setWithLastConsumed($current, "functional", true, "functional"); | ||
| 417 | } | ||
| 418 | ) | ||
| 419 | )? | ||
| 420 | ) | ||
| 421 | ) | ||
| 422 | ( | ||
| 423 | ( | ||
| 424 | { | ||
| 425 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
| 426 | } | ||
| 427 | lv_head_4_0=ruleCall | ||
| 428 | { | ||
| 429 | if ($current==null) { | ||
| 430 | $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
| 431 | } | ||
| 432 | set( | ||
| 433 | $current, | ||
| 434 | "head", | ||
| 435 | lv_head_4_0, | ||
| 436 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 437 | afterParserOrEnumRuleCall(); | ||
| 438 | } | ||
| 439 | ) | ||
| 440 | ) | ||
| 441 | otherlv_5=':-' | ||
| 174 | { | 442 | { |
| 175 | newLeafNode(this_INT_3, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); | 443 | newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); |
| 176 | } | 444 | } |
| 445 | ( | ||
| 446 | ( | ||
| 447 | { | ||
| 448 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
| 449 | } | ||
| 450 | lv_body_6_0=ruleExpression | ||
| 451 | { | ||
| 452 | if ($current==null) { | ||
| 453 | $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
| 454 | } | ||
| 455 | set( | ||
| 456 | $current, | ||
| 457 | "body", | ||
| 458 | lv_body_6_0, | ||
| 459 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 460 | afterParserOrEnumRuleCall(); | ||
| 461 | } | ||
| 462 | ) | ||
| 463 | ) | ||
| 177 | ) | 464 | ) |
| 178 | ; | 465 | ; |
| 179 | 466 | ||
| 180 | // Entry rule entryRuleINTLiteral | 467 | // Entry rule entryRuleUnnamedErrorPrediateDefinition |
| 181 | entryRuleINTLiteral returns [String current=null]: | 468 | entryRuleUnnamedErrorPrediateDefinition returns [EObject current=null]: |
| 182 | { newCompositeNode(grammarAccess.getINTLiteralRule()); } | 469 | { newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); } |
| 183 | iv_ruleINTLiteral=ruleINTLiteral | 470 | iv_ruleUnnamedErrorPrediateDefinition=ruleUnnamedErrorPrediateDefinition |
| 184 | { $current=$iv_ruleINTLiteral.current.getText(); } | 471 | { $current=$iv_ruleUnnamedErrorPrediateDefinition.current; } |
| 185 | EOF; | 472 | EOF; |
| 186 | 473 | ||
| 187 | // Rule INTLiteral | 474 | // Rule UnnamedErrorPrediateDefinition |
| 188 | ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | 475 | ruleUnnamedErrorPrediateDefinition returns [EObject current=null] |
| 189 | @init { | 476 | @init { |
| 190 | enterRule(); | 477 | enterRule(); |
| 191 | } | 478 | } |
| @@ -193,32 +480,64 @@ ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToke | |||
| 193 | leaveRule(); | 480 | leaveRule(); |
| 194 | }: | 481 | }: |
| 195 | ( | 482 | ( |
| 196 | ( | 483 | otherlv_0='error' |
| 197 | kw='-' | ||
| 198 | { | ||
| 199 | $current.merge(kw); | ||
| 200 | newLeafNode(kw, grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); | ||
| 201 | } | ||
| 202 | )? | ||
| 203 | this_INT_1=RULE_INT | ||
| 204 | { | 484 | { |
| 205 | $current.merge(this_INT_1); | 485 | newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); |
| 206 | } | 486 | } |
| 487 | ( | ||
| 488 | ( | ||
| 489 | { | ||
| 490 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); | ||
| 491 | } | ||
| 492 | lv_argumentList_1_0=ruleArgumentList | ||
| 493 | { | ||
| 494 | if ($current==null) { | ||
| 495 | $current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | ||
| 496 | } | ||
| 497 | set( | ||
| 498 | $current, | ||
| 499 | "argumentList", | ||
| 500 | lv_argumentList_1_0, | ||
| 501 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
| 502 | afterParserOrEnumRuleCall(); | ||
| 503 | } | ||
| 504 | ) | ||
| 505 | ) | ||
| 506 | otherlv_2=':-' | ||
| 207 | { | 507 | { |
| 208 | newLeafNode(this_INT_1, grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); | 508 | newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); |
| 209 | } | 509 | } |
| 510 | ( | ||
| 511 | ( | ||
| 512 | { | ||
| 513 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
| 514 | } | ||
| 515 | lv_body_3_0=ruleExpression | ||
| 516 | { | ||
| 517 | if ($current==null) { | ||
| 518 | $current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | ||
| 519 | } | ||
| 520 | set( | ||
| 521 | $current, | ||
| 522 | "body", | ||
| 523 | lv_body_3_0, | ||
| 524 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 525 | afterParserOrEnumRuleCall(); | ||
| 526 | } | ||
| 527 | ) | ||
| 528 | ) | ||
| 210 | ) | 529 | ) |
| 211 | ; | 530 | ; |
| 212 | 531 | ||
| 213 | // Entry rule entryRuleBooleanValue | 532 | // Entry rule entryRuleDefaultDefinition |
| 214 | entryRuleBooleanValue returns [EObject current=null]: | 533 | entryRuleDefaultDefinition returns [EObject current=null]: |
| 215 | { newCompositeNode(grammarAccess.getBooleanValueRule()); } | 534 | { newCompositeNode(grammarAccess.getDefaultDefinitionRule()); } |
| 216 | iv_ruleBooleanValue=ruleBooleanValue | 535 | iv_ruleDefaultDefinition=ruleDefaultDefinition |
| 217 | { $current=$iv_ruleBooleanValue.current; } | 536 | { $current=$iv_ruleDefaultDefinition.current; } |
| 218 | EOF; | 537 | EOF; |
| 219 | 538 | ||
| 220 | // Rule BooleanValue | 539 | // Rule DefaultDefinition |
| 221 | ruleBooleanValue returns [EObject current=null] | 540 | ruleDefaultDefinition returns [EObject current=null] |
| 222 | @init { | 541 | @init { |
| 223 | enterRule(); | 542 | enterRule(); |
| 224 | } | 543 | } |
| @@ -226,45 +545,64 @@ ruleBooleanValue returns [EObject current=null] | |||
| 226 | leaveRule(); | 545 | leaveRule(); |
| 227 | }: | 546 | }: |
| 228 | ( | 547 | ( |
| 548 | otherlv_0='default' | ||
| 549 | { | ||
| 550 | newLeafNode(otherlv_0, grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); | ||
| 551 | } | ||
| 229 | ( | 552 | ( |
| 230 | ( | 553 | ( |
| 231 | { | 554 | { |
| 232 | $current = forceCreateModelElement( | 555 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
| 233 | grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0(), | 556 | } |
| 234 | $current); | 557 | lv_head_1_0=ruleCall |
| 558 | { | ||
| 559 | if ($current==null) { | ||
| 560 | $current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); | ||
| 561 | } | ||
| 562 | set( | ||
| 563 | $current, | ||
| 564 | "head", | ||
| 565 | lv_head_1_0, | ||
| 566 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 567 | afterParserOrEnumRuleCall(); | ||
| 235 | } | 568 | } |
| 236 | ) | 569 | ) |
| 237 | otherlv_1='true' | ||
| 238 | { | ||
| 239 | newLeafNode(otherlv_1, grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); | ||
| 240 | } | ||
| 241 | ) | 570 | ) |
| 242 | | | 571 | otherlv_2=':' |
| 572 | { | ||
| 573 | newLeafNode(otherlv_2, grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); | ||
| 574 | } | ||
| 243 | ( | 575 | ( |
| 244 | otherlv_2='false' | ||
| 245 | { | ||
| 246 | newLeafNode(otherlv_2, grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); | ||
| 247 | } | ||
| 248 | ( | 576 | ( |
| 249 | { | 577 | { |
| 250 | $current = forceCreateModelElement( | 578 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); |
| 251 | grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1(), | 579 | } |
| 252 | $current); | 580 | lv_range_3_0=ruleExpression |
| 581 | { | ||
| 582 | if ($current==null) { | ||
| 583 | $current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); | ||
| 584 | } | ||
| 585 | set( | ||
| 586 | $current, | ||
| 587 | "range", | ||
| 588 | lv_range_3_0, | ||
| 589 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 590 | afterParserOrEnumRuleCall(); | ||
| 253 | } | 591 | } |
| 254 | ) | 592 | ) |
| 255 | ) | 593 | ) |
| 256 | ) | 594 | ) |
| 257 | ; | 595 | ; |
| 258 | 596 | ||
| 259 | // Entry rule entryRuleTruthValue | 597 | // Entry rule entryRuleExternPredicateDefinition |
| 260 | entryRuleTruthValue returns [EObject current=null]: | 598 | entryRuleExternPredicateDefinition returns [EObject current=null]: |
| 261 | { newCompositeNode(grammarAccess.getTruthValueRule()); } | 599 | { newCompositeNode(grammarAccess.getExternPredicateDefinitionRule()); } |
| 262 | iv_ruleTruthValue=ruleTruthValue | 600 | iv_ruleExternPredicateDefinition=ruleExternPredicateDefinition |
| 263 | { $current=$iv_ruleTruthValue.current; } | 601 | { $current=$iv_ruleExternPredicateDefinition.current; } |
| 264 | EOF; | 602 | EOF; |
| 265 | 603 | ||
| 266 | // Rule TruthValue | 604 | // Rule ExternPredicateDefinition |
| 267 | ruleTruthValue returns [EObject current=null] | 605 | ruleExternPredicateDefinition returns [EObject current=null] |
| 268 | @init { | 606 | @init { |
| 269 | enterRule(); | 607 | enterRule(); |
| 270 | } | 608 | } |
| @@ -272,73 +610,125 @@ ruleTruthValue returns [EObject current=null] | |||
| 272 | leaveRule(); | 610 | leaveRule(); |
| 273 | }: | 611 | }: |
| 274 | ( | 612 | ( |
| 613 | otherlv_0='extern' | ||
| 614 | { | ||
| 615 | newLeafNode(otherlv_0, grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); | ||
| 616 | } | ||
| 275 | ( | 617 | ( |
| 276 | ( | 618 | ( |
| 277 | { | 619 | { |
| 278 | $current = forceCreateModelElement( | 620 | newCompositeNode(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
| 279 | grammarAccess.getTruthValueAccess().getTrueAction_0_0(), | 621 | } |
| 280 | $current); | 622 | lv_head_1_0=ruleCall |
| 623 | { | ||
| 624 | if ($current==null) { | ||
| 625 | $current = createModelElementForParent(grammarAccess.getExternPredicateDefinitionRule()); | ||
| 626 | } | ||
| 627 | set( | ||
| 628 | $current, | ||
| 629 | "head", | ||
| 630 | lv_head_1_0, | ||
| 631 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 632 | afterParserOrEnumRuleCall(); | ||
| 281 | } | 633 | } |
| 282 | ) | 634 | ) |
| 283 | otherlv_1='true' | ||
| 284 | { | ||
| 285 | newLeafNode(otherlv_1, grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); | ||
| 286 | } | ||
| 287 | ) | 635 | ) |
| 288 | | | 636 | otherlv_2='.' |
| 637 | { | ||
| 638 | newLeafNode(otherlv_2, grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2()); | ||
| 639 | } | ||
| 640 | ) | ||
| 641 | ; | ||
| 642 | |||
| 643 | // Entry rule entryRuleMetricDefinition | ||
| 644 | entryRuleMetricDefinition returns [EObject current=null]: | ||
| 645 | { newCompositeNode(grammarAccess.getMetricDefinitionRule()); } | ||
| 646 | iv_ruleMetricDefinition=ruleMetricDefinition | ||
| 647 | { $current=$iv_ruleMetricDefinition.current; } | ||
| 648 | EOF; | ||
| 649 | |||
| 650 | // Rule MetricDefinition | ||
| 651 | ruleMetricDefinition returns [EObject current=null] | ||
| 652 | @init { | ||
| 653 | enterRule(); | ||
| 654 | } | ||
| 655 | @after { | ||
| 656 | leaveRule(); | ||
| 657 | }: | ||
| 658 | ( | ||
| 289 | ( | 659 | ( |
| 290 | ( | 660 | ( |
| 291 | { | 661 | { |
| 292 | $current = forceCreateModelElement( | 662 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); |
| 293 | grammarAccess.getTruthValueAccess().getFalseAction_1_0(), | 663 | } |
| 294 | $current); | 664 | lv_type_0_0=ruleMetricType |
| 665 | { | ||
| 666 | if ($current==null) { | ||
| 667 | $current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | ||
| 668 | } | ||
| 669 | set( | ||
| 670 | $current, | ||
| 671 | "type", | ||
| 672 | lv_type_0_0, | ||
| 673 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | ||
| 674 | afterParserOrEnumRuleCall(); | ||
| 295 | } | 675 | } |
| 296 | ) | 676 | ) |
| 297 | otherlv_3='false' | ||
| 298 | { | ||
| 299 | newLeafNode(otherlv_3, grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); | ||
| 300 | } | ||
| 301 | ) | 677 | ) |
| 302 | | | ||
| 303 | ( | 678 | ( |
| 304 | ( | 679 | ( |
| 305 | { | 680 | { |
| 306 | $current = forceCreateModelElement( | 681 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); |
| 307 | grammarAccess.getTruthValueAccess().getUnknownAction_2_0(), | 682 | } |
| 308 | $current); | 683 | lv_head_1_0=ruleExpression |
| 684 | { | ||
| 685 | if ($current==null) { | ||
| 686 | $current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | ||
| 687 | } | ||
| 688 | set( | ||
| 689 | $current, | ||
| 690 | "head", | ||
| 691 | lv_head_1_0, | ||
| 692 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 693 | afterParserOrEnumRuleCall(); | ||
| 309 | } | 694 | } |
| 310 | ) | 695 | ) |
| 311 | otherlv_5='unknown' | ||
| 312 | { | ||
| 313 | newLeafNode(otherlv_5, grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); | ||
| 314 | } | ||
| 315 | ) | 696 | ) |
| 316 | | | 697 | otherlv_2='=' |
| 698 | { | ||
| 699 | newLeafNode(otherlv_2, grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); | ||
| 700 | } | ||
| 317 | ( | 701 | ( |
| 318 | ( | 702 | ( |
| 319 | { | 703 | { |
| 320 | $current = forceCreateModelElement( | 704 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
| 321 | grammarAccess.getTruthValueAccess().getErrorAction_3_0(), | 705 | } |
| 322 | $current); | 706 | lv_body_3_0=ruleExpression |
| 707 | { | ||
| 708 | if ($current==null) { | ||
| 709 | $current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | ||
| 710 | } | ||
| 711 | set( | ||
| 712 | $current, | ||
| 713 | "body", | ||
| 714 | lv_body_3_0, | ||
| 715 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 716 | afterParserOrEnumRuleCall(); | ||
| 323 | } | 717 | } |
| 324 | ) | 718 | ) |
| 325 | otherlv_7='error' | ||
| 326 | { | ||
| 327 | newLeafNode(otherlv_7, grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); | ||
| 328 | } | ||
| 329 | ) | 719 | ) |
| 330 | ) | 720 | ) |
| 331 | ; | 721 | ; |
| 332 | 722 | ||
| 333 | // Entry rule entryRuleInterpretation | 723 | // Entry rule entryRuleExternMetricDefinition |
| 334 | entryRuleInterpretation returns [EObject current=null]: | 724 | entryRuleExternMetricDefinition returns [EObject current=null]: |
| 335 | { newCompositeNode(grammarAccess.getInterpretationRule()); } | 725 | { newCompositeNode(grammarAccess.getExternMetricDefinitionRule()); } |
| 336 | iv_ruleInterpretation=ruleInterpretation | 726 | iv_ruleExternMetricDefinition=ruleExternMetricDefinition |
| 337 | { $current=$iv_ruleInterpretation.current; } | 727 | { $current=$iv_ruleExternMetricDefinition.current; } |
| 338 | EOF; | 728 | EOF; |
| 339 | 729 | ||
| 340 | // Rule Interpretation | 730 | // Rule ExternMetricDefinition |
| 341 | ruleInterpretation returns [EObject current=null] | 731 | ruleExternMetricDefinition returns [EObject current=null] |
| 342 | @init { | 732 | @init { |
| 343 | enterRule(); | 733 | enterRule(); |
| 344 | } | 734 | } |
| @@ -346,44 +736,96 @@ ruleInterpretation returns [EObject current=null] | |||
| 346 | leaveRule(); | 736 | leaveRule(); |
| 347 | }: | 737 | }: |
| 348 | ( | 738 | ( |
| 739 | otherlv_0='extern' | ||
| 349 | { | 740 | { |
| 350 | newCompositeNode(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); | 741 | newLeafNode(otherlv_0, grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); |
| 351 | } | ||
| 352 | this_BasicInterpretation_0=ruleBasicInterpretation | ||
| 353 | { | ||
| 354 | $current = $this_BasicInterpretation_0.current; | ||
| 355 | afterParserOrEnumRuleCall(); | ||
| 356 | } | 742 | } |
| 357 | | | 743 | ( |
| 744 | ( | ||
| 745 | { | ||
| 746 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); | ||
| 747 | } | ||
| 748 | lv_type_1_0=ruleMetricType | ||
| 749 | { | ||
| 750 | if ($current==null) { | ||
| 751 | $current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); | ||
| 752 | } | ||
| 753 | set( | ||
| 754 | $current, | ||
| 755 | "type", | ||
| 756 | lv_type_1_0, | ||
| 757 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | ||
| 758 | afterParserOrEnumRuleCall(); | ||
| 759 | } | ||
| 760 | ) | ||
| 761 | ) | ||
| 762 | ( | ||
| 763 | ( | ||
| 764 | { | ||
| 765 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); | ||
| 766 | } | ||
| 767 | lv_head_2_0=ruleCall | ||
| 768 | { | ||
| 769 | if ($current==null) { | ||
| 770 | $current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); | ||
| 771 | } | ||
| 772 | set( | ||
| 773 | $current, | ||
| 774 | "head", | ||
| 775 | lv_head_2_0, | ||
| 776 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 777 | afterParserOrEnumRuleCall(); | ||
| 778 | } | ||
| 779 | ) | ||
| 780 | ) | ||
| 781 | ) | ||
| 782 | ; | ||
| 783 | |||
| 784 | // Entry rule entryRuleExpression | ||
| 785 | entryRuleExpression returns [EObject current=null]: | ||
| 786 | { newCompositeNode(grammarAccess.getExpressionRule()); } | ||
| 787 | iv_ruleExpression=ruleExpression | ||
| 788 | { $current=$iv_ruleExpression.current; } | ||
| 789 | EOF; | ||
| 790 | |||
| 791 | // Rule Expression | ||
| 792 | ruleExpression returns [EObject current=null] | ||
| 793 | @init { | ||
| 794 | enterRule(); | ||
| 795 | } | ||
| 796 | @after { | ||
| 797 | leaveRule(); | ||
| 798 | }: | ||
| 799 | ( | ||
| 358 | { | 800 | { |
| 359 | newCompositeNode(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); | 801 | newCompositeNode(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); |
| 360 | } | 802 | } |
| 361 | this_DefaultInterpretation_1=ruleDefaultInterpretation | 803 | this_IfElse_0=ruleIfElse |
| 362 | { | 804 | { |
| 363 | $current = $this_DefaultInterpretation_1.current; | 805 | $current = $this_IfElse_0.current; |
| 364 | afterParserOrEnumRuleCall(); | 806 | afterParserOrEnumRuleCall(); |
| 365 | } | 807 | } |
| 366 | | | 808 | | |
| 367 | { | 809 | { |
| 368 | newCompositeNode(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); | 810 | newCompositeNode(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); |
| 369 | } | 811 | } |
| 370 | this_CDInterpretation_2=ruleCDInterpretation | 812 | this_DisjunctiveExpression_1=ruleDisjunctiveExpression |
| 371 | { | 813 | { |
| 372 | $current = $this_CDInterpretation_2.current; | 814 | $current = $this_DisjunctiveExpression_1.current; |
| 373 | afterParserOrEnumRuleCall(); | 815 | afterParserOrEnumRuleCall(); |
| 374 | } | 816 | } |
| 375 | ) | 817 | ) |
| 376 | ; | 818 | ; |
| 377 | 819 | ||
| 378 | // Entry rule entryRuleBasicInterpretation | 820 | // Entry rule entryRuleIfElse |
| 379 | entryRuleBasicInterpretation returns [EObject current=null]: | 821 | entryRuleIfElse returns [EObject current=null]: |
| 380 | { newCompositeNode(grammarAccess.getBasicInterpretationRule()); } | 822 | { newCompositeNode(grammarAccess.getIfElseRule()); } |
| 381 | iv_ruleBasicInterpretation=ruleBasicInterpretation | 823 | iv_ruleIfElse=ruleIfElse |
| 382 | { $current=$iv_ruleBasicInterpretation.current; } | 824 | { $current=$iv_ruleIfElse.current; } |
| 383 | EOF; | 825 | EOF; |
| 384 | 826 | ||
| 385 | // Rule BasicInterpretation | 827 | // Rule IfElse |
| 386 | ruleBasicInterpretation returns [EObject current=null] | 828 | ruleIfElse returns [EObject current=null] |
| 387 | @init { | 829 | @init { |
| 388 | enterRule(); | 830 | enterRule(); |
| 389 | } | 831 | } |
| @@ -391,100 +833,260 @@ ruleBasicInterpretation returns [EObject current=null] | |||
| 391 | leaveRule(); | 833 | leaveRule(); |
| 392 | }: | 834 | }: |
| 393 | ( | 835 | ( |
| 836 | otherlv_0='if' | ||
| 837 | { | ||
| 838 | newLeafNode(otherlv_0, grammarAccess.getIfElseAccess().getIfKeyword_0()); | ||
| 839 | } | ||
| 394 | ( | 840 | ( |
| 395 | ( | 841 | ( |
| 396 | { | 842 | { |
| 397 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); | 843 | newCompositeNode(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); |
| 398 | } | 844 | } |
| 399 | lv_symbol_0_0=ruleSymbol | 845 | lv_condition_1_0=ruleExpression |
| 400 | { | 846 | { |
| 401 | if ($current==null) { | 847 | if ($current==null) { |
| 402 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | 848 | $current = createModelElementForParent(grammarAccess.getIfElseRule()); |
| 403 | } | 849 | } |
| 404 | set( | 850 | set( |
| 405 | $current, | 851 | $current, |
| 406 | "symbol", | 852 | "condition", |
| 407 | lv_symbol_0_0, | 853 | lv_condition_1_0, |
| 408 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | 854 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
| 409 | afterParserOrEnumRuleCall(); | 855 | afterParserOrEnumRuleCall(); |
| 410 | } | 856 | } |
| 411 | ) | 857 | ) |
| 412 | ) | 858 | ) |
| 859 | otherlv_2='then' | ||
| 860 | { | ||
| 861 | newLeafNode(otherlv_2, grammarAccess.getIfElseAccess().getThenKeyword_2()); | ||
| 862 | } | ||
| 413 | ( | 863 | ( |
| 414 | otherlv_1='(' | ||
| 415 | { | ||
| 416 | newLeafNode(otherlv_1, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1_0()); | ||
| 417 | } | ||
| 418 | ( | 864 | ( |
| 865 | { | ||
| 866 | newCompositeNode(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); | ||
| 867 | } | ||
| 868 | lv_then_3_0=ruleExpression | ||
| 869 | { | ||
| 870 | if ($current==null) { | ||
| 871 | $current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 872 | } | ||
| 873 | set( | ||
| 874 | $current, | ||
| 875 | "then", | ||
| 876 | lv_then_3_0, | ||
| 877 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 878 | afterParserOrEnumRuleCall(); | ||
| 879 | } | ||
| 880 | ) | ||
| 881 | ) | ||
| 882 | otherlv_4='else' | ||
| 883 | { | ||
| 884 | newLeafNode(otherlv_4, grammarAccess.getIfElseAccess().getElseKeyword_4()); | ||
| 885 | } | ||
| 886 | ( | ||
| 887 | ( | ||
| 888 | { | ||
| 889 | newCompositeNode(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); | ||
| 890 | } | ||
| 891 | lv_else_5_0=ruleExpression | ||
| 892 | { | ||
| 893 | if ($current==null) { | ||
| 894 | $current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 895 | } | ||
| 896 | set( | ||
| 897 | $current, | ||
| 898 | "else", | ||
| 899 | lv_else_5_0, | ||
| 900 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 901 | afterParserOrEnumRuleCall(); | ||
| 902 | } | ||
| 903 | ) | ||
| 904 | ) | ||
| 905 | ) | ||
| 906 | ; | ||
| 907 | |||
| 908 | // Entry rule entryRuleDisjunctiveExpression | ||
| 909 | entryRuleDisjunctiveExpression returns [EObject current=null]: | ||
| 910 | { newCompositeNode(grammarAccess.getDisjunctiveExpressionRule()); } | ||
| 911 | iv_ruleDisjunctiveExpression=ruleDisjunctiveExpression | ||
| 912 | { $current=$iv_ruleDisjunctiveExpression.current; } | ||
| 913 | EOF; | ||
| 914 | |||
| 915 | // Rule DisjunctiveExpression | ||
| 916 | ruleDisjunctiveExpression returns [EObject current=null] | ||
| 917 | @init { | ||
| 918 | enterRule(); | ||
| 919 | } | ||
| 920 | @after { | ||
| 921 | leaveRule(); | ||
| 922 | }: | ||
| 923 | ( | ||
| 924 | { | ||
| 925 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); | ||
| 926 | } | ||
| 927 | this_ConjunctiveExpression_0=ruleConjunctiveExpression | ||
| 928 | { | ||
| 929 | $current = $this_ConjunctiveExpression_0.current; | ||
| 930 | afterParserOrEnumRuleCall(); | ||
| 931 | } | ||
| 932 | ( | ||
| 933 | ( | ||
| 934 | ( | ||
| 935 | { | ||
| 936 | $current = forceCreateModelElementAndAdd( | ||
| 937 | grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0(), | ||
| 938 | $current); | ||
| 939 | } | ||
| 940 | ) | ||
| 941 | ( | ||
| 942 | otherlv_2=';' | ||
| 943 | { | ||
| 944 | newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); | ||
| 945 | } | ||
| 946 | ( | ||
| 947 | ( | ||
| 948 | { | ||
| 949 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); | ||
| 950 | } | ||
| 951 | lv_children_3_0=ruleConjunctiveExpression | ||
| 952 | { | ||
| 953 | if ($current==null) { | ||
| 954 | $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 955 | } | ||
| 956 | add( | ||
| 957 | $current, | ||
| 958 | "children", | ||
| 959 | lv_children_3_0, | ||
| 960 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 961 | afterParserOrEnumRuleCall(); | ||
| 962 | } | ||
| 963 | ) | ||
| 964 | ) | ||
| 965 | )+ | ||
| 966 | ) | ||
| 967 | | | ||
| 968 | ( | ||
| 969 | ( | ||
| 970 | { | ||
| 971 | $current = forceCreateModelElementAndSet( | ||
| 972 | grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), | ||
| 973 | $current); | ||
| 974 | } | ||
| 975 | ) | ||
| 976 | otherlv_5='->' | ||
| 977 | { | ||
| 978 | newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); | ||
| 979 | } | ||
| 419 | ( | 980 | ( |
| 420 | ( | 981 | ( |
| 421 | { | 982 | { |
| 422 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_0_0()); | 983 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); |
| 423 | } | 984 | } |
| 424 | lv_objects_2_0=ruleComplexObject | 985 | lv_body_6_0=ruleConjunctiveExpression |
| 425 | { | 986 | { |
| 426 | if ($current==null) { | 987 | if ($current==null) { |
| 427 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | 988 | $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); |
| 428 | } | 989 | } |
| 429 | add( | 990 | set( |
| 430 | $current, | 991 | $current, |
| 431 | "objects", | 992 | "body", |
| 432 | lv_objects_2_0, | 993 | lv_body_6_0, |
| 433 | "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); | 994 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); |
| 434 | afterParserOrEnumRuleCall(); | 995 | afterParserOrEnumRuleCall(); |
| 435 | } | 996 | } |
| 436 | ) | 997 | ) |
| 437 | ) | 998 | ) |
| 438 | ( | 999 | ( |
| 439 | otherlv_3=',' | ||
| 440 | { | 1000 | { |
| 441 | newLeafNode(otherlv_3, grammarAccess.getBasicInterpretationAccess().getCommaKeyword_1_1_1_0()); | 1001 | $current = forceCreateModelElementAndAdd( |
| 1002 | grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3(), | ||
| 1003 | $current); | ||
| 1004 | } | ||
| 1005 | ) | ||
| 1006 | ( | ||
| 1007 | otherlv_8=';' | ||
| 1008 | { | ||
| 1009 | newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); | ||
| 442 | } | 1010 | } |
| 443 | ( | 1011 | ( |
| 444 | ( | 1012 | ( |
| 445 | { | 1013 | { |
| 446 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_1_1_0()); | 1014 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); |
| 447 | } | 1015 | } |
| 448 | lv_objects_4_0=ruleComplexObject | 1016 | lv_cases_9_0=ruleCase |
| 449 | { | 1017 | { |
| 450 | if ($current==null) { | 1018 | if ($current==null) { |
| 451 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | 1019 | $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); |
| 452 | } | 1020 | } |
| 453 | add( | 1021 | add( |
| 454 | $current, | 1022 | $current, |
| 455 | "objects", | 1023 | "cases", |
| 456 | lv_objects_4_0, | 1024 | lv_cases_9_0, |
| 457 | "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); | 1025 | "org.eclipse.viatra.solver.language.SolverLanguage.Case"); |
| 458 | afterParserOrEnumRuleCall(); | 1026 | afterParserOrEnumRuleCall(); |
| 459 | } | 1027 | } |
| 460 | ) | 1028 | ) |
| 461 | ) | 1029 | ) |
| 462 | )* | 1030 | )* |
| 463 | )? | 1031 | ) |
| 464 | otherlv_5=')' | ||
| 465 | { | ||
| 466 | newLeafNode(otherlv_5, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_1_2()); | ||
| 467 | } | ||
| 468 | )? | 1032 | )? |
| 469 | otherlv_6=':' | 1033 | ) |
| 1034 | ; | ||
| 1035 | |||
| 1036 | // Entry rule entryRuleCase | ||
| 1037 | entryRuleCase returns [EObject current=null]: | ||
| 1038 | { newCompositeNode(grammarAccess.getCaseRule()); } | ||
| 1039 | iv_ruleCase=ruleCase | ||
| 1040 | { $current=$iv_ruleCase.current; } | ||
| 1041 | EOF; | ||
| 1042 | |||
| 1043 | // Rule Case | ||
| 1044 | ruleCase returns [EObject current=null] | ||
| 1045 | @init { | ||
| 1046 | enterRule(); | ||
| 1047 | } | ||
| 1048 | @after { | ||
| 1049 | leaveRule(); | ||
| 1050 | }: | ||
| 1051 | ( | ||
| 1052 | ( | ||
| 1053 | ( | ||
| 1054 | { | ||
| 1055 | newCompositeNode(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); | ||
| 1056 | } | ||
| 1057 | lv_condition_0_0=ruleConjunctiveExpression | ||
| 1058 | { | ||
| 1059 | if ($current==null) { | ||
| 1060 | $current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
| 1061 | } | ||
| 1062 | set( | ||
| 1063 | $current, | ||
| 1064 | "condition", | ||
| 1065 | lv_condition_0_0, | ||
| 1066 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 1067 | afterParserOrEnumRuleCall(); | ||
| 1068 | } | ||
| 1069 | ) | ||
| 1070 | ) | ||
| 1071 | otherlv_1='->' | ||
| 470 | { | 1072 | { |
| 471 | newLeafNode(otherlv_6, grammarAccess.getBasicInterpretationAccess().getColonKeyword_2()); | 1073 | newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); |
| 472 | } | 1074 | } |
| 473 | ( | 1075 | ( |
| 474 | ( | 1076 | ( |
| 475 | { | 1077 | { |
| 476 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_3_0()); | 1078 | newCompositeNode(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); |
| 477 | } | 1079 | } |
| 478 | lv_value_7_0=ruleTruthValue | 1080 | lv_body_2_0=ruleConjunctiveExpression |
| 479 | { | 1081 | { |
| 480 | if ($current==null) { | 1082 | if ($current==null) { |
| 481 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | 1083 | $current = createModelElementForParent(grammarAccess.getCaseRule()); |
| 482 | } | 1084 | } |
| 483 | set( | 1085 | set( |
| 484 | $current, | 1086 | $current, |
| 485 | "value", | 1087 | "body", |
| 486 | lv_value_7_0, | 1088 | lv_body_2_0, |
| 487 | "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue"); | 1089 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); |
| 488 | afterParserOrEnumRuleCall(); | 1090 | afterParserOrEnumRuleCall(); |
| 489 | } | 1091 | } |
| 490 | ) | 1092 | ) |
| @@ -492,15 +1094,15 @@ ruleBasicInterpretation returns [EObject current=null] | |||
| 492 | ) | 1094 | ) |
| 493 | ; | 1095 | ; |
| 494 | 1096 | ||
| 495 | // Entry rule entryRuleSymbol | 1097 | // Entry rule entryRuleConjunctiveExpression |
| 496 | entryRuleSymbol returns [EObject current=null]: | 1098 | entryRuleConjunctiveExpression returns [EObject current=null]: |
| 497 | { newCompositeNode(grammarAccess.getSymbolRule()); } | 1099 | { newCompositeNode(grammarAccess.getConjunctiveExpressionRule()); } |
| 498 | iv_ruleSymbol=ruleSymbol | 1100 | iv_ruleConjunctiveExpression=ruleConjunctiveExpression |
| 499 | { $current=$iv_ruleSymbol.current; } | 1101 | { $current=$iv_ruleConjunctiveExpression.current; } |
| 500 | EOF; | 1102 | EOF; |
| 501 | 1103 | ||
| 502 | // Rule Symbol | 1104 | // Rule ConjunctiveExpression |
| 503 | ruleSymbol returns [EObject current=null] | 1105 | ruleConjunctiveExpression returns [EObject current=null] |
| 504 | @init { | 1106 | @init { |
| 505 | enterRule(); | 1107 | enterRule(); |
| 506 | } | 1108 | } |
| @@ -509,43 +1111,59 @@ ruleSymbol returns [EObject current=null] | |||
| 509 | }: | 1111 | }: |
| 510 | ( | 1112 | ( |
| 511 | { | 1113 | { |
| 512 | newCompositeNode(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); | 1114 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); |
| 513 | } | 1115 | } |
| 514 | this_ModelSymbol_0=ruleModelSymbol | 1116 | this_ComparisonExpression_0=ruleComparisonExpression |
| 515 | { | 1117 | { |
| 516 | $current = $this_ModelSymbol_0.current; | 1118 | $current = $this_ComparisonExpression_0.current; |
| 517 | afterParserOrEnumRuleCall(); | ||
| 518 | } | ||
| 519 | | | ||
| 520 | { | ||
| 521 | newCompositeNode(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); | ||
| 522 | } | ||
| 523 | this_PartialitySymbol_1=rulePartialitySymbol | ||
| 524 | { | ||
| 525 | $current = $this_PartialitySymbol_1.current; | ||
| 526 | afterParserOrEnumRuleCall(); | ||
| 527 | } | ||
| 528 | | | ||
| 529 | { | ||
| 530 | newCompositeNode(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); | ||
| 531 | } | ||
| 532 | this_DataSymbol_2=ruleDataSymbol | ||
| 533 | { | ||
| 534 | $current = $this_DataSymbol_2.current; | ||
| 535 | afterParserOrEnumRuleCall(); | 1119 | afterParserOrEnumRuleCall(); |
| 536 | } | 1120 | } |
| 1121 | ( | ||
| 1122 | ( | ||
| 1123 | { | ||
| 1124 | $current = forceCreateModelElementAndAdd( | ||
| 1125 | grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0(), | ||
| 1126 | $current); | ||
| 1127 | } | ||
| 1128 | ) | ||
| 1129 | ( | ||
| 1130 | otherlv_2=',' | ||
| 1131 | { | ||
| 1132 | newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); | ||
| 1133 | } | ||
| 1134 | ( | ||
| 1135 | ( | ||
| 1136 | { | ||
| 1137 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); | ||
| 1138 | } | ||
| 1139 | lv_children_3_0=ruleComparisonExpression | ||
| 1140 | { | ||
| 1141 | if ($current==null) { | ||
| 1142 | $current = createModelElementForParent(grammarAccess.getConjunctiveExpressionRule()); | ||
| 1143 | } | ||
| 1144 | add( | ||
| 1145 | $current, | ||
| 1146 | "children", | ||
| 1147 | lv_children_3_0, | ||
| 1148 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
| 1149 | afterParserOrEnumRuleCall(); | ||
| 1150 | } | ||
| 1151 | ) | ||
| 1152 | ) | ||
| 1153 | )+ | ||
| 1154 | )? | ||
| 537 | ) | 1155 | ) |
| 538 | ; | 1156 | ; |
| 539 | 1157 | ||
| 540 | // Entry rule entryRuleModelSymbol | 1158 | // Entry rule entryRuleComparisonExpression |
| 541 | entryRuleModelSymbol returns [EObject current=null]: | 1159 | entryRuleComparisonExpression returns [EObject current=null]: |
| 542 | { newCompositeNode(grammarAccess.getModelSymbolRule()); } | 1160 | { newCompositeNode(grammarAccess.getComparisonExpressionRule()); } |
| 543 | iv_ruleModelSymbol=ruleModelSymbol | 1161 | iv_ruleComparisonExpression=ruleComparisonExpression |
| 544 | { $current=$iv_ruleModelSymbol.current; } | 1162 | { $current=$iv_ruleComparisonExpression.current; } |
| 545 | EOF; | 1163 | EOF; |
| 546 | 1164 | ||
| 547 | // Rule ModelSymbol | 1165 | // Rule ComparisonExpression |
| 548 | ruleModelSymbol returns [EObject current=null] | 1166 | ruleComparisonExpression returns [EObject current=null] |
| 549 | @init { | 1167 | @init { |
| 550 | enterRule(); | 1168 | enterRule(); |
| 551 | } | 1169 | } |
| @@ -553,34 +1171,73 @@ ruleModelSymbol returns [EObject current=null] | |||
| 553 | leaveRule(); | 1171 | leaveRule(); |
| 554 | }: | 1172 | }: |
| 555 | ( | 1173 | ( |
| 1174 | { | ||
| 1175 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); | ||
| 1176 | } | ||
| 1177 | this_AdditiveExpression_0=ruleAdditiveExpression | ||
| 1178 | { | ||
| 1179 | $current = $this_AdditiveExpression_0.current; | ||
| 1180 | afterParserOrEnumRuleCall(); | ||
| 1181 | } | ||
| 556 | ( | 1182 | ( |
| 557 | lv_name_0_0=RULE_ID | 1183 | ( |
| 558 | { | 1184 | { |
| 559 | newLeafNode(lv_name_0_0, grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); | 1185 | $current = forceCreateModelElementAndSet( |
| 560 | } | 1186 | grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(), |
| 561 | { | 1187 | $current); |
| 562 | if ($current==null) { | ||
| 563 | $current = createModelElement(grammarAccess.getModelSymbolRule()); | ||
| 564 | } | 1188 | } |
| 565 | setWithLastConsumed( | 1189 | ) |
| 566 | $current, | 1190 | ( |
| 567 | "name", | 1191 | ( |
| 568 | lv_name_0_0, | 1192 | { |
| 569 | "org.eclipse.xtext.common.Terminals.ID"); | 1193 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); |
| 570 | } | 1194 | } |
| 571 | ) | 1195 | lv_op_2_0=ruleComparisonOperator |
| 1196 | { | ||
| 1197 | if ($current==null) { | ||
| 1198 | $current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
| 1199 | } | ||
| 1200 | set( | ||
| 1201 | $current, | ||
| 1202 | "op", | ||
| 1203 | lv_op_2_0, | ||
| 1204 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator"); | ||
| 1205 | afterParserOrEnumRuleCall(); | ||
| 1206 | } | ||
| 1207 | ) | ||
| 1208 | ) | ||
| 1209 | ( | ||
| 1210 | ( | ||
| 1211 | { | ||
| 1212 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); | ||
| 1213 | } | ||
| 1214 | lv_right_3_0=ruleAdditiveExpression | ||
| 1215 | { | ||
| 1216 | if ($current==null) { | ||
| 1217 | $current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
| 1218 | } | ||
| 1219 | set( | ||
| 1220 | $current, | ||
| 1221 | "right", | ||
| 1222 | lv_right_3_0, | ||
| 1223 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
| 1224 | afterParserOrEnumRuleCall(); | ||
| 1225 | } | ||
| 1226 | ) | ||
| 1227 | ) | ||
| 1228 | )? | ||
| 572 | ) | 1229 | ) |
| 573 | ; | 1230 | ; |
| 574 | 1231 | ||
| 575 | // Entry rule entryRulePartialitySymbol | 1232 | // Entry rule entryRuleAdditiveExpression |
| 576 | entryRulePartialitySymbol returns [EObject current=null]: | 1233 | entryRuleAdditiveExpression returns [EObject current=null]: |
| 577 | { newCompositeNode(grammarAccess.getPartialitySymbolRule()); } | 1234 | { newCompositeNode(grammarAccess.getAdditiveExpressionRule()); } |
| 578 | iv_rulePartialitySymbol=rulePartialitySymbol | 1235 | iv_ruleAdditiveExpression=ruleAdditiveExpression |
| 579 | { $current=$iv_rulePartialitySymbol.current; } | 1236 | { $current=$iv_ruleAdditiveExpression.current; } |
| 580 | EOF; | 1237 | EOF; |
| 581 | 1238 | ||
| 582 | // Rule PartialitySymbol | 1239 | // Rule AdditiveExpression |
| 583 | rulePartialitySymbol returns [EObject current=null] | 1240 | ruleAdditiveExpression returns [EObject current=null] |
| 584 | @init { | 1241 | @init { |
| 585 | enterRule(); | 1242 | enterRule(); |
| 586 | } | 1243 | } |
| @@ -589,34 +1246,146 @@ rulePartialitySymbol returns [EObject current=null] | |||
| 589 | }: | 1246 | }: |
| 590 | ( | 1247 | ( |
| 591 | { | 1248 | { |
| 592 | newCompositeNode(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); | 1249 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); |
| 593 | } | 1250 | } |
| 594 | this_ExistSymbol_0=ruleExistSymbol | 1251 | this_MultiplicativeExpression_0=ruleMultiplicativeExpression |
| 595 | { | 1252 | { |
| 596 | $current = $this_ExistSymbol_0.current; | 1253 | $current = $this_MultiplicativeExpression_0.current; |
| 597 | afterParserOrEnumRuleCall(); | 1254 | afterParserOrEnumRuleCall(); |
| 598 | } | 1255 | } |
| 599 | | | 1256 | ( |
| 1257 | ( | ||
| 1258 | { | ||
| 1259 | $current = forceCreateModelElementAndSet( | ||
| 1260 | grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 1261 | $current); | ||
| 1262 | } | ||
| 1263 | ) | ||
| 1264 | ( | ||
| 1265 | ( | ||
| 1266 | { | ||
| 1267 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); | ||
| 1268 | } | ||
| 1269 | lv_op_2_0=ruleAdditiveBinaryOperator | ||
| 1270 | { | ||
| 1271 | if ($current==null) { | ||
| 1272 | $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
| 1273 | } | ||
| 1274 | set( | ||
| 1275 | $current, | ||
| 1276 | "op", | ||
| 1277 | lv_op_2_0, | ||
| 1278 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator"); | ||
| 1279 | afterParserOrEnumRuleCall(); | ||
| 1280 | } | ||
| 1281 | ) | ||
| 1282 | ) | ||
| 1283 | ( | ||
| 1284 | ( | ||
| 1285 | { | ||
| 1286 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); | ||
| 1287 | } | ||
| 1288 | lv_right_3_0=ruleMultiplicativeExpression | ||
| 1289 | { | ||
| 1290 | if ($current==null) { | ||
| 1291 | $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
| 1292 | } | ||
| 1293 | set( | ||
| 1294 | $current, | ||
| 1295 | "right", | ||
| 1296 | lv_right_3_0, | ||
| 1297 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression"); | ||
| 1298 | afterParserOrEnumRuleCall(); | ||
| 1299 | } | ||
| 1300 | ) | ||
| 1301 | ) | ||
| 1302 | )* | ||
| 1303 | ) | ||
| 1304 | ; | ||
| 1305 | |||
| 1306 | // Entry rule entryRuleMultiplicativeExpression | ||
| 1307 | entryRuleMultiplicativeExpression returns [EObject current=null]: | ||
| 1308 | { newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); } | ||
| 1309 | iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression | ||
| 1310 | { $current=$iv_ruleMultiplicativeExpression.current; } | ||
| 1311 | EOF; | ||
| 1312 | |||
| 1313 | // Rule MultiplicativeExpression | ||
| 1314 | ruleMultiplicativeExpression returns [EObject current=null] | ||
| 1315 | @init { | ||
| 1316 | enterRule(); | ||
| 1317 | } | ||
| 1318 | @after { | ||
| 1319 | leaveRule(); | ||
| 1320 | }: | ||
| 1321 | ( | ||
| 600 | { | 1322 | { |
| 601 | newCompositeNode(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); | 1323 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); |
| 602 | } | 1324 | } |
| 603 | this_EqualsSymbol_1=ruleEqualsSymbol | 1325 | this_ExponentialExpression_0=ruleExponentialExpression |
| 604 | { | 1326 | { |
| 605 | $current = $this_EqualsSymbol_1.current; | 1327 | $current = $this_ExponentialExpression_0.current; |
| 606 | afterParserOrEnumRuleCall(); | 1328 | afterParserOrEnumRuleCall(); |
| 607 | } | 1329 | } |
| 1330 | ( | ||
| 1331 | ( | ||
| 1332 | { | ||
| 1333 | $current = forceCreateModelElementAndSet( | ||
| 1334 | grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 1335 | $current); | ||
| 1336 | } | ||
| 1337 | ) | ||
| 1338 | ( | ||
| 1339 | ( | ||
| 1340 | { | ||
| 1341 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); | ||
| 1342 | } | ||
| 1343 | lv_op_2_0=ruleMultiplicativeBinaryOperator | ||
| 1344 | { | ||
| 1345 | if ($current==null) { | ||
| 1346 | $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
| 1347 | } | ||
| 1348 | set( | ||
| 1349 | $current, | ||
| 1350 | "op", | ||
| 1351 | lv_op_2_0, | ||
| 1352 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator"); | ||
| 1353 | afterParserOrEnumRuleCall(); | ||
| 1354 | } | ||
| 1355 | ) | ||
| 1356 | ) | ||
| 1357 | ( | ||
| 1358 | ( | ||
| 1359 | { | ||
| 1360 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
| 1361 | } | ||
| 1362 | lv_right_3_0=ruleExponentialExpression | ||
| 1363 | { | ||
| 1364 | if ($current==null) { | ||
| 1365 | $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
| 1366 | } | ||
| 1367 | set( | ||
| 1368 | $current, | ||
| 1369 | "right", | ||
| 1370 | lv_right_3_0, | ||
| 1371 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
| 1372 | afterParserOrEnumRuleCall(); | ||
| 1373 | } | ||
| 1374 | ) | ||
| 1375 | ) | ||
| 1376 | )* | ||
| 608 | ) | 1377 | ) |
| 609 | ; | 1378 | ; |
| 610 | 1379 | ||
| 611 | // Entry rule entryRuleExistSymbol | 1380 | // Entry rule entryRuleExponentialExpression |
| 612 | entryRuleExistSymbol returns [EObject current=null]: | 1381 | entryRuleExponentialExpression returns [EObject current=null]: |
| 613 | { newCompositeNode(grammarAccess.getExistSymbolRule()); } | 1382 | { newCompositeNode(grammarAccess.getExponentialExpressionRule()); } |
| 614 | iv_ruleExistSymbol=ruleExistSymbol | 1383 | iv_ruleExponentialExpression=ruleExponentialExpression |
| 615 | { $current=$iv_ruleExistSymbol.current; } | 1384 | { $current=$iv_ruleExponentialExpression.current; } |
| 616 | EOF; | 1385 | EOF; |
| 617 | 1386 | ||
| 618 | // Rule ExistSymbol | 1387 | // Rule ExponentialExpression |
| 619 | ruleExistSymbol returns [EObject current=null] | 1388 | ruleExponentialExpression returns [EObject current=null] |
| 620 | @init { | 1389 | @init { |
| 621 | enterRule(); | 1390 | enterRule(); |
| 622 | } | 1391 | } |
| @@ -624,29 +1393,73 @@ ruleExistSymbol returns [EObject current=null] | |||
| 624 | leaveRule(); | 1393 | leaveRule(); |
| 625 | }: | 1394 | }: |
| 626 | ( | 1395 | ( |
| 627 | otherlv_0='exists' | ||
| 628 | { | 1396 | { |
| 629 | newLeafNode(otherlv_0, grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); | 1397 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); |
| 1398 | } | ||
| 1399 | this_UnaryExpression_0=ruleUnaryExpression | ||
| 1400 | { | ||
| 1401 | $current = $this_UnaryExpression_0.current; | ||
| 1402 | afterParserOrEnumRuleCall(); | ||
| 630 | } | 1403 | } |
| 631 | ( | 1404 | ( |
| 632 | { | 1405 | ( |
| 633 | $current = forceCreateModelElement( | 1406 | { |
| 634 | grammarAccess.getExistSymbolAccess().getExistSymbolAction_1(), | 1407 | $current = forceCreateModelElementAndSet( |
| 635 | $current); | 1408 | grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0(), |
| 636 | } | 1409 | $current); |
| 637 | ) | 1410 | } |
| 1411 | ) | ||
| 1412 | ( | ||
| 1413 | ( | ||
| 1414 | { | ||
| 1415 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); | ||
| 1416 | } | ||
| 1417 | lv_op_2_0=ruleExponentialOp | ||
| 1418 | { | ||
| 1419 | if ($current==null) { | ||
| 1420 | $current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
| 1421 | } | ||
| 1422 | set( | ||
| 1423 | $current, | ||
| 1424 | "op", | ||
| 1425 | lv_op_2_0, | ||
| 1426 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp"); | ||
| 1427 | afterParserOrEnumRuleCall(); | ||
| 1428 | } | ||
| 1429 | ) | ||
| 1430 | ) | ||
| 1431 | ( | ||
| 1432 | ( | ||
| 1433 | { | ||
| 1434 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
| 1435 | } | ||
| 1436 | lv_right_3_0=ruleExponentialExpression | ||
| 1437 | { | ||
| 1438 | if ($current==null) { | ||
| 1439 | $current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
| 1440 | } | ||
| 1441 | set( | ||
| 1442 | $current, | ||
| 1443 | "right", | ||
| 1444 | lv_right_3_0, | ||
| 1445 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
| 1446 | afterParserOrEnumRuleCall(); | ||
| 1447 | } | ||
| 1448 | ) | ||
| 1449 | ) | ||
| 1450 | )? | ||
| 638 | ) | 1451 | ) |
| 639 | ; | 1452 | ; |
| 640 | 1453 | ||
| 641 | // Entry rule entryRuleEqualsSymbol | 1454 | // Entry rule entryRuleUnaryExpression |
| 642 | entryRuleEqualsSymbol returns [EObject current=null]: | 1455 | entryRuleUnaryExpression returns [EObject current=null]: |
| 643 | { newCompositeNode(grammarAccess.getEqualsSymbolRule()); } | 1456 | { newCompositeNode(grammarAccess.getUnaryExpressionRule()); } |
| 644 | iv_ruleEqualsSymbol=ruleEqualsSymbol | 1457 | iv_ruleUnaryExpression=ruleUnaryExpression |
| 645 | { $current=$iv_ruleEqualsSymbol.current; } | 1458 | { $current=$iv_ruleUnaryExpression.current; } |
| 646 | EOF; | 1459 | EOF; |
| 647 | 1460 | ||
| 648 | // Rule EqualsSymbol | 1461 | // Rule UnaryExpression |
| 649 | ruleEqualsSymbol returns [EObject current=null] | 1462 | ruleUnaryExpression returns [EObject current=null] |
| 650 | @init { | 1463 | @init { |
| 651 | enterRule(); | 1464 | enterRule(); |
| 652 | } | 1465 | } |
| @@ -654,29 +1467,74 @@ ruleEqualsSymbol returns [EObject current=null] | |||
| 654 | leaveRule(); | 1467 | leaveRule(); |
| 655 | }: | 1468 | }: |
| 656 | ( | 1469 | ( |
| 657 | otherlv_0='equals' | ||
| 658 | { | 1470 | { |
| 659 | newLeafNode(otherlv_0, grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); | 1471 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); |
| 660 | } | 1472 | } |
| 1473 | this_AggregationExpression_0=ruleAggregationExpression | ||
| 1474 | { | ||
| 1475 | $current = $this_AggregationExpression_0.current; | ||
| 1476 | afterParserOrEnumRuleCall(); | ||
| 1477 | } | ||
| 1478 | | | ||
| 661 | ( | 1479 | ( |
| 662 | { | 1480 | ( |
| 663 | $current = forceCreateModelElement( | 1481 | { |
| 664 | grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1(), | 1482 | $current = forceCreateModelElement( |
| 665 | $current); | 1483 | grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0(), |
| 666 | } | 1484 | $current); |
| 1485 | } | ||
| 1486 | ) | ||
| 1487 | ( | ||
| 1488 | ( | ||
| 1489 | { | ||
| 1490 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); | ||
| 1491 | } | ||
| 1492 | lv_op_2_0=ruleUnaryOp | ||
| 1493 | { | ||
| 1494 | if ($current==null) { | ||
| 1495 | $current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | ||
| 1496 | } | ||
| 1497 | set( | ||
| 1498 | $current, | ||
| 1499 | "op", | ||
| 1500 | lv_op_2_0, | ||
| 1501 | "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOp"); | ||
| 1502 | afterParserOrEnumRuleCall(); | ||
| 1503 | } | ||
| 1504 | ) | ||
| 1505 | ) | ||
| 1506 | ( | ||
| 1507 | ( | ||
| 1508 | { | ||
| 1509 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); | ||
| 1510 | } | ||
| 1511 | lv_body_3_0=ruleAggregationExpression | ||
| 1512 | { | ||
| 1513 | if ($current==null) { | ||
| 1514 | $current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | ||
| 1515 | } | ||
| 1516 | set( | ||
| 1517 | $current, | ||
| 1518 | "body", | ||
| 1519 | lv_body_3_0, | ||
| 1520 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationExpression"); | ||
| 1521 | afterParserOrEnumRuleCall(); | ||
| 1522 | } | ||
| 1523 | ) | ||
| 1524 | ) | ||
| 667 | ) | 1525 | ) |
| 668 | ) | 1526 | ) |
| 669 | ; | 1527 | ; |
| 670 | 1528 | ||
| 671 | // Entry rule entryRuleDataSymbol | 1529 | // Entry rule entryRuleAggregationExpression |
| 672 | entryRuleDataSymbol returns [EObject current=null]: | 1530 | entryRuleAggregationExpression returns [EObject current=null]: |
| 673 | { newCompositeNode(grammarAccess.getDataSymbolRule()); } | 1531 | { newCompositeNode(grammarAccess.getAggregationExpressionRule()); } |
| 674 | iv_ruleDataSymbol=ruleDataSymbol | 1532 | iv_ruleAggregationExpression=ruleAggregationExpression |
| 675 | { $current=$iv_ruleDataSymbol.current; } | 1533 | { $current=$iv_ruleAggregationExpression.current; } |
| 676 | EOF; | 1534 | EOF; |
| 677 | 1535 | ||
| 678 | // Rule DataSymbol | 1536 | // Rule AggregationExpression |
| 679 | ruleDataSymbol returns [EObject current=null] | 1537 | ruleAggregationExpression returns [EObject current=null] |
| 680 | @init { | 1538 | @init { |
| 681 | enterRule(); | 1539 | enterRule(); |
| 682 | } | 1540 | } |
| @@ -685,52 +1543,93 @@ ruleDataSymbol returns [EObject current=null] | |||
| 685 | }: | 1543 | }: |
| 686 | ( | 1544 | ( |
| 687 | { | 1545 | { |
| 688 | newCompositeNode(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); | 1546 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); |
| 689 | } | 1547 | } |
| 690 | this_BooleanSymbol_0=ruleBooleanSymbol | 1548 | this_AtomicExpression_0=ruleAtomicExpression |
| 691 | { | 1549 | { |
| 692 | $current = $this_BooleanSymbol_0.current; | 1550 | $current = $this_AtomicExpression_0.current; |
| 693 | afterParserOrEnumRuleCall(); | 1551 | afterParserOrEnumRuleCall(); |
| 694 | } | 1552 | } |
| 695 | | | 1553 | | |
| 696 | { | 1554 | { |
| 697 | newCompositeNode(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); | 1555 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); |
| 698 | } | 1556 | } |
| 699 | this_IntegerSymbol_1=ruleIntegerSymbol | 1557 | this_Count_1=ruleCount |
| 700 | { | 1558 | { |
| 701 | $current = $this_IntegerSymbol_1.current; | 1559 | $current = $this_Count_1.current; |
| 702 | afterParserOrEnumRuleCall(); | 1560 | afterParserOrEnumRuleCall(); |
| 703 | } | 1561 | } |
| 704 | | | 1562 | | |
| 705 | { | 1563 | { |
| 706 | newCompositeNode(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); | 1564 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); |
| 707 | } | 1565 | } |
| 708 | this_RealSymbol_2=ruleRealSymbol | 1566 | this_Aggregation_2=ruleAggregation |
| 709 | { | 1567 | { |
| 710 | $current = $this_RealSymbol_2.current; | 1568 | $current = $this_Aggregation_2.current; |
| 711 | afterParserOrEnumRuleCall(); | 1569 | afterParserOrEnumRuleCall(); |
| 712 | } | 1570 | } |
| 713 | | | 1571 | ) |
| 1572 | ; | ||
| 1573 | |||
| 1574 | // Entry rule entryRuleCount | ||
| 1575 | entryRuleCount returns [EObject current=null]: | ||
| 1576 | { newCompositeNode(grammarAccess.getCountRule()); } | ||
| 1577 | iv_ruleCount=ruleCount | ||
| 1578 | { $current=$iv_ruleCount.current; } | ||
| 1579 | EOF; | ||
| 1580 | |||
| 1581 | // Rule Count | ||
| 1582 | ruleCount returns [EObject current=null] | ||
| 1583 | @init { | ||
| 1584 | enterRule(); | ||
| 1585 | } | ||
| 1586 | @after { | ||
| 1587 | leaveRule(); | ||
| 1588 | }: | ||
| 1589 | ( | ||
| 1590 | otherlv_0='count' | ||
| 714 | { | 1591 | { |
| 715 | newCompositeNode(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); | 1592 | newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0()); |
| 716 | } | 1593 | } |
| 717 | this_StringSymbol_3=ruleStringSymbol | 1594 | otherlv_1='{' |
| 718 | { | 1595 | { |
| 719 | $current = $this_StringSymbol_3.current; | 1596 | newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); |
| 720 | afterParserOrEnumRuleCall(); | 1597 | } |
| 1598 | ( | ||
| 1599 | ( | ||
| 1600 | { | ||
| 1601 | newCompositeNode(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); | ||
| 1602 | } | ||
| 1603 | lv_body_2_0=ruleExpression | ||
| 1604 | { | ||
| 1605 | if ($current==null) { | ||
| 1606 | $current = createModelElementForParent(grammarAccess.getCountRule()); | ||
| 1607 | } | ||
| 1608 | set( | ||
| 1609 | $current, | ||
| 1610 | "body", | ||
| 1611 | lv_body_2_0, | ||
| 1612 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1613 | afterParserOrEnumRuleCall(); | ||
| 1614 | } | ||
| 1615 | ) | ||
| 1616 | ) | ||
| 1617 | otherlv_3='}' | ||
| 1618 | { | ||
| 1619 | newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); | ||
| 721 | } | 1620 | } |
| 722 | ) | 1621 | ) |
| 723 | ; | 1622 | ; |
| 724 | 1623 | ||
| 725 | // Entry rule entryRuleBooleanSymbol | 1624 | // Entry rule entryRuleAggregation |
| 726 | entryRuleBooleanSymbol returns [EObject current=null]: | 1625 | entryRuleAggregation returns [EObject current=null]: |
| 727 | { newCompositeNode(grammarAccess.getBooleanSymbolRule()); } | 1626 | { newCompositeNode(grammarAccess.getAggregationRule()); } |
| 728 | iv_ruleBooleanSymbol=ruleBooleanSymbol | 1627 | iv_ruleAggregation=ruleAggregation |
| 729 | { $current=$iv_ruleBooleanSymbol.current; } | 1628 | { $current=$iv_ruleAggregation.current; } |
| 730 | EOF; | 1629 | EOF; |
| 731 | 1630 | ||
| 732 | // Rule BooleanSymbol | 1631 | // Rule Aggregation |
| 733 | ruleBooleanSymbol returns [EObject current=null] | 1632 | ruleAggregation returns [EObject current=null] |
| 734 | @init { | 1633 | @init { |
| 735 | enterRule(); | 1634 | enterRule(); |
| 736 | } | 1635 | } |
| @@ -738,29 +1637,87 @@ ruleBooleanSymbol returns [EObject current=null] | |||
| 738 | leaveRule(); | 1637 | leaveRule(); |
| 739 | }: | 1638 | }: |
| 740 | ( | 1639 | ( |
| 741 | otherlv_0='bool' | 1640 | ( |
| 1641 | ( | ||
| 1642 | { | ||
| 1643 | newCompositeNode(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); | ||
| 1644 | } | ||
| 1645 | lv_op_0_0=ruleAggregationOp | ||
| 1646 | { | ||
| 1647 | if ($current==null) { | ||
| 1648 | $current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 1649 | } | ||
| 1650 | set( | ||
| 1651 | $current, | ||
| 1652 | "op", | ||
| 1653 | lv_op_0_0, | ||
| 1654 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationOp"); | ||
| 1655 | afterParserOrEnumRuleCall(); | ||
| 1656 | } | ||
| 1657 | ) | ||
| 1658 | ) | ||
| 1659 | otherlv_1='{' | ||
| 742 | { | 1660 | { |
| 743 | newLeafNode(otherlv_0, grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); | 1661 | newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); |
| 744 | } | 1662 | } |
| 745 | ( | 1663 | ( |
| 746 | { | 1664 | ( |
| 747 | $current = forceCreateModelElement( | 1665 | { |
| 748 | grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1(), | 1666 | newCompositeNode(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); |
| 749 | $current); | 1667 | } |
| 750 | } | 1668 | lv_body_2_0=ruleExpression |
| 1669 | { | ||
| 1670 | if ($current==null) { | ||
| 1671 | $current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 1672 | } | ||
| 1673 | set( | ||
| 1674 | $current, | ||
| 1675 | "body", | ||
| 1676 | lv_body_2_0, | ||
| 1677 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1678 | afterParserOrEnumRuleCall(); | ||
| 1679 | } | ||
| 1680 | ) | ||
| 1681 | ) | ||
| 1682 | otherlv_3='|' | ||
| 1683 | { | ||
| 1684 | newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); | ||
| 1685 | } | ||
| 1686 | ( | ||
| 1687 | ( | ||
| 1688 | { | ||
| 1689 | newCompositeNode(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); | ||
| 1690 | } | ||
| 1691 | lv_condition_4_0=ruleExpression | ||
| 1692 | { | ||
| 1693 | if ($current==null) { | ||
| 1694 | $current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 1695 | } | ||
| 1696 | set( | ||
| 1697 | $current, | ||
| 1698 | "condition", | ||
| 1699 | lv_condition_4_0, | ||
| 1700 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1701 | afterParserOrEnumRuleCall(); | ||
| 1702 | } | ||
| 1703 | ) | ||
| 751 | ) | 1704 | ) |
| 1705 | otherlv_5='}' | ||
| 1706 | { | ||
| 1707 | newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); | ||
| 1708 | } | ||
| 752 | ) | 1709 | ) |
| 753 | ; | 1710 | ; |
| 754 | 1711 | ||
| 755 | // Entry rule entryRuleIntegerSymbol | 1712 | // Entry rule entryRuleAtomicExpression |
| 756 | entryRuleIntegerSymbol returns [EObject current=null]: | 1713 | entryRuleAtomicExpression returns [EObject current=null]: |
| 757 | { newCompositeNode(grammarAccess.getIntegerSymbolRule()); } | 1714 | { newCompositeNode(grammarAccess.getAtomicExpressionRule()); } |
| 758 | iv_ruleIntegerSymbol=ruleIntegerSymbol | 1715 | iv_ruleAtomicExpression=ruleAtomicExpression |
| 759 | { $current=$iv_ruleIntegerSymbol.current; } | 1716 | { $current=$iv_ruleAtomicExpression.current; } |
| 760 | EOF; | 1717 | EOF; |
| 761 | 1718 | ||
| 762 | // Rule IntegerSymbol | 1719 | // Rule AtomicExpression |
| 763 | ruleIntegerSymbol returns [EObject current=null] | 1720 | ruleAtomicExpression returns [EObject current=null] |
| 764 | @init { | 1721 | @init { |
| 765 | enterRule(); | 1722 | enterRule(); |
| 766 | } | 1723 | } |
| @@ -768,29 +1725,94 @@ ruleIntegerSymbol returns [EObject current=null] | |||
| 768 | leaveRule(); | 1725 | leaveRule(); |
| 769 | }: | 1726 | }: |
| 770 | ( | 1727 | ( |
| 771 | otherlv_0='int' | 1728 | ( |
| 1729 | { | ||
| 1730 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0()); | ||
| 1731 | } | ||
| 1732 | this_Reference_0=ruleReference | ||
| 1733 | { | ||
| 1734 | $current = $this_Reference_0.current; | ||
| 1735 | afterParserOrEnumRuleCall(); | ||
| 1736 | } | ||
| 1737 | ( | ||
| 1738 | ( | ||
| 1739 | { | ||
| 1740 | $current = forceCreateModelElementAndSet( | ||
| 1741 | grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0(), | ||
| 1742 | $current); | ||
| 1743 | } | ||
| 1744 | ) | ||
| 1745 | ( | ||
| 1746 | ('(')=> | ||
| 1747 | ( | ||
| 1748 | { | ||
| 1749 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0()); | ||
| 1750 | } | ||
| 1751 | lv_argumentList_2_0=ruleArgumentList | ||
| 1752 | { | ||
| 1753 | if ($current==null) { | ||
| 1754 | $current = createModelElementForParent(grammarAccess.getAtomicExpressionRule()); | ||
| 1755 | } | ||
| 1756 | set( | ||
| 1757 | $current, | ||
| 1758 | "argumentList", | ||
| 1759 | lv_argumentList_2_0, | ||
| 1760 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
| 1761 | afterParserOrEnumRuleCall(); | ||
| 1762 | } | ||
| 1763 | ) | ||
| 1764 | ) | ||
| 1765 | )? | ||
| 1766 | ) | ||
| 1767 | | | ||
| 1768 | { | ||
| 1769 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1()); | ||
| 1770 | } | ||
| 1771 | this_Interval_3=ruleInterval | ||
| 772 | { | 1772 | { |
| 773 | newLeafNode(otherlv_0, grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); | 1773 | $current = $this_Interval_3.current; |
| 1774 | afterParserOrEnumRuleCall(); | ||
| 774 | } | 1775 | } |
| 1776 | | | ||
| 1777 | { | ||
| 1778 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2()); | ||
| 1779 | } | ||
| 1780 | this_Literal_4=ruleLiteral | ||
| 1781 | { | ||
| 1782 | $current = $this_Literal_4.current; | ||
| 1783 | afterParserOrEnumRuleCall(); | ||
| 1784 | } | ||
| 1785 | | | ||
| 775 | ( | 1786 | ( |
| 1787 | otherlv_5='(' | ||
| 776 | { | 1788 | { |
| 777 | $current = forceCreateModelElement( | 1789 | newLeafNode(otherlv_5, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0()); |
| 778 | grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1(), | 1790 | } |
| 779 | $current); | 1791 | { |
| 1792 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1()); | ||
| 1793 | } | ||
| 1794 | this_Expression_6=ruleExpression | ||
| 1795 | { | ||
| 1796 | $current = $this_Expression_6.current; | ||
| 1797 | afterParserOrEnumRuleCall(); | ||
| 1798 | } | ||
| 1799 | otherlv_7=')' | ||
| 1800 | { | ||
| 1801 | newLeafNode(otherlv_7, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2()); | ||
| 780 | } | 1802 | } |
| 781 | ) | 1803 | ) |
| 782 | ) | 1804 | ) |
| 783 | ; | 1805 | ; |
| 784 | 1806 | ||
| 785 | // Entry rule entryRuleRealSymbol | 1807 | // Entry rule entryRuleCall |
| 786 | entryRuleRealSymbol returns [EObject current=null]: | 1808 | entryRuleCall returns [EObject current=null]: |
| 787 | { newCompositeNode(grammarAccess.getRealSymbolRule()); } | 1809 | { newCompositeNode(grammarAccess.getCallRule()); } |
| 788 | iv_ruleRealSymbol=ruleRealSymbol | 1810 | iv_ruleCall=ruleCall |
| 789 | { $current=$iv_ruleRealSymbol.current; } | 1811 | { $current=$iv_ruleCall.current; } |
| 790 | EOF; | 1812 | EOF; |
| 791 | 1813 | ||
| 792 | // Rule RealSymbol | 1814 | // Rule Call |
| 793 | ruleRealSymbol returns [EObject current=null] | 1815 | ruleCall returns [EObject current=null] |
| 794 | @init { | 1816 | @init { |
| 795 | enterRule(); | 1817 | enterRule(); |
| 796 | } | 1818 | } |
| @@ -798,29 +1820,95 @@ ruleRealSymbol returns [EObject current=null] | |||
| 798 | leaveRule(); | 1820 | leaveRule(); |
| 799 | }: | 1821 | }: |
| 800 | ( | 1822 | ( |
| 801 | otherlv_0='real' | ||
| 802 | { | ||
| 803 | newLeafNode(otherlv_0, grammarAccess.getRealSymbolAccess().getRealKeyword_0()); | ||
| 804 | } | ||
| 805 | ( | 1823 | ( |
| 806 | { | 1824 | ( |
| 807 | $current = forceCreateModelElement( | 1825 | { |
| 808 | grammarAccess.getRealSymbolAccess().getRealSymbolAction_1(), | 1826 | newCompositeNode(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); |
| 809 | $current); | 1827 | } |
| 810 | } | 1828 | lv_functor_0_0=ruleReference |
| 1829 | { | ||
| 1830 | if ($current==null) { | ||
| 1831 | $current = createModelElementForParent(grammarAccess.getCallRule()); | ||
| 1832 | } | ||
| 1833 | set( | ||
| 1834 | $current, | ||
| 1835 | "functor", | ||
| 1836 | lv_functor_0_0, | ||
| 1837 | "org.eclipse.viatra.solver.language.SolverLanguage.Reference"); | ||
| 1838 | afterParserOrEnumRuleCall(); | ||
| 1839 | } | ||
| 1840 | ) | ||
| 1841 | ) | ||
| 1842 | ( | ||
| 1843 | ( | ||
| 1844 | ( | ||
| 1845 | lv_transitiveClosure_1_0=RULE_STAR | ||
| 1846 | { | ||
| 1847 | newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0()); | ||
| 1848 | } | ||
| 1849 | { | ||
| 1850 | if ($current==null) { | ||
| 1851 | $current = createModelElement(grammarAccess.getCallRule()); | ||
| 1852 | } | ||
| 1853 | setWithLastConsumed( | ||
| 1854 | $current, | ||
| 1855 | "transitiveClosure", | ||
| 1856 | true, | ||
| 1857 | "org.eclipse.viatra.solver.language.SolverLanguage.STAR"); | ||
| 1858 | } | ||
| 1859 | ) | ||
| 1860 | ) | ||
| 1861 | | | ||
| 1862 | ( | ||
| 1863 | ( | ||
| 1864 | lv_reflexiveTransitiveClosure_2_0=RULE_PLUS | ||
| 1865 | { | ||
| 1866 | newLeafNode(lv_reflexiveTransitiveClosure_2_0, grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0()); | ||
| 1867 | } | ||
| 1868 | { | ||
| 1869 | if ($current==null) { | ||
| 1870 | $current = createModelElement(grammarAccess.getCallRule()); | ||
| 1871 | } | ||
| 1872 | setWithLastConsumed( | ||
| 1873 | $current, | ||
| 1874 | "reflexiveTransitiveClosure", | ||
| 1875 | true, | ||
| 1876 | "org.eclipse.viatra.solver.language.SolverLanguage.PLUS"); | ||
| 1877 | } | ||
| 1878 | ) | ||
| 1879 | ) | ||
| 1880 | )? | ||
| 1881 | ( | ||
| 1882 | ( | ||
| 1883 | { | ||
| 1884 | newCompositeNode(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); | ||
| 1885 | } | ||
| 1886 | lv_argumentList_3_0=ruleArgumentList | ||
| 1887 | { | ||
| 1888 | if ($current==null) { | ||
| 1889 | $current = createModelElementForParent(grammarAccess.getCallRule()); | ||
| 1890 | } | ||
| 1891 | set( | ||
| 1892 | $current, | ||
| 1893 | "argumentList", | ||
| 1894 | lv_argumentList_3_0, | ||
| 1895 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
| 1896 | afterParserOrEnumRuleCall(); | ||
| 1897 | } | ||
| 1898 | ) | ||
| 811 | ) | 1899 | ) |
| 812 | ) | 1900 | ) |
| 813 | ; | 1901 | ; |
| 814 | 1902 | ||
| 815 | // Entry rule entryRuleStringSymbol | 1903 | // Entry rule entryRuleArgumentList |
| 816 | entryRuleStringSymbol returns [EObject current=null]: | 1904 | entryRuleArgumentList returns [EObject current=null]: |
| 817 | { newCompositeNode(grammarAccess.getStringSymbolRule()); } | 1905 | { newCompositeNode(grammarAccess.getArgumentListRule()); } |
| 818 | iv_ruleStringSymbol=ruleStringSymbol | 1906 | iv_ruleArgumentList=ruleArgumentList |
| 819 | { $current=$iv_ruleStringSymbol.current; } | 1907 | { $current=$iv_ruleArgumentList.current; } |
| 820 | EOF; | 1908 | EOF; |
| 821 | 1909 | ||
| 822 | // Rule StringSymbol | 1910 | // Rule ArgumentList |
| 823 | ruleStringSymbol returns [EObject current=null] | 1911 | ruleArgumentList returns [EObject current=null] |
| 824 | @init { | 1912 | @init { |
| 825 | enterRule(); | 1913 | enterRule(); |
| 826 | } | 1914 | } |
| @@ -828,29 +1916,79 @@ ruleStringSymbol returns [EObject current=null] | |||
| 828 | leaveRule(); | 1916 | leaveRule(); |
| 829 | }: | 1917 | }: |
| 830 | ( | 1918 | ( |
| 831 | otherlv_0='string' | ||
| 832 | { | ||
| 833 | newLeafNode(otherlv_0, grammarAccess.getStringSymbolAccess().getStringKeyword_0()); | ||
| 834 | } | ||
| 835 | ( | 1919 | ( |
| 836 | { | 1920 | { |
| 837 | $current = forceCreateModelElement( | 1921 | $current = forceCreateModelElement( |
| 838 | grammarAccess.getStringSymbolAccess().getStringSymbolAction_1(), | 1922 | grammarAccess.getArgumentListAccess().getArgumentListAction_0(), |
| 839 | $current); | 1923 | $current); |
| 840 | } | 1924 | } |
| 841 | ) | 1925 | ) |
| 1926 | otherlv_1='(' | ||
| 1927 | { | ||
| 1928 | newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); | ||
| 1929 | } | ||
| 1930 | ( | ||
| 1931 | ( | ||
| 1932 | ( | ||
| 1933 | { | ||
| 1934 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); | ||
| 1935 | } | ||
| 1936 | lv_arguments_2_0=ruleArgument | ||
| 1937 | { | ||
| 1938 | if ($current==null) { | ||
| 1939 | $current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
| 1940 | } | ||
| 1941 | add( | ||
| 1942 | $current, | ||
| 1943 | "arguments", | ||
| 1944 | lv_arguments_2_0, | ||
| 1945 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
| 1946 | afterParserOrEnumRuleCall(); | ||
| 1947 | } | ||
| 1948 | ) | ||
| 1949 | ) | ||
| 1950 | ( | ||
| 1951 | otherlv_3=',' | ||
| 1952 | { | ||
| 1953 | newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); | ||
| 1954 | } | ||
| 1955 | ( | ||
| 1956 | ( | ||
| 1957 | { | ||
| 1958 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); | ||
| 1959 | } | ||
| 1960 | lv_arguments_4_0=ruleArgument | ||
| 1961 | { | ||
| 1962 | if ($current==null) { | ||
| 1963 | $current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
| 1964 | } | ||
| 1965 | add( | ||
| 1966 | $current, | ||
| 1967 | "arguments", | ||
| 1968 | lv_arguments_4_0, | ||
| 1969 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
| 1970 | afterParserOrEnumRuleCall(); | ||
| 1971 | } | ||
| 1972 | ) | ||
| 1973 | ) | ||
| 1974 | )* | ||
| 1975 | )? | ||
| 1976 | otherlv_5=')' | ||
| 1977 | { | ||
| 1978 | newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); | ||
| 1979 | } | ||
| 842 | ) | 1980 | ) |
| 843 | ; | 1981 | ; |
| 844 | 1982 | ||
| 845 | // Entry rule entryRuleComplexObject | 1983 | // Entry rule entryRuleArgument |
| 846 | entryRuleComplexObject returns [EObject current=null]: | 1984 | entryRuleArgument returns [EObject current=null]: |
| 847 | { newCompositeNode(grammarAccess.getComplexObjectRule()); } | 1985 | { newCompositeNode(grammarAccess.getArgumentRule()); } |
| 848 | iv_ruleComplexObject=ruleComplexObject | 1986 | iv_ruleArgument=ruleArgument |
| 849 | { $current=$iv_ruleComplexObject.current; } | 1987 | { $current=$iv_ruleArgument.current; } |
| 850 | EOF; | 1988 | EOF; |
| 851 | 1989 | ||
| 852 | // Rule ComplexObject | 1990 | // Rule Argument |
| 853 | ruleComplexObject returns [EObject current=null] | 1991 | ruleArgument returns [EObject current=null] |
| 854 | @init { | 1992 | @init { |
| 855 | enterRule(); | 1993 | enterRule(); |
| 856 | } | 1994 | } |
| @@ -859,43 +1997,52 @@ ruleComplexObject returns [EObject current=null] | |||
| 859 | }: | 1997 | }: |
| 860 | ( | 1998 | ( |
| 861 | { | 1999 | { |
| 862 | newCompositeNode(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); | 2000 | newCompositeNode(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); |
| 863 | } | 2001 | } |
| 864 | this_Object_0=ruleObject | 2002 | this_ExpressionArgument_0=ruleExpressionArgument |
| 865 | { | 2003 | { |
| 866 | $current = $this_Object_0.current; | 2004 | $current = $this_ExpressionArgument_0.current; |
| 867 | afterParserOrEnumRuleCall(); | 2005 | afterParserOrEnumRuleCall(); |
| 868 | } | 2006 | } |
| 869 | | | 2007 | | |
| 870 | { | 2008 | { |
| 871 | newCompositeNode(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); | 2009 | newCompositeNode(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); |
| 872 | } | 2010 | } |
| 873 | this_AllInstances_1=ruleAllInstances | 2011 | this_StarArgument_1=ruleStarArgument |
| 874 | { | 2012 | { |
| 875 | $current = $this_AllInstances_1.current; | 2013 | $current = $this_StarArgument_1.current; |
| 876 | afterParserOrEnumRuleCall(); | 2014 | afterParserOrEnumRuleCall(); |
| 877 | } | 2015 | } |
| 878 | | | 2016 | | |
| 879 | { | 2017 | { |
| 880 | newCompositeNode(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); | 2018 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); |
| 881 | } | 2019 | } |
| 882 | this_AllObjects_2=ruleAllObjects | 2020 | this_TypedArgument_2=ruleTypedArgument |
| 883 | { | 2021 | { |
| 884 | $current = $this_AllObjects_2.current; | 2022 | $current = $this_TypedArgument_2.current; |
| 2023 | afterParserOrEnumRuleCall(); | ||
| 2024 | } | ||
| 2025 | | | ||
| 2026 | { | ||
| 2027 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); | ||
| 2028 | } | ||
| 2029 | this_TypedStarArgument_3=ruleTypedStarArgument | ||
| 2030 | { | ||
| 2031 | $current = $this_TypedStarArgument_3.current; | ||
| 885 | afterParserOrEnumRuleCall(); | 2032 | afterParserOrEnumRuleCall(); |
| 886 | } | 2033 | } |
| 887 | ) | 2034 | ) |
| 888 | ; | 2035 | ; |
| 889 | 2036 | ||
| 890 | // Entry rule entryRuleObject | 2037 | // Entry rule entryRuleExpressionArgument |
| 891 | entryRuleObject returns [EObject current=null]: | 2038 | entryRuleExpressionArgument returns [EObject current=null]: |
| 892 | { newCompositeNode(grammarAccess.getObjectRule()); } | 2039 | { newCompositeNode(grammarAccess.getExpressionArgumentRule()); } |
| 893 | iv_ruleObject=ruleObject | 2040 | iv_ruleExpressionArgument=ruleExpressionArgument |
| 894 | { $current=$iv_ruleObject.current; } | 2041 | { $current=$iv_ruleExpressionArgument.current; } |
| 895 | EOF; | 2042 | EOF; |
| 896 | 2043 | ||
| 897 | // Rule Object | 2044 | // Rule ExpressionArgument |
| 898 | ruleObject returns [EObject current=null] | 2045 | ruleExpressionArgument returns [EObject current=null] |
| 899 | @init { | 2046 | @init { |
| 900 | enterRule(); | 2047 | enterRule(); |
| 901 | } | 2048 | } |
| @@ -903,44 +2050,35 @@ ruleObject returns [EObject current=null] | |||
| 903 | leaveRule(); | 2050 | leaveRule(); |
| 904 | }: | 2051 | }: |
| 905 | ( | 2052 | ( |
| 906 | { | 2053 | ( |
| 907 | newCompositeNode(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); | 2054 | { |
| 908 | } | 2055 | newCompositeNode(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); |
| 909 | this_NamedObject_0=ruleNamedObject | 2056 | } |
| 910 | { | 2057 | lv_body_0_0=ruleComparisonExpression |
| 911 | $current = $this_NamedObject_0.current; | 2058 | { |
| 912 | afterParserOrEnumRuleCall(); | 2059 | if ($current==null) { |
| 913 | } | 2060 | $current = createModelElementForParent(grammarAccess.getExpressionArgumentRule()); |
| 914 | | | 2061 | } |
| 915 | { | 2062 | set( |
| 916 | newCompositeNode(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); | 2063 | $current, |
| 917 | } | 2064 | "body", |
| 918 | this_UnnamedObject_1=ruleUnnamedObject | 2065 | lv_body_0_0, |
| 919 | { | 2066 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); |
| 920 | $current = $this_UnnamedObject_1.current; | 2067 | afterParserOrEnumRuleCall(); |
| 921 | afterParserOrEnumRuleCall(); | 2068 | } |
| 922 | } | 2069 | ) |
| 923 | | | ||
| 924 | { | ||
| 925 | newCompositeNode(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); | ||
| 926 | } | ||
| 927 | this_DataObject_2=ruleDataObject | ||
| 928 | { | ||
| 929 | $current = $this_DataObject_2.current; | ||
| 930 | afterParserOrEnumRuleCall(); | ||
| 931 | } | ||
| 932 | ) | 2070 | ) |
| 933 | ; | 2071 | ; |
| 934 | 2072 | ||
| 935 | // Entry rule entryRuleNamedObject | 2073 | // Entry rule entryRuleStarArgument |
| 936 | entryRuleNamedObject returns [EObject current=null]: | 2074 | entryRuleStarArgument returns [EObject current=null]: |
| 937 | { newCompositeNode(grammarAccess.getNamedObjectRule()); } | 2075 | { newCompositeNode(grammarAccess.getStarArgumentRule()); } |
| 938 | iv_ruleNamedObject=ruleNamedObject | 2076 | iv_ruleStarArgument=ruleStarArgument |
| 939 | { $current=$iv_ruleNamedObject.current; } | 2077 | { $current=$iv_ruleStarArgument.current; } |
| 940 | EOF; | 2078 | EOF; |
| 941 | 2079 | ||
| 942 | // Rule NamedObject | 2080 | // Rule StarArgument |
| 943 | ruleNamedObject returns [EObject current=null] | 2081 | ruleStarArgument returns [EObject current=null] |
| 944 | @init { | 2082 | @init { |
| 945 | enterRule(); | 2083 | enterRule(); |
| 946 | } | 2084 | } |
| @@ -948,44 +2086,119 @@ ruleNamedObject returns [EObject current=null] | |||
| 948 | leaveRule(); | 2086 | leaveRule(); |
| 949 | }: | 2087 | }: |
| 950 | ( | 2088 | ( |
| 951 | otherlv_0='\'' | 2089 | ( |
| 2090 | { | ||
| 2091 | $current = forceCreateModelElement( | ||
| 2092 | grammarAccess.getStarArgumentAccess().getStarArgumentAction_0(), | ||
| 2093 | $current); | ||
| 2094 | } | ||
| 2095 | ) | ||
| 2096 | otherlv_1='*' | ||
| 952 | { | 2097 | { |
| 953 | newLeafNode(otherlv_0, grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); | 2098 | newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); |
| 954 | } | 2099 | } |
| 2100 | ) | ||
| 2101 | ; | ||
| 2102 | |||
| 2103 | // Entry rule entryRuleTypedArgument | ||
| 2104 | entryRuleTypedArgument returns [EObject current=null]: | ||
| 2105 | { newCompositeNode(grammarAccess.getTypedArgumentRule()); } | ||
| 2106 | iv_ruleTypedArgument=ruleTypedArgument | ||
| 2107 | { $current=$iv_ruleTypedArgument.current; } | ||
| 2108 | EOF; | ||
| 2109 | |||
| 2110 | // Rule TypedArgument | ||
| 2111 | ruleTypedArgument returns [EObject current=null] | ||
| 2112 | @init { | ||
| 2113 | enterRule(); | ||
| 2114 | } | ||
| 2115 | @after { | ||
| 2116 | leaveRule(); | ||
| 2117 | }: | ||
| 2118 | ( | ||
| 955 | ( | 2119 | ( |
| 956 | ( | 2120 | ( |
| 957 | lv_name_1_0=RULE_ID | ||
| 958 | { | 2121 | { |
| 959 | newLeafNode(lv_name_1_0, grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); | 2122 | if ($current==null) { |
| 2123 | $current = createModelElement(grammarAccess.getTypedArgumentRule()); | ||
| 2124 | } | ||
| 960 | } | 2125 | } |
| 961 | { | 2126 | { |
| 2127 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); | ||
| 2128 | } | ||
| 2129 | ruleQualifiedName | ||
| 2130 | { | ||
| 2131 | afterParserOrEnumRuleCall(); | ||
| 2132 | } | ||
| 2133 | ) | ||
| 2134 | ) | ||
| 2135 | ( | ||
| 2136 | ( | ||
| 2137 | { | ||
| 962 | if ($current==null) { | 2138 | if ($current==null) { |
| 963 | $current = createModelElement(grammarAccess.getNamedObjectRule()); | 2139 | $current = createModelElement(grammarAccess.getTypedArgumentRule()); |
| 964 | } | 2140 | } |
| 965 | setWithLastConsumed( | 2141 | } |
| 966 | $current, | 2142 | { |
| 967 | "name", | 2143 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); |
| 968 | lv_name_1_0, | 2144 | } |
| 969 | "org.eclipse.xtext.common.Terminals.ID"); | 2145 | ruleQualifiedName |
| 2146 | { | ||
| 2147 | afterParserOrEnumRuleCall(); | ||
| 970 | } | 2148 | } |
| 971 | ) | 2149 | ) |
| 972 | ) | 2150 | ) |
| 973 | otherlv_2='\'' | 2151 | ) |
| 2152 | ; | ||
| 2153 | |||
| 2154 | // Entry rule entryRuleTypedStarArgument | ||
| 2155 | entryRuleTypedStarArgument returns [EObject current=null]: | ||
| 2156 | { newCompositeNode(grammarAccess.getTypedStarArgumentRule()); } | ||
| 2157 | iv_ruleTypedStarArgument=ruleTypedStarArgument | ||
| 2158 | { $current=$iv_ruleTypedStarArgument.current; } | ||
| 2159 | EOF; | ||
| 2160 | |||
| 2161 | // Rule TypedStarArgument | ||
| 2162 | ruleTypedStarArgument returns [EObject current=null] | ||
| 2163 | @init { | ||
| 2164 | enterRule(); | ||
| 2165 | } | ||
| 2166 | @after { | ||
| 2167 | leaveRule(); | ||
| 2168 | }: | ||
| 2169 | ( | ||
| 2170 | ( | ||
| 2171 | ( | ||
| 2172 | { | ||
| 2173 | if ($current==null) { | ||
| 2174 | $current = createModelElement(grammarAccess.getTypedStarArgumentRule()); | ||
| 2175 | } | ||
| 2176 | } | ||
| 2177 | { | ||
| 2178 | newCompositeNode(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); | ||
| 2179 | } | ||
| 2180 | ruleQualifiedName | ||
| 2181 | { | ||
| 2182 | afterParserOrEnumRuleCall(); | ||
| 2183 | } | ||
| 2184 | ) | ||
| 2185 | ) | ||
| 2186 | otherlv_1='*' | ||
| 974 | { | 2187 | { |
| 975 | newLeafNode(otherlv_2, grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); | 2188 | newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); |
| 976 | } | 2189 | } |
| 977 | ) | 2190 | ) |
| 978 | ; | 2191 | ; |
| 979 | 2192 | ||
| 980 | // Entry rule entryRuleUnnamedObject | 2193 | // Entry rule entryRuleReference |
| 981 | entryRuleUnnamedObject returns [EObject current=null]: | 2194 | entryRuleReference returns [EObject current=null]: |
| 982 | { newCompositeNode(grammarAccess.getUnnamedObjectRule()); } | 2195 | { newCompositeNode(grammarAccess.getReferenceRule()); } |
| 983 | iv_ruleUnnamedObject=ruleUnnamedObject | 2196 | iv_ruleReference=ruleReference |
| 984 | { $current=$iv_ruleUnnamedObject.current; } | 2197 | { $current=$iv_ruleReference.current; } |
| 985 | EOF; | 2198 | EOF; |
| 986 | 2199 | ||
| 987 | // Rule UnnamedObject | 2200 | // Rule Reference |
| 988 | ruleUnnamedObject returns [EObject current=null] | 2201 | ruleReference returns [EObject current=null] |
| 989 | @init { | 2202 | @init { |
| 990 | enterRule(); | 2203 | enterRule(); |
| 991 | } | 2204 | } |
| @@ -994,33 +2207,31 @@ ruleUnnamedObject returns [EObject current=null] | |||
| 994 | }: | 2207 | }: |
| 995 | ( | 2208 | ( |
| 996 | ( | 2209 | ( |
| 997 | lv_name_0_0=RULE_ID | ||
| 998 | { | ||
| 999 | newLeafNode(lv_name_0_0, grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); | ||
| 1000 | } | ||
| 1001 | { | 2210 | { |
| 1002 | if ($current==null) { | 2211 | if ($current==null) { |
| 1003 | $current = createModelElement(grammarAccess.getUnnamedObjectRule()); | 2212 | $current = createModelElement(grammarAccess.getReferenceRule()); |
| 1004 | } | 2213 | } |
| 1005 | setWithLastConsumed( | 2214 | } |
| 1006 | $current, | 2215 | { |
| 1007 | "name", | 2216 | newCompositeNode(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); |
| 1008 | lv_name_0_0, | 2217 | } |
| 1009 | "org.eclipse.xtext.common.Terminals.ID"); | 2218 | ruleQualifiedName |
| 2219 | { | ||
| 2220 | afterParserOrEnumRuleCall(); | ||
| 1010 | } | 2221 | } |
| 1011 | ) | 2222 | ) |
| 1012 | ) | 2223 | ) |
| 1013 | ; | 2224 | ; |
| 1014 | 2225 | ||
| 1015 | // Entry rule entryRuleDataObject | 2226 | // Entry rule entryRuleInterval |
| 1016 | entryRuleDataObject returns [EObject current=null]: | 2227 | entryRuleInterval returns [EObject current=null]: |
| 1017 | { newCompositeNode(grammarAccess.getDataObjectRule()); } | 2228 | { newCompositeNode(grammarAccess.getIntervalRule()); } |
| 1018 | iv_ruleDataObject=ruleDataObject | 2229 | iv_ruleInterval=ruleInterval |
| 1019 | { $current=$iv_ruleDataObject.current; } | 2230 | { $current=$iv_ruleInterval.current; } |
| 1020 | EOF; | 2231 | EOF; |
| 1021 | 2232 | ||
| 1022 | // Rule DataObject | 2233 | // Rule Interval |
| 1023 | ruleDataObject returns [EObject current=null] | 2234 | ruleInterval returns [EObject current=null] |
| 1024 | @init { | 2235 | @init { |
| 1025 | enterRule(); | 2236 | enterRule(); |
| 1026 | } | 2237 | } |
| @@ -1028,53 +2239,131 @@ ruleDataObject returns [EObject current=null] | |||
| 1028 | leaveRule(); | 2239 | leaveRule(); |
| 1029 | }: | 2240 | }: |
| 1030 | ( | 2241 | ( |
| 2242 | otherlv_0='[' | ||
| 2243 | { | ||
| 2244 | newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); | ||
| 2245 | } | ||
| 2246 | ( | ||
| 2247 | ( | ||
| 2248 | { | ||
| 2249 | newCompositeNode(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); | ||
| 2250 | } | ||
| 2251 | lv_lowerBound_1_0=ruleExpression | ||
| 2252 | { | ||
| 2253 | if ($current==null) { | ||
| 2254 | $current = createModelElementForParent(grammarAccess.getIntervalRule()); | ||
| 2255 | } | ||
| 2256 | set( | ||
| 2257 | $current, | ||
| 2258 | "lowerBound", | ||
| 2259 | lv_lowerBound_1_0, | ||
| 2260 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 2261 | afterParserOrEnumRuleCall(); | ||
| 2262 | } | ||
| 2263 | ) | ||
| 2264 | ) | ||
| 2265 | otherlv_2='..' | ||
| 1031 | { | 2266 | { |
| 1032 | newCompositeNode(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); | 2267 | newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); |
| 1033 | } | 2268 | } |
| 1034 | this_BooleanObject_0=ruleBooleanObject | 2269 | ( |
| 2270 | ( | ||
| 2271 | { | ||
| 2272 | newCompositeNode(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); | ||
| 2273 | } | ||
| 2274 | lv_upperBound_3_0=ruleExpression | ||
| 2275 | { | ||
| 2276 | if ($current==null) { | ||
| 2277 | $current = createModelElementForParent(grammarAccess.getIntervalRule()); | ||
| 2278 | } | ||
| 2279 | set( | ||
| 2280 | $current, | ||
| 2281 | "upperBound", | ||
| 2282 | lv_upperBound_3_0, | ||
| 2283 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 2284 | afterParserOrEnumRuleCall(); | ||
| 2285 | } | ||
| 2286 | ) | ||
| 2287 | ) | ||
| 2288 | otherlv_4=']' | ||
| 1035 | { | 2289 | { |
| 1036 | $current = $this_BooleanObject_0.current; | 2290 | newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); |
| 2291 | } | ||
| 2292 | ) | ||
| 2293 | ; | ||
| 2294 | |||
| 2295 | // Entry rule entryRuleLiteral | ||
| 2296 | entryRuleLiteral returns [EObject current=null]: | ||
| 2297 | { newCompositeNode(grammarAccess.getLiteralRule()); } | ||
| 2298 | iv_ruleLiteral=ruleLiteral | ||
| 2299 | { $current=$iv_ruleLiteral.current; } | ||
| 2300 | EOF; | ||
| 2301 | |||
| 2302 | // Rule Literal | ||
| 2303 | ruleLiteral returns [EObject current=null] | ||
| 2304 | @init { | ||
| 2305 | enterRule(); | ||
| 2306 | } | ||
| 2307 | @after { | ||
| 2308 | leaveRule(); | ||
| 2309 | }: | ||
| 2310 | ( | ||
| 2311 | { | ||
| 2312 | newCompositeNode(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); | ||
| 2313 | } | ||
| 2314 | this_LogicLiteral_0=ruleLogicLiteral | ||
| 2315 | { | ||
| 2316 | $current = $this_LogicLiteral_0.current; | ||
| 2317 | afterParserOrEnumRuleCall(); | ||
| 2318 | } | ||
| 2319 | | | ||
| 2320 | { | ||
| 2321 | newCompositeNode(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); | ||
| 2322 | } | ||
| 2323 | this_NumericLiteral_1=ruleNumericLiteral | ||
| 2324 | { | ||
| 2325 | $current = $this_NumericLiteral_1.current; | ||
| 1037 | afterParserOrEnumRuleCall(); | 2326 | afterParserOrEnumRuleCall(); |
| 1038 | } | 2327 | } |
| 1039 | | | 2328 | | |
| 1040 | { | 2329 | { |
| 1041 | newCompositeNode(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); | 2330 | newCompositeNode(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); |
| 1042 | } | 2331 | } |
| 1043 | this_IntObject_1=ruleIntObject | 2332 | this_InfinityLiteral_2=ruleInfinityLiteral |
| 1044 | { | 2333 | { |
| 1045 | $current = $this_IntObject_1.current; | 2334 | $current = $this_InfinityLiteral_2.current; |
| 1046 | afterParserOrEnumRuleCall(); | 2335 | afterParserOrEnumRuleCall(); |
| 1047 | } | 2336 | } |
| 1048 | | | 2337 | | |
| 1049 | { | 2338 | { |
| 1050 | newCompositeNode(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); | 2339 | newCompositeNode(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); |
| 1051 | } | 2340 | } |
| 1052 | this_RealObject_2=ruleRealObject | 2341 | this_EmptyIntervalLiteral_3=ruleEmptyIntervalLiteral |
| 1053 | { | 2342 | { |
| 1054 | $current = $this_RealObject_2.current; | 2343 | $current = $this_EmptyIntervalLiteral_3.current; |
| 1055 | afterParserOrEnumRuleCall(); | 2344 | afterParserOrEnumRuleCall(); |
| 1056 | } | 2345 | } |
| 1057 | | | 2346 | | |
| 1058 | { | 2347 | { |
| 1059 | newCompositeNode(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); | 2348 | newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); |
| 1060 | } | 2349 | } |
| 1061 | this_StringObject_3=ruleStringObject | 2350 | this_StringLiteral_4=ruleStringLiteral |
| 1062 | { | 2351 | { |
| 1063 | $current = $this_StringObject_3.current; | 2352 | $current = $this_StringLiteral_4.current; |
| 1064 | afterParserOrEnumRuleCall(); | 2353 | afterParserOrEnumRuleCall(); |
| 1065 | } | 2354 | } |
| 1066 | ) | 2355 | ) |
| 1067 | ; | 2356 | ; |
| 1068 | 2357 | ||
| 1069 | // Entry rule entryRuleBooleanObject | 2358 | // Entry rule entryRuleLogicLiteral |
| 1070 | entryRuleBooleanObject returns [EObject current=null]: | 2359 | entryRuleLogicLiteral returns [EObject current=null]: |
| 1071 | { newCompositeNode(grammarAccess.getBooleanObjectRule()); } | 2360 | { newCompositeNode(grammarAccess.getLogicLiteralRule()); } |
| 1072 | iv_ruleBooleanObject=ruleBooleanObject | 2361 | iv_ruleLogicLiteral=ruleLogicLiteral |
| 1073 | { $current=$iv_ruleBooleanObject.current; } | 2362 | { $current=$iv_ruleLogicLiteral.current; } |
| 1074 | EOF; | 2363 | EOF; |
| 1075 | 2364 | ||
| 1076 | // Rule BooleanObject | 2365 | // Rule LogicLiteral |
| 1077 | ruleBooleanObject returns [EObject current=null] | 2366 | ruleLogicLiteral returns [EObject current=null] |
| 1078 | @init { | 2367 | @init { |
| 1079 | enterRule(); | 2368 | enterRule(); |
| 1080 | } | 2369 | } |
| @@ -1084,33 +2373,33 @@ ruleBooleanObject returns [EObject current=null] | |||
| 1084 | ( | 2373 | ( |
| 1085 | ( | 2374 | ( |
| 1086 | { | 2375 | { |
| 1087 | newCompositeNode(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); | 2376 | newCompositeNode(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); |
| 1088 | } | 2377 | } |
| 1089 | lv_value_0_0=ruleBooleanValue | 2378 | lv_value_0_0=ruleLogicValue |
| 1090 | { | 2379 | { |
| 1091 | if ($current==null) { | 2380 | if ($current==null) { |
| 1092 | $current = createModelElementForParent(grammarAccess.getBooleanObjectRule()); | 2381 | $current = createModelElementForParent(grammarAccess.getLogicLiteralRule()); |
| 1093 | } | 2382 | } |
| 1094 | set( | 2383 | set( |
| 1095 | $current, | 2384 | $current, |
| 1096 | "value", | 2385 | "value", |
| 1097 | lv_value_0_0, | 2386 | lv_value_0_0, |
| 1098 | "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue"); | 2387 | "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue"); |
| 1099 | afterParserOrEnumRuleCall(); | 2388 | afterParserOrEnumRuleCall(); |
| 1100 | } | 2389 | } |
| 1101 | ) | 2390 | ) |
| 1102 | ) | 2391 | ) |
| 1103 | ; | 2392 | ; |
| 1104 | 2393 | ||
| 1105 | // Entry rule entryRuleIntObject | 2394 | // Entry rule entryRuleNumericLiteral |
| 1106 | entryRuleIntObject returns [EObject current=null]: | 2395 | entryRuleNumericLiteral returns [EObject current=null]: |
| 1107 | { newCompositeNode(grammarAccess.getIntObjectRule()); } | 2396 | { newCompositeNode(grammarAccess.getNumericLiteralRule()); } |
| 1108 | iv_ruleIntObject=ruleIntObject | 2397 | iv_ruleNumericLiteral=ruleNumericLiteral |
| 1109 | { $current=$iv_ruleIntObject.current; } | 2398 | { $current=$iv_ruleNumericLiteral.current; } |
| 1110 | EOF; | 2399 | EOF; |
| 1111 | 2400 | ||
| 1112 | // Rule IntObject | 2401 | // Rule NumericLiteral |
| 1113 | ruleIntObject returns [EObject current=null] | 2402 | ruleNumericLiteral returns [EObject current=null] |
| 1114 | @init { | 2403 | @init { |
| 1115 | enterRule(); | 2404 | enterRule(); |
| 1116 | } | 2405 | } |
| @@ -1120,33 +2409,33 @@ ruleIntObject returns [EObject current=null] | |||
| 1120 | ( | 2409 | ( |
| 1121 | ( | 2410 | ( |
| 1122 | { | 2411 | { |
| 1123 | newCompositeNode(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); | 2412 | newCompositeNode(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); |
| 1124 | } | 2413 | } |
| 1125 | lv_value_0_0=ruleINTLiteral | 2414 | lv_value_0_0=ruleReal |
| 1126 | { | 2415 | { |
| 1127 | if ($current==null) { | 2416 | if ($current==null) { |
| 1128 | $current = createModelElementForParent(grammarAccess.getIntObjectRule()); | 2417 | $current = createModelElementForParent(grammarAccess.getNumericLiteralRule()); |
| 1129 | } | 2418 | } |
| 1130 | set( | 2419 | set( |
| 1131 | $current, | 2420 | $current, |
| 1132 | "value", | 2421 | "value", |
| 1133 | lv_value_0_0, | 2422 | lv_value_0_0, |
| 1134 | "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral"); | 2423 | "org.eclipse.viatra.solver.language.SolverLanguage.Real"); |
| 1135 | afterParserOrEnumRuleCall(); | 2424 | afterParserOrEnumRuleCall(); |
| 1136 | } | 2425 | } |
| 1137 | ) | 2426 | ) |
| 1138 | ) | 2427 | ) |
| 1139 | ; | 2428 | ; |
| 1140 | 2429 | ||
| 1141 | // Entry rule entryRuleRealObject | 2430 | // Entry rule entryRuleInfinityLiteral |
| 1142 | entryRuleRealObject returns [EObject current=null]: | 2431 | entryRuleInfinityLiteral returns [EObject current=null]: |
| 1143 | { newCompositeNode(grammarAccess.getRealObjectRule()); } | 2432 | { newCompositeNode(grammarAccess.getInfinityLiteralRule()); } |
| 1144 | iv_ruleRealObject=ruleRealObject | 2433 | iv_ruleInfinityLiteral=ruleInfinityLiteral |
| 1145 | { $current=$iv_ruleRealObject.current; } | 2434 | { $current=$iv_ruleInfinityLiteral.current; } |
| 1146 | EOF; | 2435 | EOF; |
| 1147 | 2436 | ||
| 1148 | // Rule RealObject | 2437 | // Rule InfinityLiteral |
| 1149 | ruleRealObject returns [EObject current=null] | 2438 | ruleInfinityLiteral returns [EObject current=null] |
| 1150 | @init { | 2439 | @init { |
| 1151 | enterRule(); | 2440 | enterRule(); |
| 1152 | } | 2441 | } |
| @@ -1156,33 +2445,57 @@ ruleRealObject returns [EObject current=null] | |||
| 1156 | ( | 2445 | ( |
| 1157 | ( | 2446 | ( |
| 1158 | { | 2447 | { |
| 1159 | newCompositeNode(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); | 2448 | $current = forceCreateModelElement( |
| 2449 | grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0(), | ||
| 2450 | $current); | ||
| 1160 | } | 2451 | } |
| 1161 | lv_value_0_0=ruleREALLiteral | 2452 | ) |
| 2453 | otherlv_1='inf' | ||
| 2454 | { | ||
| 2455 | newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); | ||
| 2456 | } | ||
| 2457 | ) | ||
| 2458 | ; | ||
| 2459 | |||
| 2460 | // Entry rule entryRuleEmptyIntervalLiteral | ||
| 2461 | entryRuleEmptyIntervalLiteral returns [EObject current=null]: | ||
| 2462 | { newCompositeNode(grammarAccess.getEmptyIntervalLiteralRule()); } | ||
| 2463 | iv_ruleEmptyIntervalLiteral=ruleEmptyIntervalLiteral | ||
| 2464 | { $current=$iv_ruleEmptyIntervalLiteral.current; } | ||
| 2465 | EOF; | ||
| 2466 | |||
| 2467 | // Rule EmptyIntervalLiteral | ||
| 2468 | ruleEmptyIntervalLiteral returns [EObject current=null] | ||
| 2469 | @init { | ||
| 2470 | enterRule(); | ||
| 2471 | } | ||
| 2472 | @after { | ||
| 2473 | leaveRule(); | ||
| 2474 | }: | ||
| 2475 | ( | ||
| 2476 | ( | ||
| 1162 | { | 2477 | { |
| 1163 | if ($current==null) { | 2478 | $current = forceCreateModelElement( |
| 1164 | $current = createModelElementForParent(grammarAccess.getRealObjectRule()); | 2479 | grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0(), |
| 1165 | } | 2480 | $current); |
| 1166 | set( | ||
| 1167 | $current, | ||
| 1168 | "value", | ||
| 1169 | lv_value_0_0, | ||
| 1170 | "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral"); | ||
| 1171 | afterParserOrEnumRuleCall(); | ||
| 1172 | } | 2481 | } |
| 1173 | ) | 2482 | ) |
| 2483 | otherlv_1='empty' | ||
| 2484 | { | ||
| 2485 | newLeafNode(otherlv_1, grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); | ||
| 2486 | } | ||
| 1174 | ) | 2487 | ) |
| 1175 | ; | 2488 | ; |
| 1176 | 2489 | ||
| 1177 | // Entry rule entryRuleStringObject | 2490 | // Entry rule entryRuleStringLiteral |
| 1178 | entryRuleStringObject returns [EObject current=null]: | 2491 | entryRuleStringLiteral returns [EObject current=null]: |
| 1179 | { newCompositeNode(grammarAccess.getStringObjectRule()); } | 2492 | { newCompositeNode(grammarAccess.getStringLiteralRule()); } |
| 1180 | iv_ruleStringObject=ruleStringObject | 2493 | iv_ruleStringLiteral=ruleStringLiteral |
| 1181 | { $current=$iv_ruleStringObject.current; } | 2494 | { $current=$iv_ruleStringLiteral.current; } |
| 1182 | EOF; | 2495 | EOF; |
| 1183 | 2496 | ||
| 1184 | // Rule StringObject | 2497 | // Rule StringLiteral |
| 1185 | ruleStringObject returns [EObject current=null] | 2498 | ruleStringLiteral returns [EObject current=null] |
| 1186 | @init { | 2499 | @init { |
| 1187 | enterRule(); | 2500 | enterRule(); |
| 1188 | } | 2501 | } |
| @@ -1193,11 +2506,11 @@ ruleStringObject returns [EObject current=null] | |||
| 1193 | ( | 2506 | ( |
| 1194 | lv_value_0_0=RULE_STRING | 2507 | lv_value_0_0=RULE_STRING |
| 1195 | { | 2508 | { |
| 1196 | newLeafNode(lv_value_0_0, grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); | 2509 | newLeafNode(lv_value_0_0, grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); |
| 1197 | } | 2510 | } |
| 1198 | { | 2511 | { |
| 1199 | if ($current==null) { | 2512 | if ($current==null) { |
| 1200 | $current = createModelElement(grammarAccess.getStringObjectRule()); | 2513 | $current = createModelElement(grammarAccess.getStringLiteralRule()); |
| 1201 | } | 2514 | } |
| 1202 | setWithLastConsumed( | 2515 | setWithLastConsumed( |
| 1203 | $current, | 2516 | $current, |
| @@ -1209,15 +2522,15 @@ ruleStringObject returns [EObject current=null] | |||
| 1209 | ) | 2522 | ) |
| 1210 | ; | 2523 | ; |
| 1211 | 2524 | ||
| 1212 | // Entry rule entryRulePredicate | 2525 | // Entry rule entryRuleClassDefinition |
| 1213 | entryRulePredicate returns [EObject current=null]: | 2526 | entryRuleClassDefinition returns [EObject current=null]: |
| 1214 | { newCompositeNode(grammarAccess.getPredicateRule()); } | 2527 | { newCompositeNode(grammarAccess.getClassDefinitionRule()); } |
| 1215 | iv_rulePredicate=rulePredicate | 2528 | iv_ruleClassDefinition=ruleClassDefinition |
| 1216 | { $current=$iv_rulePredicate.current; } | 2529 | { $current=$iv_ruleClassDefinition.current; } |
| 1217 | EOF; | 2530 | EOF; |
| 1218 | 2531 | ||
| 1219 | // Rule Predicate | 2532 | // Rule ClassDefinition |
| 1220 | rulePredicate returns [EObject current=null] | 2533 | ruleClassDefinition returns [EObject current=null] |
| 1221 | @init { | 2534 | @init { |
| 1222 | enterRule(); | 2535 | enterRule(); |
| 1223 | } | 2536 | } |
| @@ -1227,166 +2540,123 @@ rulePredicate returns [EObject current=null] | |||
| 1227 | ( | 2540 | ( |
| 1228 | ( | 2541 | ( |
| 1229 | ( | 2542 | ( |
| 1230 | lv_isError_0_0='error' | 2543 | lv_abstract_0_0='abstract' |
| 1231 | { | 2544 | { |
| 1232 | newLeafNode(lv_isError_0_0, grammarAccess.getPredicateAccess().getIsErrorErrorKeyword_0_0()); | 2545 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); |
| 1233 | } | 2546 | } |
| 1234 | { | 2547 | { |
| 1235 | if ($current==null) { | 2548 | if ($current==null) { |
| 1236 | $current = createModelElement(grammarAccess.getPredicateRule()); | 2549 | $current = createModelElement(grammarAccess.getClassDefinitionRule()); |
| 1237 | } | 2550 | } |
| 1238 | setWithLastConsumed($current, "isError", true, "error"); | 2551 | setWithLastConsumed($current, "abstract", true, "abstract"); |
| 1239 | } | 2552 | } |
| 1240 | ) | 2553 | ) |
| 1241 | )? | 2554 | )? |
| 2555 | otherlv_1='class' | ||
| 2556 | { | ||
| 2557 | newLeafNode(otherlv_1, grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); | ||
| 2558 | } | ||
| 1242 | ( | 2559 | ( |
| 1243 | ( | 2560 | ( |
| 2561 | lv_name_2_0=RULE_ID | ||
| 1244 | { | 2562 | { |
| 1245 | newCompositeNode(grammarAccess.getPredicateAccess().getSymbolModelSymbolParserRuleCall_1_0()); | 2563 | newLeafNode(lv_name_2_0, grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); |
| 1246 | } | 2564 | } |
| 1247 | lv_symbol_1_0=ruleModelSymbol | ||
| 1248 | { | 2565 | { |
| 1249 | if ($current==null) { | 2566 | if ($current==null) { |
| 1250 | $current = createModelElementForParent(grammarAccess.getPredicateRule()); | 2567 | $current = createModelElement(grammarAccess.getClassDefinitionRule()); |
| 1251 | } | 2568 | } |
| 1252 | set( | 2569 | setWithLastConsumed( |
| 1253 | $current, | 2570 | $current, |
| 1254 | "symbol", | 2571 | "name", |
| 1255 | lv_symbol_1_0, | 2572 | lv_name_2_0, |
| 1256 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | 2573 | "org.eclipse.xtext.common.Terminals.ID"); |
| 1257 | afterParserOrEnumRuleCall(); | ||
| 1258 | } | 2574 | } |
| 1259 | ) | 2575 | ) |
| 1260 | ) | 2576 | ) |
| 1261 | ( | 2577 | ( |
| 1262 | otherlv_2='(' | 2578 | otherlv_3='extends' |
| 1263 | { | 2579 | { |
| 1264 | newLeafNode(otherlv_2, grammarAccess.getPredicateAccess().getLeftParenthesisKeyword_2_0()); | 2580 | newLeafNode(otherlv_3, grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); |
| 1265 | } | 2581 | } |
| 1266 | ( | 2582 | ( |
| 1267 | ( | 2583 | ( |
| 1268 | ( | 2584 | { |
| 1269 | { | 2585 | if ($current==null) { |
| 1270 | newCompositeNode(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_0_0()); | 2586 | $current = createModelElement(grammarAccess.getClassDefinitionRule()); |
| 1271 | } | ||
| 1272 | lv_parameters_3_0=ruleParameter | ||
| 1273 | { | ||
| 1274 | if ($current==null) { | ||
| 1275 | $current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 1276 | } | ||
| 1277 | add( | ||
| 1278 | $current, | ||
| 1279 | "parameters", | ||
| 1280 | lv_parameters_3_0, | ||
| 1281 | "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | ||
| 1282 | afterParserOrEnumRuleCall(); | ||
| 1283 | } | 2587 | } |
| 1284 | ) | 2588 | } |
| 1285 | ) | ||
| 1286 | ( | ||
| 1287 | otherlv_4=',' | ||
| 1288 | { | 2589 | { |
| 1289 | newLeafNode(otherlv_4, grammarAccess.getPredicateAccess().getCommaKeyword_2_1_1_0()); | 2590 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); |
| 1290 | } | 2591 | } |
| 1291 | ( | 2592 | ruleQualifiedName |
| 1292 | ( | 2593 | { |
| 1293 | { | 2594 | afterParserOrEnumRuleCall(); |
| 1294 | newCompositeNode(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_1_1_0()); | 2595 | } |
| 1295 | } | 2596 | ) |
| 1296 | lv_parameters_5_0=ruleParameter | 2597 | ) |
| 1297 | { | ||
| 1298 | if ($current==null) { | ||
| 1299 | $current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 1300 | } | ||
| 1301 | add( | ||
| 1302 | $current, | ||
| 1303 | "parameters", | ||
| 1304 | lv_parameters_5_0, | ||
| 1305 | "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | ||
| 1306 | afterParserOrEnumRuleCall(); | ||
| 1307 | } | ||
| 1308 | ) | ||
| 1309 | ) | ||
| 1310 | )* | ||
| 1311 | )? | ||
| 1312 | otherlv_6=')' | ||
| 1313 | { | ||
| 1314 | newLeafNode(otherlv_6, grammarAccess.getPredicateAccess().getRightParenthesisKeyword_2_2()); | ||
| 1315 | } | ||
| 1316 | )? | ||
| 1317 | otherlv_7=':-' | ||
| 1318 | { | ||
| 1319 | newLeafNode(otherlv_7, grammarAccess.getPredicateAccess().getColonHyphenMinusKeyword_3()); | ||
| 1320 | } | ||
| 1321 | ( | ||
| 1322 | otherlv_8='false' | ||
| 1323 | { | ||
| 1324 | newLeafNode(otherlv_8, grammarAccess.getPredicateAccess().getFalseKeyword_4_0()); | ||
| 1325 | } | ||
| 1326 | | | ||
| 1327 | ( | 2598 | ( |
| 2599 | otherlv_5=',' | ||
| 2600 | { | ||
| 2601 | newLeafNode(otherlv_5, grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); | ||
| 2602 | } | ||
| 1328 | ( | 2603 | ( |
| 1329 | ( | 2604 | ( |
| 1330 | { | 2605 | { |
| 1331 | newCompositeNode(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_0_0()); | ||
| 1332 | } | ||
| 1333 | lv_bodies_9_0=rulePatternBody | ||
| 1334 | { | ||
| 1335 | if ($current==null) { | 2606 | if ($current==null) { |
| 1336 | $current = createModelElementForParent(grammarAccess.getPredicateRule()); | 2607 | $current = createModelElement(grammarAccess.getClassDefinitionRule()); |
| 1337 | } | 2608 | } |
| 1338 | add( | 2609 | } |
| 1339 | $current, | 2610 | { |
| 1340 | "bodies", | 2611 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); |
| 1341 | lv_bodies_9_0, | 2612 | } |
| 1342 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | 2613 | ruleQualifiedName |
| 2614 | { | ||
| 1343 | afterParserOrEnumRuleCall(); | 2615 | afterParserOrEnumRuleCall(); |
| 1344 | } | 2616 | } |
| 1345 | ) | 2617 | ) |
| 1346 | ) | 2618 | ) |
| 1347 | ( | 2619 | )* |
| 1348 | otherlv_10='|' | 2620 | )? |
| 1349 | { | 2621 | otherlv_7='{' |
| 1350 | newLeafNode(otherlv_10, grammarAccess.getPredicateAccess().getVerticalLineKeyword_4_1_1_0()); | 2622 | { |
| 2623 | newLeafNode(otherlv_7, grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); | ||
| 2624 | } | ||
| 2625 | ( | ||
| 2626 | ( | ||
| 2627 | { | ||
| 2628 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); | ||
| 2629 | } | ||
| 2630 | lv_members_8_0=ruleMemberDefinition | ||
| 2631 | { | ||
| 2632 | if ($current==null) { | ||
| 2633 | $current = createModelElementForParent(grammarAccess.getClassDefinitionRule()); | ||
| 1351 | } | 2634 | } |
| 1352 | ( | 2635 | add( |
| 1353 | ( | 2636 | $current, |
| 1354 | { | 2637 | "members", |
| 1355 | newCompositeNode(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_1_1_0()); | 2638 | lv_members_8_0, |
| 1356 | } | 2639 | "org.eclipse.viatra.solver.language.SolverLanguage.MemberDefinition"); |
| 1357 | lv_bodies_11_0=rulePatternBody | 2640 | afterParserOrEnumRuleCall(); |
| 1358 | { | 2641 | } |
| 1359 | if ($current==null) { | ||
| 1360 | $current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 1361 | } | ||
| 1362 | add( | ||
| 1363 | $current, | ||
| 1364 | "bodies", | ||
| 1365 | lv_bodies_11_0, | ||
| 1366 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | ||
| 1367 | afterParserOrEnumRuleCall(); | ||
| 1368 | } | ||
| 1369 | ) | ||
| 1370 | ) | ||
| 1371 | )* | ||
| 1372 | ) | 2642 | ) |
| 1373 | ) | 2643 | )* |
| 1374 | otherlv_12='.' | 2644 | otherlv_9='}' |
| 1375 | { | 2645 | { |
| 1376 | newLeafNode(otherlv_12, grammarAccess.getPredicateAccess().getFullStopKeyword_5()); | 2646 | newLeafNode(otherlv_9, grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); |
| 1377 | } | 2647 | } |
| 1378 | ) | 2648 | ) |
| 1379 | ; | 2649 | ; |
| 1380 | 2650 | ||
| 1381 | // Entry rule entryRuleParameter | 2651 | // Entry rule entryRuleMemberDefinition |
| 1382 | entryRuleParameter returns [EObject current=null]: | 2652 | entryRuleMemberDefinition returns [EObject current=null]: |
| 1383 | { newCompositeNode(grammarAccess.getParameterRule()); } | 2653 | { newCompositeNode(grammarAccess.getMemberDefinitionRule()); } |
| 1384 | iv_ruleParameter=ruleParameter | 2654 | iv_ruleMemberDefinition=ruleMemberDefinition |
| 1385 | { $current=$iv_ruleParameter.current; } | 2655 | { $current=$iv_ruleMemberDefinition.current; } |
| 1386 | EOF; | 2656 | EOF; |
| 1387 | 2657 | ||
| 1388 | // Rule Parameter | 2658 | // Rule MemberDefinition |
| 1389 | ruleParameter returns [EObject current=null] | 2659 | ruleMemberDefinition returns [EObject current=null] |
| 1390 | @init { | 2660 | @init { |
| 1391 | enterRule(); | 2661 | enterRule(); |
| 1392 | } | 2662 | } |
| @@ -1396,60 +2666,156 @@ ruleParameter returns [EObject current=null] | |||
| 1396 | ( | 2666 | ( |
| 1397 | ( | 2667 | ( |
| 1398 | ( | 2668 | ( |
| 2669 | lv_containment_0_0='contains' | ||
| 2670 | { | ||
| 2671 | newLeafNode(lv_containment_0_0, grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); | ||
| 2672 | } | ||
| 1399 | { | 2673 | { |
| 1400 | newCompositeNode(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); | 2674 | if ($current==null) { |
| 2675 | $current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 2676 | } | ||
| 2677 | setWithLastConsumed($current, "containment", true, "contains"); | ||
| 1401 | } | 2678 | } |
| 1402 | lv_variable_0_0=ruleVariable | 2679 | ) |
| 2680 | )? | ||
| 2681 | ( | ||
| 2682 | ( | ||
| 1403 | { | 2683 | { |
| 1404 | if ($current==null) { | 2684 | if ($current==null) { |
| 1405 | $current = createModelElementForParent(grammarAccess.getParameterRule()); | 2685 | $current = createModelElement(grammarAccess.getMemberDefinitionRule()); |
| 2686 | } | ||
| 2687 | } | ||
| 2688 | { | ||
| 2689 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | ||
| 2690 | } | ||
| 2691 | ruleQualifiedName | ||
| 2692 | { | ||
| 2693 | afterParserOrEnumRuleCall(); | ||
| 2694 | } | ||
| 2695 | ) | ||
| 2696 | ) | ||
| 2697 | ( | ||
| 2698 | ( | ||
| 2699 | { | ||
| 2700 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); | ||
| 2701 | } | ||
| 2702 | lv_multiplicity_2_0=ruleMultiplicity | ||
| 2703 | { | ||
| 2704 | if ($current==null) { | ||
| 2705 | $current = createModelElementForParent(grammarAccess.getMemberDefinitionRule()); | ||
| 1406 | } | 2706 | } |
| 1407 | set( | 2707 | set( |
| 1408 | $current, | 2708 | $current, |
| 1409 | "variable", | 2709 | "multiplicity", |
| 1410 | lv_variable_0_0, | 2710 | lv_multiplicity_2_0, |
| 1411 | "org.eclipse.viatra.solver.language.SolverLanguage.Variable"); | 2711 | "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity"); |
| 1412 | afterParserOrEnumRuleCall(); | 2712 | afterParserOrEnumRuleCall(); |
| 1413 | } | 2713 | } |
| 1414 | ) | 2714 | ) |
| 2715 | )? | ||
| 2716 | ( | ||
| 2717 | ( | ||
| 2718 | lv_name_3_0=RULE_ID | ||
| 2719 | { | ||
| 2720 | newLeafNode(lv_name_3_0, grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); | ||
| 2721 | } | ||
| 2722 | { | ||
| 2723 | if ($current==null) { | ||
| 2724 | $current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 2725 | } | ||
| 2726 | setWithLastConsumed( | ||
| 2727 | $current, | ||
| 2728 | "name", | ||
| 2729 | lv_name_3_0, | ||
| 2730 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 2731 | } | ||
| 2732 | ) | ||
| 1415 | ) | 2733 | ) |
| 1416 | ( | 2734 | ( |
| 1417 | otherlv_1=':' | 2735 | otherlv_4='opposite' |
| 1418 | { | 2736 | { |
| 1419 | newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getColonKeyword_1_0()); | 2737 | newLeafNode(otherlv_4, grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); |
| 1420 | } | 2738 | } |
| 1421 | ( | 2739 | ( |
| 1422 | ( | 2740 | ( |
| 1423 | { | 2741 | { |
| 1424 | newCompositeNode(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); | ||
| 1425 | } | ||
| 1426 | lv_type_2_0=ruleSymbol | ||
| 1427 | { | ||
| 1428 | if ($current==null) { | 2742 | if ($current==null) { |
| 1429 | $current = createModelElementForParent(grammarAccess.getParameterRule()); | 2743 | $current = createModelElement(grammarAccess.getMemberDefinitionRule()); |
| 1430 | } | 2744 | } |
| 1431 | set( | 2745 | } |
| 1432 | $current, | 2746 | { |
| 1433 | "type", | 2747 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); |
| 1434 | lv_type_2_0, | 2748 | } |
| 1435 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | 2749 | ruleQualifiedName |
| 2750 | { | ||
| 1436 | afterParserOrEnumRuleCall(); | 2751 | afterParserOrEnumRuleCall(); |
| 1437 | } | 2752 | } |
| 1438 | ) | 2753 | ) |
| 1439 | ) | 2754 | ) |
| 1440 | )? | 2755 | )? |
| 2756 | ( | ||
| 2757 | otherlv_6=';' | ||
| 2758 | { | ||
| 2759 | newLeafNode(otherlv_6, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); | ||
| 2760 | } | ||
| 2761 | )? | ||
| 1441 | ) | 2762 | ) |
| 1442 | ; | 2763 | ; |
| 1443 | 2764 | ||
| 1444 | // Entry rule entryRulePatternBody | 2765 | // Entry rule entryRuleMultiplicity |
| 1445 | entryRulePatternBody returns [EObject current=null]: | 2766 | entryRuleMultiplicity returns [EObject current=null]: |
| 1446 | { newCompositeNode(grammarAccess.getPatternBodyRule()); } | 2767 | { newCompositeNode(grammarAccess.getMultiplicityRule()); } |
| 1447 | iv_rulePatternBody=rulePatternBody | 2768 | iv_ruleMultiplicity=ruleMultiplicity |
| 1448 | { $current=$iv_rulePatternBody.current; } | 2769 | { $current=$iv_ruleMultiplicity.current; } |
| 1449 | EOF; | 2770 | EOF; |
| 1450 | 2771 | ||
| 1451 | // Rule PatternBody | 2772 | // Rule Multiplicity |
| 1452 | rulePatternBody returns [EObject current=null] | 2773 | ruleMultiplicity returns [EObject current=null] |
| 2774 | @init { | ||
| 2775 | enterRule(); | ||
| 2776 | } | ||
| 2777 | @after { | ||
| 2778 | leaveRule(); | ||
| 2779 | }: | ||
| 2780 | ( | ||
| 2781 | { | ||
| 2782 | newCompositeNode(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); | ||
| 2783 | } | ||
| 2784 | this_ManyMultiplicity_0=ruleManyMultiplicity | ||
| 2785 | { | ||
| 2786 | $current = $this_ManyMultiplicity_0.current; | ||
| 2787 | afterParserOrEnumRuleCall(); | ||
| 2788 | } | ||
| 2789 | | | ||
| 2790 | { | ||
| 2791 | newCompositeNode(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); | ||
| 2792 | } | ||
| 2793 | this_ExactMultiplicity_1=ruleExactMultiplicity | ||
| 2794 | { | ||
| 2795 | $current = $this_ExactMultiplicity_1.current; | ||
| 2796 | afterParserOrEnumRuleCall(); | ||
| 2797 | } | ||
| 2798 | | | ||
| 2799 | { | ||
| 2800 | newCompositeNode(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); | ||
| 2801 | } | ||
| 2802 | this_BoundedMultiplicity_2=ruleBoundedMultiplicity | ||
| 2803 | { | ||
| 2804 | $current = $this_BoundedMultiplicity_2.current; | ||
| 2805 | afterParserOrEnumRuleCall(); | ||
| 2806 | } | ||
| 2807 | ) | ||
| 2808 | ; | ||
| 2809 | |||
| 2810 | // Entry rule entryRuleManyMultiplicity | ||
| 2811 | entryRuleManyMultiplicity returns [EObject current=null]: | ||
| 2812 | { newCompositeNode(grammarAccess.getManyMultiplicityRule()); } | ||
| 2813 | iv_ruleManyMultiplicity=ruleManyMultiplicity | ||
| 2814 | { $current=$iv_ruleManyMultiplicity.current; } | ||
| 2815 | EOF; | ||
| 2816 | |||
| 2817 | // Rule ManyMultiplicity | ||
| 2818 | ruleManyMultiplicity returns [EObject current=null] | ||
| 1453 | @init { | 2819 | @init { |
| 1454 | enterRule(); | 2820 | enterRule(); |
| 1455 | } | 2821 | } |
| @@ -1460,48 +2826,76 @@ rulePatternBody returns [EObject current=null] | |||
| 1460 | ( | 2826 | ( |
| 1461 | { | 2827 | { |
| 1462 | $current = forceCreateModelElement( | 2828 | $current = forceCreateModelElement( |
| 1463 | grammarAccess.getPatternBodyAccess().getPatternBodyAction_0(), | 2829 | grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0(), |
| 1464 | $current); | 2830 | $current); |
| 1465 | } | 2831 | } |
| 1466 | ) | 2832 | ) |
| 2833 | otherlv_1='[' | ||
| 2834 | { | ||
| 2835 | newLeafNode(otherlv_1, grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); | ||
| 2836 | } | ||
| 2837 | otherlv_2=']' | ||
| 2838 | { | ||
| 2839 | newLeafNode(otherlv_2, grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
| 2840 | } | ||
| 2841 | ) | ||
| 2842 | ; | ||
| 2843 | |||
| 2844 | // Entry rule entryRuleExactMultiplicity | ||
| 2845 | entryRuleExactMultiplicity returns [EObject current=null]: | ||
| 2846 | { newCompositeNode(grammarAccess.getExactMultiplicityRule()); } | ||
| 2847 | iv_ruleExactMultiplicity=ruleExactMultiplicity | ||
| 2848 | { $current=$iv_ruleExactMultiplicity.current; } | ||
| 2849 | EOF; | ||
| 2850 | |||
| 2851 | // Rule ExactMultiplicity | ||
| 2852 | ruleExactMultiplicity returns [EObject current=null] | ||
| 2853 | @init { | ||
| 2854 | enterRule(); | ||
| 2855 | } | ||
| 2856 | @after { | ||
| 2857 | leaveRule(); | ||
| 2858 | }: | ||
| 2859 | ( | ||
| 2860 | otherlv_0='[' | ||
| 2861 | { | ||
| 2862 | newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
| 2863 | } | ||
| 1467 | ( | 2864 | ( |
| 1468 | otherlv_1='true' | ||
| 1469 | { | ||
| 1470 | newLeafNode(otherlv_1, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); | ||
| 1471 | } | ||
| 1472 | | | ||
| 1473 | ( | 2865 | ( |
| 1474 | ( | 2866 | { |
| 1475 | { | 2867 | newCompositeNode(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); |
| 1476 | newCompositeNode(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); | 2868 | } |
| 1477 | } | 2869 | lv_multiplicity_1_0=ruleUpperMultiplicty |
| 1478 | lv_constraints_2_0=ruleConstraint | 2870 | { |
| 1479 | { | 2871 | if ($current==null) { |
| 1480 | if ($current==null) { | 2872 | $current = createModelElementForParent(grammarAccess.getExactMultiplicityRule()); |
| 1481 | $current = createModelElementForParent(grammarAccess.getPatternBodyRule()); | ||
| 1482 | } | ||
| 1483 | add( | ||
| 1484 | $current, | ||
| 1485 | "constraints", | ||
| 1486 | lv_constraints_2_0, | ||
| 1487 | "org.eclipse.viatra.solver.language.SolverLanguage.Constraint"); | ||
| 1488 | afterParserOrEnumRuleCall(); | ||
| 1489 | } | 2873 | } |
| 1490 | ) | 2874 | set( |
| 1491 | )* | 2875 | $current, |
| 2876 | "multiplicity", | ||
| 2877 | lv_multiplicity_1_0, | ||
| 2878 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
| 2879 | afterParserOrEnumRuleCall(); | ||
| 2880 | } | ||
| 2881 | ) | ||
| 1492 | ) | 2882 | ) |
| 2883 | otherlv_2=']' | ||
| 2884 | { | ||
| 2885 | newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
| 2886 | } | ||
| 1493 | ) | 2887 | ) |
| 1494 | ; | 2888 | ; |
| 1495 | 2889 | ||
| 1496 | // Entry rule entryRulePolarity | 2890 | // Entry rule entryRuleBoundedMultiplicity |
| 1497 | entryRulePolarity returns [EObject current=null]: | 2891 | entryRuleBoundedMultiplicity returns [EObject current=null]: |
| 1498 | { newCompositeNode(grammarAccess.getPolarityRule()); } | 2892 | { newCompositeNode(grammarAccess.getBoundedMultiplicityRule()); } |
| 1499 | iv_rulePolarity=rulePolarity | 2893 | iv_ruleBoundedMultiplicity=ruleBoundedMultiplicity |
| 1500 | { $current=$iv_rulePolarity.current; } | 2894 | { $current=$iv_ruleBoundedMultiplicity.current; } |
| 1501 | EOF; | 2895 | EOF; |
| 1502 | 2896 | ||
| 1503 | // Rule Polarity | 2897 | // Rule BoundedMultiplicity |
| 1504 | rulePolarity returns [EObject current=null] | 2898 | ruleBoundedMultiplicity returns [EObject current=null] |
| 1505 | @init { | 2899 | @init { |
| 1506 | enterRule(); | 2900 | enterRule(); |
| 1507 | } | 2901 | } |
| @@ -1509,45 +2903,173 @@ rulePolarity returns [EObject current=null] | |||
| 1509 | leaveRule(); | 2903 | leaveRule(); |
| 1510 | }: | 2904 | }: |
| 1511 | ( | 2905 | ( |
| 2906 | otherlv_0='[' | ||
| 2907 | { | ||
| 2908 | newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
| 2909 | } | ||
| 1512 | ( | 2910 | ( |
| 1513 | ( | 2911 | ( |
| 2912 | lv_lowerBound_1_0=RULE_INT | ||
| 1514 | { | 2913 | { |
| 1515 | $current = forceCreateModelElement( | 2914 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); |
| 1516 | grammarAccess.getPolarityAccess().getPositiveAction_0_0(), | 2915 | } |
| 1517 | $current); | 2916 | { |
| 2917 | if ($current==null) { | ||
| 2918 | $current = createModelElement(grammarAccess.getBoundedMultiplicityRule()); | ||
| 2919 | } | ||
| 2920 | setWithLastConsumed( | ||
| 2921 | $current, | ||
| 2922 | "lowerBound", | ||
| 2923 | lv_lowerBound_1_0, | ||
| 2924 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 1518 | } | 2925 | } |
| 1519 | ) | 2926 | ) |
| 1520 | otherlv_1='+' | ||
| 1521 | { | ||
| 1522 | newLeafNode(otherlv_1, grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); | ||
| 1523 | } | ||
| 1524 | ) | 2927 | ) |
| 2928 | otherlv_2='..' | ||
| 2929 | { | ||
| 2930 | newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); | ||
| 2931 | } | ||
| 2932 | ( | ||
| 2933 | ( | ||
| 2934 | { | ||
| 2935 | newCompositeNode(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); | ||
| 2936 | } | ||
| 2937 | lv_upperBound_3_0=ruleUpperMultiplicty | ||
| 2938 | { | ||
| 2939 | if ($current==null) { | ||
| 2940 | $current = createModelElementForParent(grammarAccess.getBoundedMultiplicityRule()); | ||
| 2941 | } | ||
| 2942 | set( | ||
| 2943 | $current, | ||
| 2944 | "upperBound", | ||
| 2945 | lv_upperBound_3_0, | ||
| 2946 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
| 2947 | afterParserOrEnumRuleCall(); | ||
| 2948 | } | ||
| 2949 | ) | ||
| 2950 | ) | ||
| 2951 | otherlv_4=']' | ||
| 2952 | { | ||
| 2953 | newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); | ||
| 2954 | } | ||
| 2955 | ) | ||
| 2956 | ; | ||
| 2957 | |||
| 2958 | // Entry rule entryRuleScopeDefinition | ||
| 2959 | entryRuleScopeDefinition returns [EObject current=null]: | ||
| 2960 | { newCompositeNode(grammarAccess.getScopeDefinitionRule()); } | ||
| 2961 | iv_ruleScopeDefinition=ruleScopeDefinition | ||
| 2962 | { $current=$iv_ruleScopeDefinition.current; } | ||
| 2963 | EOF; | ||
| 2964 | |||
| 2965 | // Rule ScopeDefinition | ||
| 2966 | ruleScopeDefinition returns [EObject current=null] | ||
| 2967 | @init { | ||
| 2968 | enterRule(); | ||
| 2969 | } | ||
| 2970 | @after { | ||
| 2971 | leaveRule(); | ||
| 2972 | }: | ||
| 2973 | ( | ||
| 2974 | { | ||
| 2975 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); | ||
| 2976 | } | ||
| 2977 | this_ExactScopeDefinition_0=ruleExactScopeDefinition | ||
| 2978 | { | ||
| 2979 | $current = $this_ExactScopeDefinition_0.current; | ||
| 2980 | afterParserOrEnumRuleCall(); | ||
| 2981 | } | ||
| 2982 | | | ||
| 2983 | { | ||
| 2984 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); | ||
| 2985 | } | ||
| 2986 | this_BoundedScopeDefinition_1=ruleBoundedScopeDefinition | ||
| 2987 | { | ||
| 2988 | $current = $this_BoundedScopeDefinition_1.current; | ||
| 2989 | afterParserOrEnumRuleCall(); | ||
| 2990 | } | ||
| 1525 | | | 2991 | | |
| 2992 | { | ||
| 2993 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); | ||
| 2994 | } | ||
| 2995 | this_LowerBoundedScopeDefinition_2=ruleLowerBoundedScopeDefinition | ||
| 2996 | { | ||
| 2997 | $current = $this_LowerBoundedScopeDefinition_2.current; | ||
| 2998 | afterParserOrEnumRuleCall(); | ||
| 2999 | } | ||
| 3000 | ) | ||
| 3001 | ; | ||
| 3002 | |||
| 3003 | // Entry rule entryRuleExactScopeDefinition | ||
| 3004 | entryRuleExactScopeDefinition returns [EObject current=null]: | ||
| 3005 | { newCompositeNode(grammarAccess.getExactScopeDefinitionRule()); } | ||
| 3006 | iv_ruleExactScopeDefinition=ruleExactScopeDefinition | ||
| 3007 | { $current=$iv_ruleExactScopeDefinition.current; } | ||
| 3008 | EOF; | ||
| 3009 | |||
| 3010 | // Rule ExactScopeDefinition | ||
| 3011 | ruleExactScopeDefinition returns [EObject current=null] | ||
| 3012 | @init { | ||
| 3013 | enterRule(); | ||
| 3014 | } | ||
| 3015 | @after { | ||
| 3016 | leaveRule(); | ||
| 3017 | }: | ||
| 3018 | ( | ||
| 3019 | otherlv_0='scope' | ||
| 3020 | { | ||
| 3021 | newLeafNode(otherlv_0, grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); | ||
| 3022 | } | ||
| 1526 | ( | 3023 | ( |
| 1527 | ( | 3024 | ( |
| 1528 | { | 3025 | { |
| 1529 | $current = forceCreateModelElement( | 3026 | if ($current==null) { |
| 1530 | grammarAccess.getPolarityAccess().getNegativeAction_1_0(), | 3027 | $current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); |
| 1531 | $current); | 3028 | } |
| 3029 | } | ||
| 3030 | { | ||
| 3031 | newCompositeNode(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | ||
| 3032 | } | ||
| 3033 | ruleQualifiedName | ||
| 3034 | { | ||
| 3035 | afterParserOrEnumRuleCall(); | ||
| 3036 | } | ||
| 3037 | ) | ||
| 3038 | ) | ||
| 3039 | otherlv_2='==' | ||
| 3040 | { | ||
| 3041 | newLeafNode(otherlv_2, grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); | ||
| 3042 | } | ||
| 3043 | ( | ||
| 3044 | ( | ||
| 3045 | lv_exactScope_3_0=RULE_INT | ||
| 3046 | { | ||
| 3047 | newLeafNode(lv_exactScope_3_0, grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); | ||
| 3048 | } | ||
| 3049 | { | ||
| 3050 | if ($current==null) { | ||
| 3051 | $current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); | ||
| 3052 | } | ||
| 3053 | setWithLastConsumed( | ||
| 3054 | $current, | ||
| 3055 | "exactScope", | ||
| 3056 | lv_exactScope_3_0, | ||
| 3057 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 1532 | } | 3058 | } |
| 1533 | ) | 3059 | ) |
| 1534 | otherlv_3='-' | ||
| 1535 | { | ||
| 1536 | newLeafNode(otherlv_3, grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); | ||
| 1537 | } | ||
| 1538 | ) | 3060 | ) |
| 1539 | ) | 3061 | ) |
| 1540 | ; | 3062 | ; |
| 1541 | 3063 | ||
| 1542 | // Entry rule entryRuleConstraint | 3064 | // Entry rule entryRuleBoundedScopeDefinition |
| 1543 | entryRuleConstraint returns [EObject current=null]: | 3065 | entryRuleBoundedScopeDefinition returns [EObject current=null]: |
| 1544 | { newCompositeNode(grammarAccess.getConstraintRule()); } | 3066 | { newCompositeNode(grammarAccess.getBoundedScopeDefinitionRule()); } |
| 1545 | iv_ruleConstraint=ruleConstraint | 3067 | iv_ruleBoundedScopeDefinition=ruleBoundedScopeDefinition |
| 1546 | { $current=$iv_ruleConstraint.current; } | 3068 | { $current=$iv_ruleBoundedScopeDefinition.current; } |
| 1547 | EOF; | 3069 | EOF; |
| 1548 | 3070 | ||
| 1549 | // Rule Constraint | 3071 | // Rule BoundedScopeDefinition |
| 1550 | ruleConstraint returns [EObject current=null] | 3072 | ruleBoundedScopeDefinition returns [EObject current=null] |
| 1551 | @init { | 3073 | @init { |
| 1552 | enterRule(); | 3074 | enterRule(); |
| 1553 | } | 3075 | } |
| @@ -1555,186 +3077,267 @@ ruleConstraint returns [EObject current=null] | |||
| 1555 | leaveRule(); | 3077 | leaveRule(); |
| 1556 | }: | 3078 | }: |
| 1557 | ( | 3079 | ( |
| 3080 | otherlv_0='scope' | ||
| 3081 | { | ||
| 3082 | newLeafNode(otherlv_0, grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); | ||
| 3083 | } | ||
| 1558 | ( | 3084 | ( |
| 1559 | ( | 3085 | ( |
| 1560 | ( | 3086 | ( |
| 3087 | ( | ||
| 3088 | ( | ||
| 3089 | lv_lowerBound_1_0=RULE_INT | ||
| 3090 | { | ||
| 3091 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); | ||
| 3092 | } | ||
| 3093 | { | ||
| 3094 | if ($current==null) { | ||
| 3095 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 3096 | } | ||
| 3097 | setWithLastConsumed( | ||
| 3098 | $current, | ||
| 3099 | "lowerBound", | ||
| 3100 | lv_lowerBound_1_0, | ||
| 3101 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 3102 | } | ||
| 3103 | ) | ||
| 3104 | ) | ||
| 3105 | otherlv_2='<=' | ||
| 1561 | { | 3106 | { |
| 1562 | newCompositeNode(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0_0()); | 3107 | newLeafNode(otherlv_2, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); |
| 1563 | } | 3108 | } |
| 1564 | lv_polarity_0_0=rulePolarity | 3109 | )? |
| 1565 | { | 3110 | ( |
| 1566 | if ($current==null) { | 3111 | ( |
| 1567 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | 3112 | { |
| 3113 | if ($current==null) { | ||
| 3114 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 3115 | } | ||
| 1568 | } | 3116 | } |
| 1569 | set( | 3117 | { |
| 1570 | $current, | 3118 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); |
| 1571 | "polarity", | 3119 | } |
| 1572 | lv_polarity_0_0, | 3120 | ruleQualifiedName |
| 1573 | "org.eclipse.viatra.solver.language.SolverLanguage.Polarity"); | 3121 | { |
| 1574 | afterParserOrEnumRuleCall(); | 3122 | afterParserOrEnumRuleCall(); |
| 1575 | } | 3123 | } |
| 3124 | ) | ||
| 1576 | ) | 3125 | ) |
| 1577 | )? | 3126 | otherlv_4='<=' |
| 1578 | ( | 3127 | { |
| 3128 | newLeafNode(otherlv_4, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); | ||
| 3129 | } | ||
| 1579 | ( | 3130 | ( |
| 1580 | { | 3131 | ( |
| 1581 | newCompositeNode(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_0_1_0()); | 3132 | lv_upperBound_5_0=RULE_INT |
| 1582 | } | 3133 | { |
| 1583 | lv_symbol_1_0=ruleModelSymbol | 3134 | newLeafNode(lv_upperBound_5_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); |
| 1584 | { | ||
| 1585 | if ($current==null) { | ||
| 1586 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1587 | } | 3135 | } |
| 1588 | set( | 3136 | { |
| 1589 | $current, | 3137 | if ($current==null) { |
| 1590 | "symbol", | 3138 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); |
| 1591 | lv_symbol_1_0, | 3139 | } |
| 1592 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | 3140 | setWithLastConsumed( |
| 1593 | afterParserOrEnumRuleCall(); | 3141 | $current, |
| 1594 | } | 3142 | "upperBound", |
| 3143 | lv_upperBound_5_0, | ||
| 3144 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 3145 | } | ||
| 3146 | ) | ||
| 1595 | ) | 3147 | ) |
| 1596 | ) | 3148 | ) |
| 3149 | | | ||
| 1597 | ( | 3150 | ( |
| 1598 | otherlv_2='(' | ||
| 1599 | { | ||
| 1600 | newLeafNode(otherlv_2, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_0_2_0()); | ||
| 1601 | } | ||
| 1602 | ( | 3151 | ( |
| 1603 | ( | 3152 | ( |
| 3153 | lv_upperBound_6_0=RULE_INT | ||
| 1604 | { | 3154 | { |
| 1605 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_1_0()); | 3155 | newLeafNode(lv_upperBound_6_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); |
| 1606 | } | 3156 | } |
| 1607 | lv_params_3_0=ruleLiteral | ||
| 1608 | { | 3157 | { |
| 1609 | if ($current==null) { | 3158 | if ($current==null) { |
| 1610 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | 3159 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); |
| 1611 | } | 3160 | } |
| 1612 | add( | 3161 | setWithLastConsumed( |
| 1613 | $current, | 3162 | $current, |
| 1614 | "params", | 3163 | "upperBound", |
| 1615 | lv_params_3_0, | 3164 | lv_upperBound_6_0, |
| 1616 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | 3165 | "org.eclipse.xtext.common.Terminals.INT"); |
| 3166 | } | ||
| 3167 | ) | ||
| 3168 | ) | ||
| 3169 | otherlv_7='>=' | ||
| 3170 | { | ||
| 3171 | newLeafNode(otherlv_7, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
| 3172 | } | ||
| 3173 | ( | ||
| 3174 | ( | ||
| 3175 | { | ||
| 3176 | if ($current==null) { | ||
| 3177 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 3178 | } | ||
| 3179 | } | ||
| 3180 | { | ||
| 3181 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); | ||
| 3182 | } | ||
| 3183 | ruleQualifiedName | ||
| 3184 | { | ||
| 1617 | afterParserOrEnumRuleCall(); | 3185 | afterParserOrEnumRuleCall(); |
| 1618 | } | 3186 | } |
| 1619 | ) | 3187 | ) |
| 1620 | )? | 3188 | ) |
| 1621 | ( | 3189 | ( |
| 1622 | otherlv_4=',' | 3190 | otherlv_9='>=' |
| 1623 | { | 3191 | { |
| 1624 | newLeafNode(otherlv_4, grammarAccess.getConstraintAccess().getCommaKeyword_0_2_2_0()); | 3192 | newLeafNode(otherlv_9, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); |
| 1625 | } | 3193 | } |
| 1626 | ( | 3194 | ( |
| 1627 | ( | 3195 | ( |
| 3196 | lv_lowerBound_10_0=RULE_INT | ||
| 1628 | { | 3197 | { |
| 1629 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_2_1_0()); | 3198 | newLeafNode(lv_lowerBound_10_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); |
| 1630 | } | 3199 | } |
| 1631 | lv_params_5_0=ruleLiteral | ||
| 1632 | { | 3200 | { |
| 1633 | if ($current==null) { | 3201 | if ($current==null) { |
| 1634 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | 3202 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); |
| 1635 | } | 3203 | } |
| 1636 | add( | 3204 | setWithLastConsumed( |
| 1637 | $current, | 3205 | $current, |
| 1638 | "params", | 3206 | "lowerBound", |
| 1639 | lv_params_5_0, | 3207 | lv_lowerBound_10_0, |
| 1640 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | 3208 | "org.eclipse.xtext.common.Terminals.INT"); |
| 1641 | afterParserOrEnumRuleCall(); | ||
| 1642 | } | 3209 | } |
| 1643 | ) | 3210 | ) |
| 1644 | ) | 3211 | ) |
| 1645 | )* | 3212 | )? |
| 1646 | otherlv_6=')' | 3213 | ) |
| 1647 | { | ||
| 1648 | newLeafNode(otherlv_6, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_0_2_3()); | ||
| 1649 | } | ||
| 1650 | )? | ||
| 1651 | ) | 3214 | ) |
| 1652 | | | 3215 | otherlv_11='.' |
| 3216 | { | ||
| 3217 | newLeafNode(otherlv_11, grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
| 3218 | } | ||
| 3219 | ) | ||
| 3220 | ; | ||
| 3221 | |||
| 3222 | // Entry rule entryRuleLowerBoundedScopeDefinition | ||
| 3223 | entryRuleLowerBoundedScopeDefinition returns [EObject current=null]: | ||
| 3224 | { newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionRule()); } | ||
| 3225 | iv_ruleLowerBoundedScopeDefinition=ruleLowerBoundedScopeDefinition | ||
| 3226 | { $current=$iv_ruleLowerBoundedScopeDefinition.current; } | ||
| 3227 | EOF; | ||
| 3228 | |||
| 3229 | // Rule LowerBoundedScopeDefinition | ||
| 3230 | ruleLowerBoundedScopeDefinition returns [EObject current=null] | ||
| 3231 | @init { | ||
| 3232 | enterRule(); | ||
| 3233 | } | ||
| 3234 | @after { | ||
| 3235 | leaveRule(); | ||
| 3236 | }: | ||
| 3237 | ( | ||
| 3238 | otherlv_0='scope' | ||
| 3239 | { | ||
| 3240 | newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); | ||
| 3241 | } | ||
| 1653 | ( | 3242 | ( |
| 1654 | ( | 3243 | ( |
| 1655 | ( | 3244 | ( |
| 1656 | { | 3245 | ( |
| 1657 | newCompositeNode(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_1_0_0()); | 3246 | lv_lowerBound_1_0=RULE_INT |
| 1658 | } | 3247 | { |
| 1659 | lv_closureType_7_0=ruleClosureType | 3248 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); |
| 1660 | { | ||
| 1661 | if ($current==null) { | ||
| 1662 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1663 | } | 3249 | } |
| 1664 | set( | 3250 | { |
| 1665 | $current, | 3251 | if ($current==null) { |
| 1666 | "closureType", | 3252 | $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
| 1667 | lv_closureType_7_0, | 3253 | } |
| 1668 | "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType"); | 3254 | setWithLastConsumed( |
| 1669 | afterParserOrEnumRuleCall(); | 3255 | $current, |
| 1670 | } | 3256 | "lowerBound", |
| 3257 | lv_lowerBound_1_0, | ||
| 3258 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 3259 | } | ||
| 3260 | ) | ||
| 3261 | ) | ||
| 3262 | otherlv_2='<=' | ||
| 3263 | { | ||
| 3264 | newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); | ||
| 3265 | } | ||
| 3266 | ( | ||
| 3267 | ( | ||
| 3268 | { | ||
| 3269 | if ($current==null) { | ||
| 3270 | $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
| 3271 | } | ||
| 3272 | } | ||
| 3273 | { | ||
| 3274 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); | ||
| 3275 | } | ||
| 3276 | ruleQualifiedName | ||
| 3277 | { | ||
| 3278 | afterParserOrEnumRuleCall(); | ||
| 3279 | } | ||
| 3280 | ) | ||
| 1671 | ) | 3281 | ) |
| 1672 | ) | 3282 | ) |
| 1673 | otherlv_8='(' | 3283 | | |
| 1674 | { | ||
| 1675 | newLeafNode(otherlv_8, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_1_1()); | ||
| 1676 | } | ||
| 1677 | ( | 3284 | ( |
| 1678 | ( | 3285 | ( |
| 1679 | { | 3286 | ( |
| 1680 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_2_0()); | 3287 | { |
| 1681 | } | 3288 | if ($current==null) { |
| 1682 | lv_params_9_0=ruleLiteral | 3289 | $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
| 1683 | { | 3290 | } |
| 1684 | if ($current==null) { | ||
| 1685 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1686 | } | 3291 | } |
| 1687 | add( | 3292 | { |
| 1688 | $current, | 3293 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); |
| 1689 | "params", | 3294 | } |
| 1690 | lv_params_9_0, | 3295 | ruleQualifiedName |
| 1691 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | 3296 | { |
| 1692 | afterParserOrEnumRuleCall(); | 3297 | afterParserOrEnumRuleCall(); |
| 1693 | } | 3298 | } |
| 3299 | ) | ||
| 1694 | ) | 3300 | ) |
| 1695 | )? | 3301 | otherlv_5='>=' |
| 1696 | ( | ||
| 1697 | otherlv_10=',' | ||
| 1698 | { | 3302 | { |
| 1699 | newLeafNode(otherlv_10, grammarAccess.getConstraintAccess().getCommaKeyword_1_3_0()); | 3303 | newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); |
| 1700 | } | 3304 | } |
| 1701 | ( | 3305 | ( |
| 1702 | ( | 3306 | ( |
| 3307 | lv_lowerBound_6_0=RULE_INT | ||
| 1703 | { | 3308 | { |
| 1704 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_3_1_0()); | 3309 | newLeafNode(lv_lowerBound_6_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); |
| 1705 | } | 3310 | } |
| 1706 | lv_params_11_0=ruleLiteral | ||
| 1707 | { | 3311 | { |
| 1708 | if ($current==null) { | 3312 | if ($current==null) { |
| 1709 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | 3313 | $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
| 1710 | } | 3314 | } |
| 1711 | add( | 3315 | setWithLastConsumed( |
| 1712 | $current, | 3316 | $current, |
| 1713 | "params", | 3317 | "lowerBound", |
| 1714 | lv_params_11_0, | 3318 | lv_lowerBound_6_0, |
| 1715 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | 3319 | "org.eclipse.xtext.common.Terminals.INT"); |
| 1716 | afterParserOrEnumRuleCall(); | ||
| 1717 | } | 3320 | } |
| 1718 | ) | 3321 | ) |
| 1719 | ) | 3322 | ) |
| 1720 | )* | 3323 | ) |
| 1721 | otherlv_12=')' | ||
| 1722 | { | ||
| 1723 | newLeafNode(otherlv_12, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_1_4()); | ||
| 1724 | } | ||
| 1725 | ) | 3324 | ) |
| 3325 | otherlv_7='.' | ||
| 3326 | { | ||
| 3327 | newLeafNode(otherlv_7, grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
| 3328 | } | ||
| 1726 | ) | 3329 | ) |
| 1727 | ; | 3330 | ; |
| 1728 | 3331 | ||
| 1729 | // Entry rule entryRuleClosureType | 3332 | // Entry rule entryRuleObjectiveDefinition |
| 1730 | entryRuleClosureType returns [EObject current=null]: | 3333 | entryRuleObjectiveDefinition returns [EObject current=null]: |
| 1731 | { newCompositeNode(grammarAccess.getClosureTypeRule()); } | 3334 | { newCompositeNode(grammarAccess.getObjectiveDefinitionRule()); } |
| 1732 | iv_ruleClosureType=ruleClosureType | 3335 | iv_ruleObjectiveDefinition=ruleObjectiveDefinition |
| 1733 | { $current=$iv_ruleClosureType.current; } | 3336 | { $current=$iv_ruleObjectiveDefinition.current; } |
| 1734 | EOF; | 3337 | EOF; |
| 1735 | 3338 | ||
| 1736 | // Rule ClosureType | 3339 | // Rule ObjectiveDefinition |
| 1737 | ruleClosureType returns [EObject current=null] | 3340 | ruleObjectiveDefinition returns [EObject current=null] |
| 1738 | @init { | 3341 | @init { |
| 1739 | enterRule(); | 3342 | enterRule(); |
| 1740 | } | 3343 | } |
| @@ -1745,42 +3348,53 @@ ruleClosureType returns [EObject current=null] | |||
| 1745 | ( | 3348 | ( |
| 1746 | ( | 3349 | ( |
| 1747 | { | 3350 | { |
| 1748 | $current = forceCreateModelElement( | 3351 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); |
| 1749 | grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0(), | 3352 | } |
| 1750 | $current); | 3353 | lv_kind_0_0=ruleObjectiveKind |
| 3354 | { | ||
| 3355 | if ($current==null) { | ||
| 3356 | $current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); | ||
| 3357 | } | ||
| 3358 | set( | ||
| 3359 | $current, | ||
| 3360 | "kind", | ||
| 3361 | lv_kind_0_0, | ||
| 3362 | "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind"); | ||
| 3363 | afterParserOrEnumRuleCall(); | ||
| 1751 | } | 3364 | } |
| 1752 | ) | 3365 | ) |
| 1753 | otherlv_1='*' | ||
| 1754 | { | ||
| 1755 | newLeafNode(otherlv_1, grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); | ||
| 1756 | } | ||
| 1757 | ) | 3366 | ) |
| 1758 | | | ||
| 1759 | ( | 3367 | ( |
| 1760 | ( | 3368 | ( |
| 1761 | { | 3369 | { |
| 1762 | $current = forceCreateModelElement( | 3370 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); |
| 1763 | grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0(), | 3371 | } |
| 1764 | $current); | 3372 | lv_objective_1_0=ruleExpression |
| 3373 | { | ||
| 3374 | if ($current==null) { | ||
| 3375 | $current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); | ||
| 3376 | } | ||
| 3377 | set( | ||
| 3378 | $current, | ||
| 3379 | "objective", | ||
| 3380 | lv_objective_1_0, | ||
| 3381 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 3382 | afterParserOrEnumRuleCall(); | ||
| 1765 | } | 3383 | } |
| 1766 | ) | 3384 | ) |
| 1767 | otherlv_3='+' | ||
| 1768 | { | ||
| 1769 | newLeafNode(otherlv_3, grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); | ||
| 1770 | } | ||
| 1771 | ) | 3385 | ) |
| 1772 | ) | 3386 | ) |
| 1773 | ; | 3387 | ; |
| 1774 | 3388 | ||
| 1775 | // Entry rule entryRuleLiteral | 3389 | // Entry rule entryRuleUpperMultiplicty |
| 1776 | entryRuleLiteral returns [EObject current=null]: | 3390 | entryRuleUpperMultiplicty returns [String current=null]: |
| 1777 | { newCompositeNode(grammarAccess.getLiteralRule()); } | 3391 | { newCompositeNode(grammarAccess.getUpperMultiplictyRule()); } |
| 1778 | iv_ruleLiteral=ruleLiteral | 3392 | iv_ruleUpperMultiplicty=ruleUpperMultiplicty |
| 1779 | { $current=$iv_ruleLiteral.current; } | 3393 | { $current=$iv_ruleUpperMultiplicty.current.getText(); } |
| 1780 | EOF; | 3394 | EOF; |
| 1781 | 3395 | ||
| 1782 | // Rule Literal | 3396 | // Rule UpperMultiplicty |
| 1783 | ruleLiteral returns [EObject current=null] | 3397 | ruleUpperMultiplicty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] |
| 1784 | @init { | 3398 | @init { |
| 1785 | enterRule(); | 3399 | enterRule(); |
| 1786 | } | 3400 | } |
| @@ -1788,121 +3402,132 @@ ruleLiteral returns [EObject current=null] | |||
| 1788 | leaveRule(); | 3402 | leaveRule(); |
| 1789 | }: | 3403 | }: |
| 1790 | ( | 3404 | ( |
| 3405 | this_INT_0=RULE_INT | ||
| 1791 | { | 3406 | { |
| 1792 | newCompositeNode(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); | 3407 | $current.merge(this_INT_0); |
| 1793 | } | 3408 | } |
| 1794 | this_Variable_0=ruleVariable | ||
| 1795 | { | 3409 | { |
| 1796 | $current = $this_Variable_0.current; | 3410 | newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); |
| 1797 | afterParserOrEnumRuleCall(); | ||
| 1798 | } | 3411 | } |
| 1799 | | | 3412 | | |
| 3413 | kw='*' | ||
| 1800 | { | 3414 | { |
| 1801 | newCompositeNode(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); | 3415 | $current.merge(kw); |
| 1802 | } | 3416 | newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); |
| 1803 | this_DataObject_1=ruleDataObject | ||
| 1804 | { | ||
| 1805 | $current = $this_DataObject_1.current; | ||
| 1806 | afterParserOrEnumRuleCall(); | ||
| 1807 | } | ||
| 1808 | | | ||
| 1809 | { | ||
| 1810 | newCompositeNode(grammarAccess.getLiteralAccess().getNamedObjectParserRuleCall_2()); | ||
| 1811 | } | ||
| 1812 | this_NamedObject_2=ruleNamedObject | ||
| 1813 | { | ||
| 1814 | $current = $this_NamedObject_2.current; | ||
| 1815 | afterParserOrEnumRuleCall(); | ||
| 1816 | } | 3417 | } |
| 1817 | ) | 3418 | ) |
| 1818 | ; | 3419 | ; |
| 1819 | 3420 | ||
| 1820 | // Entry rule entryRuleVariable | 3421 | // Entry rule entryRuleReal |
| 1821 | entryRuleVariable returns [EObject current=null]: | 3422 | entryRuleReal returns [String current=null]@init { |
| 1822 | { newCompositeNode(grammarAccess.getVariableRule()); } | 3423 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
| 1823 | iv_ruleVariable=ruleVariable | 3424 | }: |
| 1824 | { $current=$iv_ruleVariable.current; } | 3425 | { newCompositeNode(grammarAccess.getRealRule()); } |
| 3426 | iv_ruleReal=ruleReal | ||
| 3427 | { $current=$iv_ruleReal.current.getText(); } | ||
| 1825 | EOF; | 3428 | EOF; |
| 3429 | finally { | ||
| 3430 | myHiddenTokenState.restore(); | ||
| 3431 | } | ||
| 1826 | 3432 | ||
| 1827 | // Rule Variable | 3433 | // Rule Real |
| 1828 | ruleVariable returns [EObject current=null] | 3434 | ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] |
| 1829 | @init { | 3435 | @init { |
| 1830 | enterRule(); | 3436 | enterRule(); |
| 3437 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 1831 | } | 3438 | } |
| 1832 | @after { | 3439 | @after { |
| 1833 | leaveRule(); | 3440 | leaveRule(); |
| 1834 | }: | 3441 | }: |
| 1835 | ( | 3442 | ( |
| 3443 | this_INT_0=RULE_INT | ||
| 3444 | { | ||
| 3445 | $current.merge(this_INT_0); | ||
| 3446 | } | ||
| 3447 | { | ||
| 3448 | newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); | ||
| 3449 | } | ||
| 1836 | ( | 3450 | ( |
| 1837 | lv_name_0_0=RULE_ID | 3451 | kw='.' |
| 1838 | { | 3452 | { |
| 1839 | newLeafNode(lv_name_0_0, grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); | 3453 | $current.merge(kw); |
| 3454 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1_0()); | ||
| 1840 | } | 3455 | } |
| 3456 | this_INT_2=RULE_INT | ||
| 1841 | { | 3457 | { |
| 1842 | if ($current==null) { | 3458 | $current.merge(this_INT_2); |
| 1843 | $current = createModelElement(grammarAccess.getVariableRule()); | ||
| 1844 | } | ||
| 1845 | setWithLastConsumed( | ||
| 1846 | $current, | ||
| 1847 | "name", | ||
| 1848 | lv_name_0_0, | ||
| 1849 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 1850 | } | 3459 | } |
| 1851 | ) | 3460 | { |
| 3461 | newLeafNode(this_INT_2, grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); | ||
| 3462 | } | ||
| 3463 | )? | ||
| 1852 | ) | 3464 | ) |
| 1853 | ; | 3465 | ; |
| 3466 | finally { | ||
| 3467 | myHiddenTokenState.restore(); | ||
| 3468 | } | ||
| 1854 | 3469 | ||
| 1855 | // Entry rule entryRuleAllInstances | 3470 | // Entry rule entryRuleQualifiedName |
| 1856 | entryRuleAllInstances returns [EObject current=null]: | 3471 | entryRuleQualifiedName returns [String current=null]@init { |
| 1857 | { newCompositeNode(grammarAccess.getAllInstancesRule()); } | 3472 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
| 1858 | iv_ruleAllInstances=ruleAllInstances | 3473 | }: |
| 1859 | { $current=$iv_ruleAllInstances.current; } | 3474 | { newCompositeNode(grammarAccess.getQualifiedNameRule()); } |
| 3475 | iv_ruleQualifiedName=ruleQualifiedName | ||
| 3476 | { $current=$iv_ruleQualifiedName.current.getText(); } | ||
| 1860 | EOF; | 3477 | EOF; |
| 3478 | finally { | ||
| 3479 | myHiddenTokenState.restore(); | ||
| 3480 | } | ||
| 1861 | 3481 | ||
| 1862 | // Rule AllInstances | 3482 | // Rule QualifiedName |
| 1863 | ruleAllInstances returns [EObject current=null] | 3483 | ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] |
| 1864 | @init { | 3484 | @init { |
| 1865 | enterRule(); | 3485 | enterRule(); |
| 3486 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 1866 | } | 3487 | } |
| 1867 | @after { | 3488 | @after { |
| 1868 | leaveRule(); | 3489 | leaveRule(); |
| 1869 | }: | 3490 | }: |
| 1870 | ( | 3491 | ( |
| 1871 | otherlv_0=':' | ||
| 1872 | { | ||
| 1873 | newLeafNode(otherlv_0, grammarAccess.getAllInstancesAccess().getColonKeyword_0()); | ||
| 1874 | } | ||
| 1875 | ( | 3492 | ( |
| 3493 | this_ID_0=RULE_ID | ||
| 3494 | { | ||
| 3495 | $current.merge(this_ID_0); | ||
| 3496 | } | ||
| 3497 | { | ||
| 3498 | newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); | ||
| 3499 | } | ||
| 1876 | ( | 3500 | ( |
| 3501 | kw='.' | ||
| 1877 | { | 3502 | { |
| 1878 | newCompositeNode(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); | 3503 | $current.merge(kw); |
| 3504 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); | ||
| 1879 | } | 3505 | } |
| 1880 | lv_symbol_1_0=ruleSymbol | 3506 | this_ID_2=RULE_ID |
| 1881 | { | 3507 | { |
| 1882 | if ($current==null) { | 3508 | $current.merge(this_ID_2); |
| 1883 | $current = createModelElementForParent(grammarAccess.getAllInstancesRule()); | ||
| 1884 | } | ||
| 1885 | set( | ||
| 1886 | $current, | ||
| 1887 | "symbol", | ||
| 1888 | lv_symbol_1_0, | ||
| 1889 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 1890 | afterParserOrEnumRuleCall(); | ||
| 1891 | } | 3509 | } |
| 1892 | ) | 3510 | { |
| 3511 | newLeafNode(this_ID_2, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); | ||
| 3512 | } | ||
| 3513 | )* | ||
| 1893 | ) | 3514 | ) |
| 3515 | | | ||
| 3516 | this_QUOTED_ID_3=RULE_QUOTED_ID | ||
| 3517 | { | ||
| 3518 | $current.merge(this_QUOTED_ID_3); | ||
| 3519 | } | ||
| 3520 | { | ||
| 3521 | newLeafNode(this_QUOTED_ID_3, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); | ||
| 3522 | } | ||
| 1894 | ) | 3523 | ) |
| 1895 | ; | 3524 | ; |
| 3525 | finally { | ||
| 3526 | myHiddenTokenState.restore(); | ||
| 3527 | } | ||
| 1896 | 3528 | ||
| 1897 | // Entry rule entryRuleAllObjects | 3529 | // Rule MetricType |
| 1898 | entryRuleAllObjects returns [EObject current=null]: | 3530 | ruleMetricType returns [Enumerator current=null] |
| 1899 | { newCompositeNode(grammarAccess.getAllObjectsRule()); } | ||
| 1900 | iv_ruleAllObjects=ruleAllObjects | ||
| 1901 | { $current=$iv_ruleAllObjects.current; } | ||
| 1902 | EOF; | ||
| 1903 | |||
| 1904 | // Rule AllObjects | ||
| 1905 | ruleAllObjects returns [EObject current=null] | ||
| 1906 | @init { | 3531 | @init { |
| 1907 | enterRule(); | 3532 | enterRule(); |
| 1908 | } | 3533 | } |
| @@ -1911,28 +3536,25 @@ ruleAllObjects returns [EObject current=null] | |||
| 1911 | }: | 3536 | }: |
| 1912 | ( | 3537 | ( |
| 1913 | ( | 3538 | ( |
| 3539 | enumLiteral_0='int' | ||
| 1914 | { | 3540 | { |
| 1915 | $current = forceCreateModelElement( | 3541 | $current = grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 1916 | grammarAccess.getAllObjectsAccess().getAllObjectsAction_0(), | 3542 | newLeafNode(enumLiteral_0, grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); |
| 1917 | $current); | 3543 | } |
| 3544 | ) | ||
| 3545 | | | ||
| 3546 | ( | ||
| 3547 | enumLiteral_1='real' | ||
| 3548 | { | ||
| 3549 | $current = grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 3550 | newLeafNode(enumLiteral_1, grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); | ||
| 1918 | } | 3551 | } |
| 1919 | ) | 3552 | ) |
| 1920 | otherlv_1='*' | ||
| 1921 | { | ||
| 1922 | newLeafNode(otherlv_1, grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); | ||
| 1923 | } | ||
| 1924 | ) | 3553 | ) |
| 1925 | ; | 3554 | ; |
| 1926 | 3555 | ||
| 1927 | // Entry rule entryRuleDefaultInterpretation | 3556 | // Rule ComparisonOperator |
| 1928 | entryRuleDefaultInterpretation returns [EObject current=null]: | 3557 | ruleComparisonOperator returns [Enumerator current=null] |
| 1929 | { newCompositeNode(grammarAccess.getDefaultInterpretationRule()); } | ||
| 1930 | iv_ruleDefaultInterpretation=ruleDefaultInterpretation | ||
| 1931 | { $current=$iv_ruleDefaultInterpretation.current; } | ||
| 1932 | EOF; | ||
| 1933 | |||
| 1934 | // Rule DefaultInterpretation | ||
| 1935 | ruleDefaultInterpretation returns [EObject current=null] | ||
| 1936 | @init { | 3558 | @init { |
| 1937 | enterRule(); | 3559 | enterRule(); |
| 1938 | } | 3560 | } |
| @@ -1940,41 +3562,66 @@ ruleDefaultInterpretation returns [EObject current=null] | |||
| 1940 | leaveRule(); | 3562 | leaveRule(); |
| 1941 | }: | 3563 | }: |
| 1942 | ( | 3564 | ( |
| 1943 | otherlv_0='default' | ||
| 1944 | { | ||
| 1945 | newLeafNode(otherlv_0, grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); | ||
| 1946 | } | ||
| 1947 | ( | 3565 | ( |
| 1948 | ( | 3566 | enumLiteral_0='==' |
| 1949 | { | 3567 | { |
| 1950 | newCompositeNode(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); | 3568 | $current = grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 1951 | } | 3569 | newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); |
| 1952 | lv_interpretation_1_0=ruleBasicInterpretation | 3570 | } |
| 1953 | { | 3571 | ) |
| 1954 | if ($current==null) { | 3572 | | |
| 1955 | $current = createModelElementForParent(grammarAccess.getDefaultInterpretationRule()); | 3573 | ( |
| 1956 | } | 3574 | enumLiteral_1='!=' |
| 1957 | set( | 3575 | { |
| 1958 | $current, | 3576 | $current = grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
| 1959 | "interpretation", | 3577 | newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); |
| 1960 | lv_interpretation_1_0, | 3578 | } |
| 1961 | "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation"); | 3579 | ) |
| 1962 | afterParserOrEnumRuleCall(); | 3580 | | |
| 1963 | } | 3581 | ( |
| 1964 | ) | 3582 | enumLiteral_2='<' |
| 3583 | { | ||
| 3584 | $current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 3585 | newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); | ||
| 3586 | } | ||
| 3587 | ) | ||
| 3588 | | | ||
| 3589 | ( | ||
| 3590 | enumLiteral_3='<=' | ||
| 3591 | { | ||
| 3592 | $current = grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 3593 | newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); | ||
| 3594 | } | ||
| 3595 | ) | ||
| 3596 | | | ||
| 3597 | ( | ||
| 3598 | enumLiteral_4='>' | ||
| 3599 | { | ||
| 3600 | $current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
| 3601 | newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); | ||
| 3602 | } | ||
| 3603 | ) | ||
| 3604 | | | ||
| 3605 | ( | ||
| 3606 | enumLiteral_5='>=' | ||
| 3607 | { | ||
| 3608 | $current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 3609 | newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); | ||
| 3610 | } | ||
| 3611 | ) | ||
| 3612 | | | ||
| 3613 | ( | ||
| 3614 | enumLiteral_6='in' | ||
| 3615 | { | ||
| 3616 | $current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance(); | ||
| 3617 | newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); | ||
| 3618 | } | ||
| 1965 | ) | 3619 | ) |
| 1966 | ) | 3620 | ) |
| 1967 | ; | 3621 | ; |
| 1968 | 3622 | ||
| 1969 | // Entry rule entryRuleCDInterpretation | 3623 | // Rule AdditiveBinaryOperator |
| 1970 | entryRuleCDInterpretation returns [EObject current=null]: | 3624 | ruleAdditiveBinaryOperator returns [Enumerator current=null] |
| 1971 | { newCompositeNode(grammarAccess.getCDInterpretationRule()); } | ||
| 1972 | iv_ruleCDInterpretation=ruleCDInterpretation | ||
| 1973 | { $current=$iv_ruleCDInterpretation.current; } | ||
| 1974 | EOF; | ||
| 1975 | |||
| 1976 | // Rule CDInterpretation | ||
| 1977 | ruleCDInterpretation returns [EObject current=null] | ||
| 1978 | @init { | 3625 | @init { |
| 1979 | enterRule(); | 3626 | enterRule(); |
| 1980 | } | 3627 | } |
| @@ -1982,44 +3629,26 @@ ruleCDInterpretation returns [EObject current=null] | |||
| 1982 | leaveRule(); | 3629 | leaveRule(); |
| 1983 | }: | 3630 | }: |
| 1984 | ( | 3631 | ( |
| 1985 | { | 3632 | ( |
| 1986 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); | 3633 | enumLiteral_0='+' |
| 1987 | } | 3634 | { |
| 1988 | this_ClassInterpretation_0=ruleClassInterpretation | 3635 | $current = grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 1989 | { | 3636 | newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); |
| 1990 | $current = $this_ClassInterpretation_0.current; | 3637 | } |
| 1991 | afterParserOrEnumRuleCall(); | 3638 | ) |
| 1992 | } | ||
| 1993 | | | ||
| 1994 | { | ||
| 1995 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); | ||
| 1996 | } | ||
| 1997 | this_EnumInterpretation_1=ruleEnumInterpretation | ||
| 1998 | { | ||
| 1999 | $current = $this_EnumInterpretation_1.current; | ||
| 2000 | afterParserOrEnumRuleCall(); | ||
| 2001 | } | ||
| 2002 | | | 3639 | | |
| 2003 | { | 3640 | ( |
| 2004 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); | 3641 | enumLiteral_1='-' |
| 2005 | } | 3642 | { |
| 2006 | this_GlobalRelationInterpretation_2=ruleGlobalRelationInterpretation | 3643 | $current = grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
| 2007 | { | 3644 | newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); |
| 2008 | $current = $this_GlobalRelationInterpretation_2.current; | 3645 | } |
| 2009 | afterParserOrEnumRuleCall(); | 3646 | ) |
| 2010 | } | ||
| 2011 | ) | 3647 | ) |
| 2012 | ; | 3648 | ; |
| 2013 | 3649 | ||
| 2014 | // Entry rule entryRuleClassInterpretation | 3650 | // Rule MultiplicativeBinaryOperator |
| 2015 | entryRuleClassInterpretation returns [EObject current=null]: | 3651 | ruleMultiplicativeBinaryOperator returns [Enumerator current=null] |
| 2016 | { newCompositeNode(grammarAccess.getClassInterpretationRule()); } | ||
| 2017 | iv_ruleClassInterpretation=ruleClassInterpretation | ||
| 2018 | { $current=$iv_ruleClassInterpretation.current; } | ||
| 2019 | EOF; | ||
| 2020 | |||
| 2021 | // Rule ClassInterpretation | ||
| 2022 | ruleClassInterpretation returns [EObject current=null] | ||
| 2023 | @init { | 3652 | @init { |
| 2024 | enterRule(); | 3653 | enterRule(); |
| 2025 | } | 3654 | } |
| @@ -2028,106 +3657,25 @@ ruleClassInterpretation returns [EObject current=null] | |||
| 2028 | }: | 3657 | }: |
| 2029 | ( | 3658 | ( |
| 2030 | ( | 3659 | ( |
| 2031 | ( | 3660 | enumLiteral_0='*' |
| 2032 | lv_abstract_0_0='abstract' | 3661 | { |
| 2033 | { | 3662 | $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 2034 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); | 3663 | newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); |
| 2035 | } | 3664 | } |
| 2036 | { | ||
| 2037 | if ($current==null) { | ||
| 2038 | $current = createModelElement(grammarAccess.getClassInterpretationRule()); | ||
| 2039 | } | ||
| 2040 | setWithLastConsumed($current, "abstract", true, "abstract"); | ||
| 2041 | } | ||
| 2042 | ) | ||
| 2043 | )? | ||
| 2044 | otherlv_1='class' | ||
| 2045 | { | ||
| 2046 | newLeafNode(otherlv_1, grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); | ||
| 2047 | } | ||
| 2048 | ( | ||
| 2049 | ( | ||
| 2050 | { | ||
| 2051 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); | ||
| 2052 | } | ||
| 2053 | lv_symbol_2_0=ruleModelSymbol | ||
| 2054 | { | ||
| 2055 | if ($current==null) { | ||
| 2056 | $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 2057 | } | ||
| 2058 | set( | ||
| 2059 | $current, | ||
| 2060 | "symbol", | ||
| 2061 | lv_symbol_2_0, | ||
| 2062 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2063 | afterParserOrEnumRuleCall(); | ||
| 2064 | } | ||
| 2065 | ) | ||
| 2066 | ) | 3665 | ) |
| 3666 | | | ||
| 2067 | ( | 3667 | ( |
| 2068 | otherlv_3='extends' | 3668 | enumLiteral_1='/' |
| 2069 | { | 3669 | { |
| 2070 | newLeafNode(otherlv_3, grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); | 3670 | $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
| 3671 | newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); | ||
| 2071 | } | 3672 | } |
| 2072 | ( | 3673 | ) |
| 2073 | ( | ||
| 2074 | { | ||
| 2075 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); | ||
| 2076 | } | ||
| 2077 | lv_supertypes_4_0=ruleModelSymbol | ||
| 2078 | { | ||
| 2079 | if ($current==null) { | ||
| 2080 | $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 2081 | } | ||
| 2082 | add( | ||
| 2083 | $current, | ||
| 2084 | "supertypes", | ||
| 2085 | lv_supertypes_4_0, | ||
| 2086 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2087 | afterParserOrEnumRuleCall(); | ||
| 2088 | } | ||
| 2089 | ) | ||
| 2090 | )+ | ||
| 2091 | )? | ||
| 2092 | otherlv_5='{' | ||
| 2093 | { | ||
| 2094 | newLeafNode(otherlv_5, grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); | ||
| 2095 | } | ||
| 2096 | ( | ||
| 2097 | ( | ||
| 2098 | { | ||
| 2099 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); | ||
| 2100 | } | ||
| 2101 | lv_fielt_6_0=ruleFieldRelationInterpretation | ||
| 2102 | { | ||
| 2103 | if ($current==null) { | ||
| 2104 | $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 2105 | } | ||
| 2106 | add( | ||
| 2107 | $current, | ||
| 2108 | "fielt", | ||
| 2109 | lv_fielt_6_0, | ||
| 2110 | "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation"); | ||
| 2111 | afterParserOrEnumRuleCall(); | ||
| 2112 | } | ||
| 2113 | ) | ||
| 2114 | )* | ||
| 2115 | otherlv_7='}' | ||
| 2116 | { | ||
| 2117 | newLeafNode(otherlv_7, grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); | ||
| 2118 | } | ||
| 2119 | ) | 3674 | ) |
| 2120 | ; | 3675 | ; |
| 2121 | 3676 | ||
| 2122 | // Entry rule entryRuleEnumInterpretation | 3677 | // Rule ExponentialOp |
| 2123 | entryRuleEnumInterpretation returns [EObject current=null]: | 3678 | ruleExponentialOp returns [Enumerator current=null] |
| 2124 | { newCompositeNode(grammarAccess.getEnumInterpretationRule()); } | ||
| 2125 | iv_ruleEnumInterpretation=ruleEnumInterpretation | ||
| 2126 | { $current=$iv_ruleEnumInterpretation.current; } | ||
| 2127 | EOF; | ||
| 2128 | |||
| 2129 | // Rule EnumInterpretation | ||
| 2130 | ruleEnumInterpretation returns [EObject current=null] | ||
| 2131 | @init { | 3679 | @init { |
| 2132 | enterRule(); | 3680 | enterRule(); |
| 2133 | } | 3681 | } |
| @@ -2135,68 +3683,16 @@ ruleEnumInterpretation returns [EObject current=null] | |||
| 2135 | leaveRule(); | 3683 | leaveRule(); |
| 2136 | }: | 3684 | }: |
| 2137 | ( | 3685 | ( |
| 2138 | otherlv_0='enum' | 3686 | enumLiteral_0='^' |
| 2139 | { | ||
| 2140 | newLeafNode(otherlv_0, grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); | ||
| 2141 | } | ||
| 2142 | ( | ||
| 2143 | ( | ||
| 2144 | { | ||
| 2145 | newCompositeNode(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); | ||
| 2146 | } | ||
| 2147 | lv_Symbol_1_0=ruleModelSymbol | ||
| 2148 | { | ||
| 2149 | if ($current==null) { | ||
| 2150 | $current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); | ||
| 2151 | } | ||
| 2152 | set( | ||
| 2153 | $current, | ||
| 2154 | "Symbol", | ||
| 2155 | lv_Symbol_1_0, | ||
| 2156 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2157 | afterParserOrEnumRuleCall(); | ||
| 2158 | } | ||
| 2159 | ) | ||
| 2160 | ) | ||
| 2161 | otherlv_2='{' | ||
| 2162 | { | ||
| 2163 | newLeafNode(otherlv_2, grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); | ||
| 2164 | } | ||
| 2165 | ( | ||
| 2166 | ( | ||
| 2167 | { | ||
| 2168 | newCompositeNode(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); | ||
| 2169 | } | ||
| 2170 | lv_objects_3_0=ruleNamedObject | ||
| 2171 | { | ||
| 2172 | if ($current==null) { | ||
| 2173 | $current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); | ||
| 2174 | } | ||
| 2175 | add( | ||
| 2176 | $current, | ||
| 2177 | "objects", | ||
| 2178 | lv_objects_3_0, | ||
| 2179 | "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject"); | ||
| 2180 | afterParserOrEnumRuleCall(); | ||
| 2181 | } | ||
| 2182 | ) | ||
| 2183 | )+ | ||
| 2184 | otherlv_4='}' | ||
| 2185 | { | 3687 | { |
| 2186 | newLeafNode(otherlv_4, grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); | 3688 | $current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance(); |
| 3689 | newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); | ||
| 2187 | } | 3690 | } |
| 2188 | ) | 3691 | ) |
| 2189 | ; | 3692 | ; |
| 2190 | 3693 | ||
| 2191 | // Entry rule entryRuleFieldRelationInterpretation | 3694 | // Rule UnaryOp |
| 2192 | entryRuleFieldRelationInterpretation returns [EObject current=null]: | 3695 | ruleUnaryOp returns [Enumerator current=null] |
| 2193 | { newCompositeNode(grammarAccess.getFieldRelationInterpretationRule()); } | ||
| 2194 | iv_ruleFieldRelationInterpretation=ruleFieldRelationInterpretation | ||
| 2195 | { $current=$iv_ruleFieldRelationInterpretation.current; } | ||
| 2196 | EOF; | ||
| 2197 | |||
| 2198 | // Rule FieldRelationInterpretation | ||
| 2199 | ruleFieldRelationInterpretation returns [EObject current=null] | ||
| 2200 | @init { | 3696 | @init { |
| 2201 | enterRule(); | 3697 | enterRule(); |
| 2202 | } | 3698 | } |
| @@ -2205,92 +3701,57 @@ ruleFieldRelationInterpretation returns [EObject current=null] | |||
| 2205 | }: | 3701 | }: |
| 2206 | ( | 3702 | ( |
| 2207 | ( | 3703 | ( |
| 2208 | ( | 3704 | enumLiteral_0='!' |
| 2209 | lv_containment_0_0='containment' | 3705 | { |
| 2210 | { | 3706 | $current = grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 2211 | newLeafNode(lv_containment_0_0, grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); | 3707 | newLeafNode(enumLiteral_0, grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); |
| 2212 | } | 3708 | } |
| 2213 | { | 3709 | ) |
| 2214 | if ($current==null) { | 3710 | | |
| 2215 | $current = createModelElement(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2216 | } | ||
| 2217 | setWithLastConsumed($current, "containment", true, "containment"); | ||
| 2218 | } | ||
| 2219 | ) | ||
| 2220 | )? | ||
| 2221 | ( | 3711 | ( |
| 2222 | ( | 3712 | enumLiteral_1='+' |
| 2223 | { | 3713 | { |
| 2224 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); | 3714 | $current = grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
| 2225 | } | 3715 | newLeafNode(enumLiteral_1, grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); |
| 2226 | lv_symbol_1_0=ruleModelSymbol | 3716 | } |
| 2227 | { | ||
| 2228 | if ($current==null) { | ||
| 2229 | $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2230 | } | ||
| 2231 | set( | ||
| 2232 | $current, | ||
| 2233 | "symbol", | ||
| 2234 | lv_symbol_1_0, | ||
| 2235 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2236 | afterParserOrEnumRuleCall(); | ||
| 2237 | } | ||
| 2238 | ) | ||
| 2239 | ) | 3717 | ) |
| 2240 | otherlv_2=':' | 3718 | | |
| 2241 | { | ||
| 2242 | newLeafNode(otherlv_2, grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); | ||
| 2243 | } | ||
| 2244 | ( | 3719 | ( |
| 2245 | ( | 3720 | enumLiteral_2='-' |
| 2246 | { | 3721 | { |
| 2247 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); | 3722 | $current = grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
| 2248 | } | 3723 | newLeafNode(enumLiteral_2, grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); |
| 2249 | lv_multiplicity_3_0=ruleMultiplicityDefinition | 3724 | } |
| 2250 | { | 3725 | ) |
| 2251 | if ($current==null) { | 3726 | | |
| 2252 | $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2253 | } | ||
| 2254 | set( | ||
| 2255 | $current, | ||
| 2256 | "multiplicity", | ||
| 2257 | lv_multiplicity_3_0, | ||
| 2258 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 2259 | afterParserOrEnumRuleCall(); | ||
| 2260 | } | ||
| 2261 | ) | ||
| 2262 | )? | ||
| 2263 | ( | 3727 | ( |
| 2264 | ( | 3728 | enumLiteral_3='may' |
| 2265 | { | 3729 | { |
| 2266 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); | 3730 | $current = grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); |
| 2267 | } | 3731 | newLeafNode(enumLiteral_3, grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); |
| 2268 | lv_target_4_0=ruleSymbol | 3732 | } |
| 2269 | { | 3733 | ) |
| 2270 | if ($current==null) { | 3734 | | |
| 2271 | $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | 3735 | ( |
| 2272 | } | 3736 | enumLiteral_4='must' |
| 2273 | set( | 3737 | { |
| 2274 | $current, | 3738 | $current = grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); |
| 2275 | "target", | 3739 | newLeafNode(enumLiteral_4, grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); |
| 2276 | lv_target_4_0, | 3740 | } |
| 2277 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | 3741 | ) |
| 2278 | afterParserOrEnumRuleCall(); | 3742 | | |
| 2279 | } | 3743 | ( |
| 2280 | ) | 3744 | enumLiteral_5='current' |
| 3745 | { | ||
| 3746 | $current = grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 3747 | newLeafNode(enumLiteral_5, grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); | ||
| 3748 | } | ||
| 2281 | ) | 3749 | ) |
| 2282 | ) | 3750 | ) |
| 2283 | ; | 3751 | ; |
| 2284 | 3752 | ||
| 2285 | // Entry rule entryRuleGlobalRelationInterpretation | 3753 | // Rule AggregationOp |
| 2286 | entryRuleGlobalRelationInterpretation returns [EObject current=null]: | 3754 | ruleAggregationOp returns [Enumerator current=null] |
| 2287 | { newCompositeNode(grammarAccess.getGlobalRelationInterpretationRule()); } | ||
| 2288 | iv_ruleGlobalRelationInterpretation=ruleGlobalRelationInterpretation | ||
| 2289 | { $current=$iv_ruleGlobalRelationInterpretation.current; } | ||
| 2290 | EOF; | ||
| 2291 | |||
| 2292 | // Rule GlobalRelationInterpretation | ||
| 2293 | ruleGlobalRelationInterpretation returns [EObject current=null] | ||
| 2294 | @init { | 3755 | @init { |
| 2295 | enterRule(); | 3756 | enterRule(); |
| 2296 | } | 3757 | } |
| @@ -2299,134 +3760,100 @@ ruleGlobalRelationInterpretation returns [EObject current=null] | |||
| 2299 | }: | 3760 | }: |
| 2300 | ( | 3761 | ( |
| 2301 | ( | 3762 | ( |
| 2302 | ( | 3763 | enumLiteral_0='only' |
| 2303 | lv_containment_0_0='containment' | 3764 | { |
| 2304 | { | 3765 | $current = grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 2305 | newLeafNode(lv_containment_0_0, grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); | 3766 | newLeafNode(enumLiteral_0, grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); |
| 2306 | } | 3767 | } |
| 2307 | { | 3768 | ) |
| 2308 | if ($current==null) { | 3769 | | |
| 2309 | $current = createModelElement(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2310 | } | ||
| 2311 | setWithLastConsumed($current, "containment", true, "containment"); | ||
| 2312 | } | ||
| 2313 | ) | ||
| 2314 | )? | ||
| 2315 | otherlv_1='relation' | ||
| 2316 | { | ||
| 2317 | newLeafNode(otherlv_1, grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); | ||
| 2318 | } | ||
| 2319 | ( | 3770 | ( |
| 2320 | ( | 3771 | enumLiteral_1='sum' |
| 2321 | { | 3772 | { |
| 2322 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); | 3773 | $current = grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
| 2323 | } | 3774 | newLeafNode(enumLiteral_1, grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); |
| 2324 | lv_symbol_2_0=ruleModelSymbol | 3775 | } |
| 2325 | { | ||
| 2326 | if ($current==null) { | ||
| 2327 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2328 | } | ||
| 2329 | set( | ||
| 2330 | $current, | ||
| 2331 | "symbol", | ||
| 2332 | lv_symbol_2_0, | ||
| 2333 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2334 | afterParserOrEnumRuleCall(); | ||
| 2335 | } | ||
| 2336 | ) | ||
| 2337 | ) | 3776 | ) |
| 2338 | otherlv_3=':' | 3777 | | |
| 2339 | { | ||
| 2340 | newLeafNode(otherlv_3, grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); | ||
| 2341 | } | ||
| 2342 | ( | 3778 | ( |
| 2343 | ( | 3779 | enumLiteral_2='prod' |
| 2344 | { | 3780 | { |
| 2345 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); | 3781 | $current = grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
| 2346 | } | 3782 | newLeafNode(enumLiteral_2, grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); |
| 2347 | lv_sourceMultiplicity_4_0=ruleMultiplicityDefinition | 3783 | } |
| 2348 | { | 3784 | ) |
| 2349 | if ($current==null) { | 3785 | | |
| 2350 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2351 | } | ||
| 2352 | set( | ||
| 2353 | $current, | ||
| 2354 | "sourceMultiplicity", | ||
| 2355 | lv_sourceMultiplicity_4_0, | ||
| 2356 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 2357 | afterParserOrEnumRuleCall(); | ||
| 2358 | } | ||
| 2359 | ) | ||
| 2360 | )? | ||
| 2361 | ( | 3786 | ( |
| 2362 | ( | 3787 | enumLiteral_3='avg' |
| 2363 | { | 3788 | { |
| 2364 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); | 3789 | $current = grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); |
| 2365 | } | 3790 | newLeafNode(enumLiteral_3, grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); |
| 2366 | lv_source_5_0=ruleSymbol | 3791 | } |
| 2367 | { | ||
| 2368 | if ($current==null) { | ||
| 2369 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2370 | } | ||
| 2371 | set( | ||
| 2372 | $current, | ||
| 2373 | "source", | ||
| 2374 | lv_source_5_0, | ||
| 2375 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 2376 | afterParserOrEnumRuleCall(); | ||
| 2377 | } | ||
| 2378 | ) | ||
| 2379 | ) | 3792 | ) |
| 3793 | | | ||
| 2380 | ( | 3794 | ( |
| 2381 | ( | 3795 | enumLiteral_4='min' |
| 2382 | { | 3796 | { |
| 2383 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); | 3797 | $current = grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); |
| 2384 | } | 3798 | newLeafNode(enumLiteral_4, grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); |
| 2385 | lv_targetMultiplicity_6_0=ruleMultiplicityDefinition | 3799 | } |
| 2386 | { | 3800 | ) |
| 2387 | if ($current==null) { | 3801 | | |
| 2388 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2389 | } | ||
| 2390 | set( | ||
| 2391 | $current, | ||
| 2392 | "targetMultiplicity", | ||
| 2393 | lv_targetMultiplicity_6_0, | ||
| 2394 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 2395 | afterParserOrEnumRuleCall(); | ||
| 2396 | } | ||
| 2397 | ) | ||
| 2398 | )? | ||
| 2399 | ( | 3802 | ( |
| 2400 | ( | 3803 | enumLiteral_5='max' |
| 2401 | { | 3804 | { |
| 2402 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); | 3805 | $current = grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); |
| 2403 | } | 3806 | newLeafNode(enumLiteral_5, grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); |
| 2404 | lv_target_7_0=ruleSymbol | 3807 | } |
| 2405 | { | ||
| 2406 | if ($current==null) { | ||
| 2407 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2408 | } | ||
| 2409 | set( | ||
| 2410 | $current, | ||
| 2411 | "target", | ||
| 2412 | lv_target_7_0, | ||
| 2413 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 2414 | afterParserOrEnumRuleCall(); | ||
| 2415 | } | ||
| 2416 | ) | ||
| 2417 | ) | 3808 | ) |
| 2418 | ) | 3809 | ) |
| 2419 | ; | 3810 | ; |
| 2420 | 3811 | ||
| 2421 | // Entry rule entryRuleMultiplicityDefinition | 3812 | // Rule LogicValue |
| 2422 | entryRuleMultiplicityDefinition returns [EObject current=null]: | 3813 | ruleLogicValue returns [Enumerator current=null] |
| 2423 | { newCompositeNode(grammarAccess.getMultiplicityDefinitionRule()); } | 3814 | @init { |
| 2424 | iv_ruleMultiplicityDefinition=ruleMultiplicityDefinition | 3815 | enterRule(); |
| 2425 | { $current=$iv_ruleMultiplicityDefinition.current; } | 3816 | } |
| 2426 | EOF; | 3817 | @after { |
| 3818 | leaveRule(); | ||
| 3819 | }: | ||
| 3820 | ( | ||
| 3821 | ( | ||
| 3822 | enumLiteral_0='true' | ||
| 3823 | { | ||
| 3824 | $current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 3825 | newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | ||
| 3826 | } | ||
| 3827 | ) | ||
| 3828 | | | ||
| 3829 | ( | ||
| 3830 | enumLiteral_1='false' | ||
| 3831 | { | ||
| 3832 | $current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 3833 | newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | ||
| 3834 | } | ||
| 3835 | ) | ||
| 3836 | | | ||
| 3837 | ( | ||
| 3838 | enumLiteral_2='unknown' | ||
| 3839 | { | ||
| 3840 | $current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 3841 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | ||
| 3842 | } | ||
| 3843 | ) | ||
| 3844 | | | ||
| 3845 | ( | ||
| 3846 | enumLiteral_3='error' | ||
| 3847 | { | ||
| 3848 | $current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 3849 | newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); | ||
| 3850 | } | ||
| 3851 | ) | ||
| 3852 | ) | ||
| 3853 | ; | ||
| 2427 | 3854 | ||
| 2428 | // Rule MultiplicityDefinition | 3855 | // Rule ObjectiveKind |
| 2429 | ruleMultiplicityDefinition returns [EObject current=null] | 3856 | ruleObjectiveKind returns [Enumerator current=null] |
| 2430 | @init { | 3857 | @init { |
| 2431 | enterRule(); | 3858 | enterRule(); |
| 2432 | } | 3859 | } |
| @@ -2435,67 +3862,33 @@ ruleMultiplicityDefinition returns [EObject current=null] | |||
| 2435 | }: | 3862 | }: |
| 2436 | ( | 3863 | ( |
| 2437 | ( | 3864 | ( |
| 2438 | ( | 3865 | enumLiteral_0='minimize' |
| 2439 | lv_lower_0_0=RULE_INT | 3866 | { |
| 2440 | { | 3867 | $current = grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 2441 | newLeafNode(lv_lower_0_0, grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); | 3868 | newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); |
| 2442 | } | 3869 | } |
| 2443 | { | ||
| 2444 | if ($current==null) { | ||
| 2445 | $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 2446 | } | ||
| 2447 | setWithLastConsumed( | ||
| 2448 | $current, | ||
| 2449 | "lower", | ||
| 2450 | lv_lower_0_0, | ||
| 2451 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 2452 | } | ||
| 2453 | ) | ||
| 2454 | ) | 3870 | ) |
| 2455 | otherlv_1='..' | 3871 | | |
| 2456 | { | ||
| 2457 | newLeafNode(otherlv_1, grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); | ||
| 2458 | } | ||
| 2459 | ( | 3872 | ( |
| 2460 | ( | 3873 | enumLiteral_1='maximize' |
| 2461 | ( | 3874 | { |
| 2462 | lv_upper_2_0=RULE_INT | 3875 | $current = grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
| 2463 | { | 3876 | newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); |
| 2464 | newLeafNode(lv_upper_2_0, grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); | 3877 | } |
| 2465 | } | ||
| 2466 | { | ||
| 2467 | if ($current==null) { | ||
| 2468 | $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 2469 | } | ||
| 2470 | setWithLastConsumed( | ||
| 2471 | $current, | ||
| 2472 | "upper", | ||
| 2473 | lv_upper_2_0, | ||
| 2474 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 2475 | } | ||
| 2476 | ) | ||
| 2477 | ) | ||
| 2478 | | | ||
| 2479 | ( | ||
| 2480 | ( | ||
| 2481 | lv_unlimitedUpper_3_0='*' | ||
| 2482 | { | ||
| 2483 | newLeafNode(lv_unlimitedUpper_3_0, grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); | ||
| 2484 | } | ||
| 2485 | { | ||
| 2486 | if ($current==null) { | ||
| 2487 | $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 2488 | } | ||
| 2489 | setWithLastConsumed($current, "unlimitedUpper", true, "*"); | ||
| 2490 | } | ||
| 2491 | ) | ||
| 2492 | ) | ||
| 2493 | ) | 3878 | ) |
| 2494 | ) | 3879 | ) |
| 2495 | ; | 3880 | ; |
| 2496 | 3881 | ||
| 2497 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; | 3882 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; |
| 2498 | 3883 | ||
| 3884 | RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; | ||
| 3885 | |||
| 3886 | RULE_PLUS : 'synthetic::plus'; | ||
| 3887 | |||
| 3888 | RULE_STAR : 'synthetic::star'; | ||
| 3889 | |||
| 3890 | RULE_DOT : 'synthetic::dot'; | ||
| 3891 | |||
| 2499 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | 3892 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; |
| 2500 | 3893 | ||
| 2501 | RULE_INT : ('0'..'9')+; | 3894 | RULE_INT : ('0'..'9')+; |
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 index 5054ccc5..1cf5b64f 100644 --- 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 | |||
| @@ -1,45 +1,74 @@ | |||
| 1 | '('=17 | 1 | '!'=60 |
| 2 | ')'=19 | 2 | '!='=52 |
| 3 | '*'=31 | 3 | '('=33 |
| 4 | '+'=30 | 4 | ')'=34 |
| 5 | ','=18 | 5 | '*'=35 |
| 6 | '-'=11 | 6 | '+'=56 |
| 7 | '.'=12 | 7 | ','=28 |
| 8 | '..'=41 | 8 | '-'=57 |
| 9 | ':'=20 | 9 | '->'=27 |
| 10 | ':-'=28 | 10 | '.'=22 |
| 11 | '\''=27 | 11 | '..'=37 |
| 12 | 'abstract'=33 | 12 | '/'=58 |
| 13 | 'bool'=23 | 13 | ':'=15 |
| 14 | 'class'=34 | 14 | ':-'=16 |
| 15 | 'containment'=39 | 15 | ';'=26 |
| 16 | 'default'=32 | 16 | '<'=53 |
| 17 | 'enum'=38 | 17 | '<='=48 |
| 18 | 'equals'=22 | 18 | '='=17 |
| 19 | 'error'=16 | 19 | '=='=47 |
| 20 | 'exists'=21 | 20 | '>'=54 |
| 21 | 'extends'=35 | 21 | '>='=49 |
| 22 | 'false'=14 | 22 | '['=36 |
| 23 | 'int'=24 | 23 | ']'=38 |
| 24 | 'real'=25 | 24 | '^'=59 |
| 25 | 'relation'=40 | 25 | 'abstract'=41 |
| 26 | 'string'=26 | 26 | 'avg'=67 |
| 27 | 'true'=13 | 27 | 'class'=42 |
| 28 | 'unknown'=15 | 28 | 'contains'=44 |
| 29 | '{'=36 | 29 | 'count'=29 |
| 30 | '|'=29 | 30 | 'current'=63 |
| 31 | '}'=37 | 31 | 'default'=20 |
| 32 | RULE_ANY_OTHER=10 | 32 | 'else'=25 |
| 33 | RULE_ID=5 | 33 | 'empty'=40 |
| 34 | RULE_INT=4 | 34 | 'error'=19 |
| 35 | RULE_ML_COMMENT=7 | 35 | 'extends'=43 |
| 36 | RULE_SL_COMMENT=8 | 36 | 'extern'=21 |
| 37 | RULE_STRING=6 | 37 | 'false'=71 |
| 38 | RULE_WS=9 | 38 | 'functional'=18 |
| 39 | T__11=11 | 39 | 'if'=23 |
| 40 | T__12=12 | 40 | 'in'=55 |
| 41 | T__13=13 | 41 | 'inf'=39 |
| 42 | T__14=14 | 42 | 'int'=50 |
| 43 | 'max'=69 | ||
| 44 | 'maximize'=74 | ||
| 45 | 'may'=61 | ||
| 46 | 'min'=68 | ||
| 47 | 'minimize'=73 | ||
| 48 | 'must'=62 | ||
| 49 | 'only'=64 | ||
| 50 | 'opposite'=45 | ||
| 51 | 'prod'=66 | ||
| 52 | 'real'=51 | ||
| 53 | 'scope'=46 | ||
| 54 | 'sum'=65 | ||
| 55 | 'then'=24 | ||
| 56 | 'true'=70 | ||
| 57 | 'unknown'=72 | ||
| 58 | '{'=30 | ||
| 59 | '|'=32 | ||
| 60 | '}'=31 | ||
| 61 | RULE_ANY_OTHER=14 | ||
| 62 | RULE_DOT=4 | ||
| 63 | RULE_ID=8 | ||
| 64 | RULE_INT=9 | ||
| 65 | RULE_ML_COMMENT=11 | ||
| 66 | RULE_PLUS=6 | ||
| 67 | RULE_QUOTED_ID=10 | ||
| 68 | RULE_SL_COMMENT=12 | ||
| 69 | RULE_STAR=5 | ||
| 70 | RULE_STRING=7 | ||
| 71 | RULE_WS=13 | ||
| 43 | T__15=15 | 72 | T__15=15 |
| 44 | T__16=16 | 73 | T__16=16 |
| 45 | T__17=17 | 74 | T__17=17 |
| @@ -67,3 +96,36 @@ T__38=38 | |||
| 67 | T__39=39 | 96 | T__39=39 |
| 68 | T__40=40 | 97 | T__40=40 |
| 69 | T__41=41 | 98 | T__41=41 |
| 99 | T__42=42 | ||
| 100 | T__43=43 | ||
| 101 | T__44=44 | ||
| 102 | T__45=45 | ||
| 103 | T__46=46 | ||
| 104 | T__47=47 | ||
| 105 | T__48=48 | ||
| 106 | T__49=49 | ||
| 107 | T__50=50 | ||
| 108 | T__51=51 | ||
| 109 | T__52=52 | ||
| 110 | T__53=53 | ||
| 111 | T__54=54 | ||
| 112 | T__55=55 | ||
| 113 | T__56=56 | ||
| 114 | T__57=57 | ||
| 115 | T__58=58 | ||
| 116 | T__59=59 | ||
| 117 | T__60=60 | ||
| 118 | T__61=61 | ||
| 119 | T__62=62 | ||
| 120 | T__63=63 | ||
| 121 | T__64=64 | ||
| 122 | T__65=65 | ||
| 123 | T__66=66 | ||
| 124 | T__67=67 | ||
| 125 | T__68=68 | ||
| 126 | T__69=69 | ||
| 127 | T__70=70 | ||
| 128 | T__71=71 | ||
| 129 | T__72=72 | ||
| 130 | T__73=73 | ||
| 131 | T__74=74 | ||
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 index 53c80216..21e5bac9 100644 --- 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 | |||
| @@ -12,45 +12,78 @@ import java.util.ArrayList; | |||
| 12 | 12 | ||
| 13 | @SuppressWarnings("all") | 13 | @SuppressWarnings("all") |
| 14 | public class InternalSolverLanguageLexer extends Lexer { | 14 | public class InternalSolverLanguageLexer extends Lexer { |
| 15 | public static final int RULE_STRING=6; | 15 | public static final int T__50=50; |
| 16 | public static final int RULE_SL_COMMENT=8; | ||
| 17 | public static final int T__19=19; | 16 | public static final int T__19=19; |
| 18 | public static final int T__15=15; | 17 | public static final int T__15=15; |
| 19 | public static final int T__37=37; | 18 | public static final int T__59=59; |
| 20 | public static final int T__16=16; | 19 | public static final int T__16=16; |
| 21 | public static final int T__38=38; | ||
| 22 | public static final int T__17=17; | 20 | public static final int T__17=17; |
| 23 | public static final int T__39=39; | ||
| 24 | public static final int T__18=18; | 21 | public static final int T__18=18; |
| 25 | public static final int T__11=11; | 22 | public static final int T__55=55; |
| 26 | public static final int T__33=33; | 23 | public static final int T__56=56; |
| 27 | public static final int T__12=12; | 24 | public static final int T__57=57; |
| 28 | public static final int T__34=34; | 25 | public static final int T__58=58; |
| 29 | public static final int T__13=13; | 26 | public static final int T__51=51; |
| 30 | public static final int T__35=35; | 27 | public static final int RULE_STAR=5; |
| 31 | public static final int T__14=14; | 28 | public static final int T__52=52; |
| 32 | public static final int T__36=36; | 29 | public static final int T__53=53; |
| 33 | public static final int EOF=-1; | 30 | public static final int T__54=54; |
| 34 | public static final int T__30=30; | 31 | public static final int T__60=60; |
| 35 | public static final int T__31=31; | 32 | public static final int T__61=61; |
| 36 | public static final int T__32=32; | 33 | public static final int RULE_ID=8; |
| 37 | public static final int RULE_ID=5; | 34 | public static final int RULE_QUOTED_ID=10; |
| 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; | 35 | public static final int T__26=26; |
| 41 | public static final int T__27=27; | 36 | public static final int T__27=27; |
| 42 | public static final int T__28=28; | 37 | public static final int T__28=28; |
| 43 | public static final int RULE_INT=4; | 38 | public static final int RULE_INT=9; |
| 44 | public static final int T__29=29; | 39 | public static final int T__29=29; |
| 45 | public static final int T__22=22; | 40 | public static final int T__22=22; |
| 46 | public static final int RULE_ML_COMMENT=7; | 41 | public static final int T__66=66; |
| 42 | public static final int RULE_ML_COMMENT=11; | ||
| 47 | public static final int T__23=23; | 43 | public static final int T__23=23; |
| 44 | public static final int T__67=67; | ||
| 48 | public static final int T__24=24; | 45 | public static final int T__24=24; |
| 46 | public static final int T__68=68; | ||
| 49 | public static final int T__25=25; | 47 | public static final int T__25=25; |
| 50 | public static final int T__40=40; | 48 | public static final int T__69=69; |
| 51 | public static final int T__41=41; | 49 | public static final int T__62=62; |
| 50 | public static final int T__63=63; | ||
| 52 | public static final int T__20=20; | 51 | public static final int T__20=20; |
| 52 | public static final int T__64=64; | ||
| 53 | public static final int T__21=21; | 53 | public static final int T__21=21; |
| 54 | public static final int T__65=65; | ||
| 55 | public static final int T__70=70; | ||
| 56 | public static final int T__71=71; | ||
| 57 | public static final int T__72=72; | ||
| 58 | public static final int RULE_STRING=7; | ||
| 59 | public static final int RULE_SL_COMMENT=12; | ||
| 60 | public static final int T__37=37; | ||
| 61 | public static final int T__38=38; | ||
| 62 | public static final int T__39=39; | ||
| 63 | public static final int T__33=33; | ||
| 64 | public static final int T__34=34; | ||
| 65 | public static final int T__35=35; | ||
| 66 | public static final int RULE_PLUS=6; | ||
| 67 | public static final int T__36=36; | ||
| 68 | public static final int T__73=73; | ||
| 69 | public static final int RULE_DOT=4; | ||
| 70 | public static final int EOF=-1; | ||
| 71 | public static final int T__30=30; | ||
| 72 | public static final int T__74=74; | ||
| 73 | public static final int T__31=31; | ||
| 74 | public static final int T__32=32; | ||
| 75 | public static final int RULE_WS=13; | ||
| 76 | public static final int RULE_ANY_OTHER=14; | ||
| 77 | public static final int T__48=48; | ||
| 78 | public static final int T__49=49; | ||
| 79 | public static final int T__44=44; | ||
| 80 | public static final int T__45=45; | ||
| 81 | public static final int T__46=46; | ||
| 82 | public static final int T__47=47; | ||
| 83 | public static final int T__40=40; | ||
| 84 | public static final int T__41=41; | ||
| 85 | public static final int T__42=42; | ||
| 86 | public static final int T__43=43; | ||
| 54 | 87 | ||
| 55 | // delegates | 88 | // delegates |
| 56 | // delegators | 89 | // delegators |
| @@ -65,98 +98,15 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 65 | } | 98 | } |
| 66 | public String getGrammarFileName() { return "InternalSolverLanguage.g"; } | 99 | public String getGrammarFileName() { return "InternalSolverLanguage.g"; } |
| 67 | 100 | ||
| 68 | // $ANTLR start "T__11" | ||
| 69 | public final void mT__11() throws RecognitionException { | ||
| 70 | try { | ||
| 71 | int _type = T__11; | ||
| 72 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 73 | // InternalSolverLanguage.g:11:7: ( '-' ) | ||
| 74 | // InternalSolverLanguage.g:11:9: '-' | ||
| 75 | { | ||
| 76 | match('-'); | ||
| 77 | |||
| 78 | } | ||
| 79 | |||
| 80 | state.type = _type; | ||
| 81 | state.channel = _channel; | ||
| 82 | } | ||
| 83 | finally { | ||
| 84 | } | ||
| 85 | } | ||
| 86 | // $ANTLR end "T__11" | ||
| 87 | |||
| 88 | // $ANTLR start "T__12" | ||
| 89 | public final void mT__12() throws RecognitionException { | ||
| 90 | try { | ||
| 91 | int _type = T__12; | ||
| 92 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 93 | // InternalSolverLanguage.g:12:7: ( '.' ) | ||
| 94 | // InternalSolverLanguage.g:12:9: '.' | ||
| 95 | { | ||
| 96 | match('.'); | ||
| 97 | |||
| 98 | } | ||
| 99 | |||
| 100 | state.type = _type; | ||
| 101 | state.channel = _channel; | ||
| 102 | } | ||
| 103 | finally { | ||
| 104 | } | ||
| 105 | } | ||
| 106 | // $ANTLR end "T__12" | ||
| 107 | |||
| 108 | // $ANTLR start "T__13" | ||
| 109 | public final void mT__13() throws RecognitionException { | ||
| 110 | try { | ||
| 111 | int _type = T__13; | ||
| 112 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 113 | // InternalSolverLanguage.g:13:7: ( 'true' ) | ||
| 114 | // InternalSolverLanguage.g:13:9: 'true' | ||
| 115 | { | ||
| 116 | match("true"); | ||
| 117 | |||
| 118 | |||
| 119 | } | ||
| 120 | |||
| 121 | state.type = _type; | ||
| 122 | state.channel = _channel; | ||
| 123 | } | ||
| 124 | finally { | ||
| 125 | } | ||
| 126 | } | ||
| 127 | // $ANTLR end "T__13" | ||
| 128 | |||
| 129 | // $ANTLR start "T__14" | ||
| 130 | public final void mT__14() throws RecognitionException { | ||
| 131 | try { | ||
| 132 | int _type = T__14; | ||
| 133 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 134 | // InternalSolverLanguage.g:14:7: ( 'false' ) | ||
| 135 | // InternalSolverLanguage.g:14:9: 'false' | ||
| 136 | { | ||
| 137 | match("false"); | ||
| 138 | |||
| 139 | |||
| 140 | } | ||
| 141 | |||
| 142 | state.type = _type; | ||
| 143 | state.channel = _channel; | ||
| 144 | } | ||
| 145 | finally { | ||
| 146 | } | ||
| 147 | } | ||
| 148 | // $ANTLR end "T__14" | ||
| 149 | |||
| 150 | // $ANTLR start "T__15" | 101 | // $ANTLR start "T__15" |
| 151 | public final void mT__15() throws RecognitionException { | 102 | public final void mT__15() throws RecognitionException { |
| 152 | try { | 103 | try { |
| 153 | int _type = T__15; | 104 | int _type = T__15; |
| 154 | int _channel = DEFAULT_TOKEN_CHANNEL; | 105 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 155 | // InternalSolverLanguage.g:15:7: ( 'unknown' ) | 106 | // InternalSolverLanguage.g:11:7: ( ':' ) |
| 156 | // InternalSolverLanguage.g:15:9: 'unknown' | 107 | // InternalSolverLanguage.g:11:9: ':' |
| 157 | { | 108 | { |
| 158 | match("unknown"); | 109 | match(':'); |
| 159 | |||
| 160 | 110 | ||
| 161 | } | 111 | } |
| 162 | 112 | ||
| @@ -173,10 +123,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 173 | try { | 123 | try { |
| 174 | int _type = T__16; | 124 | int _type = T__16; |
| 175 | int _channel = DEFAULT_TOKEN_CHANNEL; | 125 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 176 | // InternalSolverLanguage.g:16:7: ( 'error' ) | 126 | // InternalSolverLanguage.g:12:7: ( ':-' ) |
| 177 | // InternalSolverLanguage.g:16:9: 'error' | 127 | // InternalSolverLanguage.g:12:9: ':-' |
| 178 | { | 128 | { |
| 179 | match("error"); | 129 | match(":-"); |
| 180 | 130 | ||
| 181 | 131 | ||
| 182 | } | 132 | } |
| @@ -194,10 +144,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 194 | try { | 144 | try { |
| 195 | int _type = T__17; | 145 | int _type = T__17; |
| 196 | int _channel = DEFAULT_TOKEN_CHANNEL; | 146 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 197 | // InternalSolverLanguage.g:17:7: ( '(' ) | 147 | // InternalSolverLanguage.g:13:7: ( '=' ) |
| 198 | // InternalSolverLanguage.g:17:9: '(' | 148 | // InternalSolverLanguage.g:13:9: '=' |
| 199 | { | 149 | { |
| 200 | match('('); | 150 | match('='); |
| 201 | 151 | ||
| 202 | } | 152 | } |
| 203 | 153 | ||
| @@ -214,10 +164,11 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 214 | try { | 164 | try { |
| 215 | int _type = T__18; | 165 | int _type = T__18; |
| 216 | int _channel = DEFAULT_TOKEN_CHANNEL; | 166 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 217 | // InternalSolverLanguage.g:18:7: ( ',' ) | 167 | // InternalSolverLanguage.g:14:7: ( 'functional' ) |
| 218 | // InternalSolverLanguage.g:18:9: ',' | 168 | // InternalSolverLanguage.g:14:9: 'functional' |
| 219 | { | 169 | { |
| 220 | match(','); | 170 | match("functional"); |
| 171 | |||
| 221 | 172 | ||
| 222 | } | 173 | } |
| 223 | 174 | ||
| @@ -234,10 +185,11 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 234 | try { | 185 | try { |
| 235 | int _type = T__19; | 186 | int _type = T__19; |
| 236 | int _channel = DEFAULT_TOKEN_CHANNEL; | 187 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 237 | // InternalSolverLanguage.g:19:7: ( ')' ) | 188 | // InternalSolverLanguage.g:15:7: ( 'error' ) |
| 238 | // InternalSolverLanguage.g:19:9: ')' | 189 | // InternalSolverLanguage.g:15:9: 'error' |
| 239 | { | 190 | { |
| 240 | match(')'); | 191 | match("error"); |
| 192 | |||
| 241 | 193 | ||
| 242 | } | 194 | } |
| 243 | 195 | ||
| @@ -254,10 +206,11 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 254 | try { | 206 | try { |
| 255 | int _type = T__20; | 207 | int _type = T__20; |
| 256 | int _channel = DEFAULT_TOKEN_CHANNEL; | 208 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 257 | // InternalSolverLanguage.g:20:7: ( ':' ) | 209 | // InternalSolverLanguage.g:16:7: ( 'default' ) |
| 258 | // InternalSolverLanguage.g:20:9: ':' | 210 | // InternalSolverLanguage.g:16:9: 'default' |
| 259 | { | 211 | { |
| 260 | match(':'); | 212 | match("default"); |
| 213 | |||
| 261 | 214 | ||
| 262 | } | 215 | } |
| 263 | 216 | ||
| @@ -274,10 +227,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 274 | try { | 227 | try { |
| 275 | int _type = T__21; | 228 | int _type = T__21; |
| 276 | int _channel = DEFAULT_TOKEN_CHANNEL; | 229 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 277 | // InternalSolverLanguage.g:21:7: ( 'exists' ) | 230 | // InternalSolverLanguage.g:17:7: ( 'extern' ) |
| 278 | // InternalSolverLanguage.g:21:9: 'exists' | 231 | // InternalSolverLanguage.g:17:9: 'extern' |
| 279 | { | 232 | { |
| 280 | match("exists"); | 233 | match("extern"); |
| 281 | 234 | ||
| 282 | 235 | ||
| 283 | } | 236 | } |
| @@ -295,11 +248,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 295 | try { | 248 | try { |
| 296 | int _type = T__22; | 249 | int _type = T__22; |
| 297 | int _channel = DEFAULT_TOKEN_CHANNEL; | 250 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 298 | // InternalSolverLanguage.g:22:7: ( 'equals' ) | 251 | // InternalSolverLanguage.g:18:7: ( '.' ) |
| 299 | // InternalSolverLanguage.g:22:9: 'equals' | 252 | // InternalSolverLanguage.g:18:9: '.' |
| 300 | { | 253 | { |
| 301 | match("equals"); | 254 | match('.'); |
| 302 | |||
| 303 | 255 | ||
| 304 | } | 256 | } |
| 305 | 257 | ||
| @@ -316,10 +268,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 316 | try { | 268 | try { |
| 317 | int _type = T__23; | 269 | int _type = T__23; |
| 318 | int _channel = DEFAULT_TOKEN_CHANNEL; | 270 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 319 | // InternalSolverLanguage.g:23:7: ( 'bool' ) | 271 | // InternalSolverLanguage.g:19:7: ( 'if' ) |
| 320 | // InternalSolverLanguage.g:23:9: 'bool' | 272 | // InternalSolverLanguage.g:19:9: 'if' |
| 321 | { | 273 | { |
| 322 | match("bool"); | 274 | match("if"); |
| 323 | 275 | ||
| 324 | 276 | ||
| 325 | } | 277 | } |
| @@ -337,10 +289,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 337 | try { | 289 | try { |
| 338 | int _type = T__24; | 290 | int _type = T__24; |
| 339 | int _channel = DEFAULT_TOKEN_CHANNEL; | 291 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 340 | // InternalSolverLanguage.g:24:7: ( 'int' ) | 292 | // InternalSolverLanguage.g:20:7: ( 'then' ) |
| 341 | // InternalSolverLanguage.g:24:9: 'int' | 293 | // InternalSolverLanguage.g:20:9: 'then' |
| 342 | { | 294 | { |
| 343 | match("int"); | 295 | match("then"); |
| 344 | 296 | ||
| 345 | 297 | ||
| 346 | } | 298 | } |
| @@ -358,10 +310,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 358 | try { | 310 | try { |
| 359 | int _type = T__25; | 311 | int _type = T__25; |
| 360 | int _channel = DEFAULT_TOKEN_CHANNEL; | 312 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 361 | // InternalSolverLanguage.g:25:7: ( 'real' ) | 313 | // InternalSolverLanguage.g:21:7: ( 'else' ) |
| 362 | // InternalSolverLanguage.g:25:9: 'real' | 314 | // InternalSolverLanguage.g:21:9: 'else' |
| 363 | { | 315 | { |
| 364 | match("real"); | 316 | match("else"); |
| 365 | 317 | ||
| 366 | 318 | ||
| 367 | } | 319 | } |
| @@ -379,11 +331,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 379 | try { | 331 | try { |
| 380 | int _type = T__26; | 332 | int _type = T__26; |
| 381 | int _channel = DEFAULT_TOKEN_CHANNEL; | 333 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 382 | // InternalSolverLanguage.g:26:7: ( 'string' ) | 334 | // InternalSolverLanguage.g:22:7: ( ';' ) |
| 383 | // InternalSolverLanguage.g:26:9: 'string' | 335 | // InternalSolverLanguage.g:22:9: ';' |
| 384 | { | 336 | { |
| 385 | match("string"); | 337 | match(';'); |
| 386 | |||
| 387 | 338 | ||
| 388 | } | 339 | } |
| 389 | 340 | ||
| @@ -400,10 +351,11 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 400 | try { | 351 | try { |
| 401 | int _type = T__27; | 352 | int _type = T__27; |
| 402 | int _channel = DEFAULT_TOKEN_CHANNEL; | 353 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 403 | // InternalSolverLanguage.g:27:7: ( '\\'' ) | 354 | // InternalSolverLanguage.g:23:7: ( '->' ) |
| 404 | // InternalSolverLanguage.g:27:9: '\\'' | 355 | // InternalSolverLanguage.g:23:9: '->' |
| 405 | { | 356 | { |
| 406 | match('\''); | 357 | match("->"); |
| 358 | |||
| 407 | 359 | ||
| 408 | } | 360 | } |
| 409 | 361 | ||
| @@ -420,11 +372,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 420 | try { | 372 | try { |
| 421 | int _type = T__28; | 373 | int _type = T__28; |
| 422 | int _channel = DEFAULT_TOKEN_CHANNEL; | 374 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 423 | // InternalSolverLanguage.g:28:7: ( ':-' ) | 375 | // InternalSolverLanguage.g:24:7: ( ',' ) |
| 424 | // InternalSolverLanguage.g:28:9: ':-' | 376 | // InternalSolverLanguage.g:24:9: ',' |
| 425 | { | 377 | { |
| 426 | match(":-"); | 378 | match(','); |
| 427 | |||
| 428 | 379 | ||
| 429 | } | 380 | } |
| 430 | 381 | ||
| @@ -441,10 +392,11 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 441 | try { | 392 | try { |
| 442 | int _type = T__29; | 393 | int _type = T__29; |
| 443 | int _channel = DEFAULT_TOKEN_CHANNEL; | 394 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 444 | // InternalSolverLanguage.g:29:7: ( '|' ) | 395 | // InternalSolverLanguage.g:25:7: ( 'count' ) |
| 445 | // InternalSolverLanguage.g:29:9: '|' | 396 | // InternalSolverLanguage.g:25:9: 'count' |
| 446 | { | 397 | { |
| 447 | match('|'); | 398 | match("count"); |
| 399 | |||
| 448 | 400 | ||
| 449 | } | 401 | } |
| 450 | 402 | ||
| @@ -461,10 +413,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 461 | try { | 413 | try { |
| 462 | int _type = T__30; | 414 | int _type = T__30; |
| 463 | int _channel = DEFAULT_TOKEN_CHANNEL; | 415 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 464 | // InternalSolverLanguage.g:30:7: ( '+' ) | 416 | // InternalSolverLanguage.g:26:7: ( '{' ) |
| 465 | // InternalSolverLanguage.g:30:9: '+' | 417 | // InternalSolverLanguage.g:26:9: '{' |
| 466 | { | 418 | { |
| 467 | match('+'); | 419 | match('{'); |
| 468 | 420 | ||
| 469 | } | 421 | } |
| 470 | 422 | ||
| @@ -481,10 +433,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 481 | try { | 433 | try { |
| 482 | int _type = T__31; | 434 | int _type = T__31; |
| 483 | int _channel = DEFAULT_TOKEN_CHANNEL; | 435 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 484 | // InternalSolverLanguage.g:31:7: ( '*' ) | 436 | // InternalSolverLanguage.g:27:7: ( '}' ) |
| 485 | // InternalSolverLanguage.g:31:9: '*' | 437 | // InternalSolverLanguage.g:27:9: '}' |
| 486 | { | 438 | { |
| 487 | match('*'); | 439 | match('}'); |
| 488 | 440 | ||
| 489 | } | 441 | } |
| 490 | 442 | ||
| @@ -501,11 +453,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 501 | try { | 453 | try { |
| 502 | int _type = T__32; | 454 | int _type = T__32; |
| 503 | int _channel = DEFAULT_TOKEN_CHANNEL; | 455 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 504 | // InternalSolverLanguage.g:32:7: ( 'default' ) | 456 | // InternalSolverLanguage.g:28:7: ( '|' ) |
| 505 | // InternalSolverLanguage.g:32:9: 'default' | 457 | // InternalSolverLanguage.g:28:9: '|' |
| 506 | { | 458 | { |
| 507 | match("default"); | 459 | match('|'); |
| 508 | |||
| 509 | 460 | ||
| 510 | } | 461 | } |
| 511 | 462 | ||
| @@ -522,11 +473,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 522 | try { | 473 | try { |
| 523 | int _type = T__33; | 474 | int _type = T__33; |
| 524 | int _channel = DEFAULT_TOKEN_CHANNEL; | 475 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 525 | // InternalSolverLanguage.g:33:7: ( 'abstract' ) | 476 | // InternalSolverLanguage.g:29:7: ( '(' ) |
| 526 | // InternalSolverLanguage.g:33:9: 'abstract' | 477 | // InternalSolverLanguage.g:29:9: '(' |
| 527 | { | 478 | { |
| 528 | match("abstract"); | 479 | match('('); |
| 529 | |||
| 530 | 480 | ||
| 531 | } | 481 | } |
| 532 | 482 | ||
| @@ -543,11 +493,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 543 | try { | 493 | try { |
| 544 | int _type = T__34; | 494 | int _type = T__34; |
| 545 | int _channel = DEFAULT_TOKEN_CHANNEL; | 495 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 546 | // InternalSolverLanguage.g:34:7: ( 'class' ) | 496 | // InternalSolverLanguage.g:30:7: ( ')' ) |
| 547 | // InternalSolverLanguage.g:34:9: 'class' | 497 | // InternalSolverLanguage.g:30:9: ')' |
| 548 | { | 498 | { |
| 549 | match("class"); | 499 | match(')'); |
| 550 | |||
| 551 | 500 | ||
| 552 | } | 501 | } |
| 553 | 502 | ||
| @@ -564,11 +513,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 564 | try { | 513 | try { |
| 565 | int _type = T__35; | 514 | int _type = T__35; |
| 566 | int _channel = DEFAULT_TOKEN_CHANNEL; | 515 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 567 | // InternalSolverLanguage.g:35:7: ( 'extends' ) | 516 | // InternalSolverLanguage.g:31:7: ( '*' ) |
| 568 | // InternalSolverLanguage.g:35:9: 'extends' | 517 | // InternalSolverLanguage.g:31:9: '*' |
| 569 | { | 518 | { |
| 570 | match("extends"); | 519 | match('*'); |
| 571 | |||
| 572 | 520 | ||
| 573 | } | 521 | } |
| 574 | 522 | ||
| @@ -585,10 +533,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 585 | try { | 533 | try { |
| 586 | int _type = T__36; | 534 | int _type = T__36; |
| 587 | int _channel = DEFAULT_TOKEN_CHANNEL; | 535 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 588 | // InternalSolverLanguage.g:36:7: ( '{' ) | 536 | // InternalSolverLanguage.g:32:7: ( '[' ) |
| 589 | // InternalSolverLanguage.g:36:9: '{' | 537 | // InternalSolverLanguage.g:32:9: '[' |
| 590 | { | 538 | { |
| 591 | match('{'); | 539 | match('['); |
| 592 | 540 | ||
| 593 | } | 541 | } |
| 594 | 542 | ||
| @@ -605,10 +553,11 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 605 | try { | 553 | try { |
| 606 | int _type = T__37; | 554 | int _type = T__37; |
| 607 | int _channel = DEFAULT_TOKEN_CHANNEL; | 555 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 608 | // InternalSolverLanguage.g:37:7: ( '}' ) | 556 | // InternalSolverLanguage.g:33:7: ( '..' ) |
| 609 | // InternalSolverLanguage.g:37:9: '}' | 557 | // InternalSolverLanguage.g:33:9: '..' |
| 610 | { | 558 | { |
| 611 | match('}'); | 559 | match(".."); |
| 560 | |||
| 612 | 561 | ||
| 613 | } | 562 | } |
| 614 | 563 | ||
| @@ -625,11 +574,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 625 | try { | 574 | try { |
| 626 | int _type = T__38; | 575 | int _type = T__38; |
| 627 | int _channel = DEFAULT_TOKEN_CHANNEL; | 576 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 628 | // InternalSolverLanguage.g:38:7: ( 'enum' ) | 577 | // InternalSolverLanguage.g:34:7: ( ']' ) |
| 629 | // InternalSolverLanguage.g:38:9: 'enum' | 578 | // InternalSolverLanguage.g:34:9: ']' |
| 630 | { | 579 | { |
| 631 | match("enum"); | 580 | match(']'); |
| 632 | |||
| 633 | 581 | ||
| 634 | } | 582 | } |
| 635 | 583 | ||
| @@ -646,10 +594,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 646 | try { | 594 | try { |
| 647 | int _type = T__39; | 595 | int _type = T__39; |
| 648 | int _channel = DEFAULT_TOKEN_CHANNEL; | 596 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 649 | // InternalSolverLanguage.g:39:7: ( 'containment' ) | 597 | // InternalSolverLanguage.g:35:7: ( 'inf' ) |
| 650 | // InternalSolverLanguage.g:39:9: 'containment' | 598 | // InternalSolverLanguage.g:35:9: 'inf' |
| 651 | { | 599 | { |
| 652 | match("containment"); | 600 | match("inf"); |
| 653 | 601 | ||
| 654 | 602 | ||
| 655 | } | 603 | } |
| @@ -667,10 +615,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 667 | try { | 615 | try { |
| 668 | int _type = T__40; | 616 | int _type = T__40; |
| 669 | int _channel = DEFAULT_TOKEN_CHANNEL; | 617 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 670 | // InternalSolverLanguage.g:40:7: ( 'relation' ) | 618 | // InternalSolverLanguage.g:36:7: ( 'empty' ) |
| 671 | // InternalSolverLanguage.g:40:9: 'relation' | 619 | // InternalSolverLanguage.g:36:9: 'empty' |
| 672 | { | 620 | { |
| 673 | match("relation"); | 621 | match("empty"); |
| 674 | 622 | ||
| 675 | 623 | ||
| 676 | } | 624 | } |
| @@ -688,10 +636,10 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 688 | try { | 636 | try { |
| 689 | int _type = T__41; | 637 | int _type = T__41; |
| 690 | int _channel = DEFAULT_TOKEN_CHANNEL; | 638 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 691 | // InternalSolverLanguage.g:41:7: ( '..' ) | 639 | // InternalSolverLanguage.g:37:7: ( 'abstract' ) |
| 692 | // InternalSolverLanguage.g:41:9: '..' | 640 | // InternalSolverLanguage.g:37:9: 'abstract' |
| 693 | { | 641 | { |
| 694 | match(".."); | 642 | match("abstract"); |
| 695 | 643 | ||
| 696 | 644 | ||
| 697 | } | 645 | } |
| @@ -704,16 +652,702 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 704 | } | 652 | } |
| 705 | // $ANTLR end "T__41" | 653 | // $ANTLR end "T__41" |
| 706 | 654 | ||
| 655 | // $ANTLR start "T__42" | ||
| 656 | public final void mT__42() throws RecognitionException { | ||
| 657 | try { | ||
| 658 | int _type = T__42; | ||
| 659 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 660 | // InternalSolverLanguage.g:38:7: ( 'class' ) | ||
| 661 | // InternalSolverLanguage.g:38:9: 'class' | ||
| 662 | { | ||
| 663 | match("class"); | ||
| 664 | |||
| 665 | |||
| 666 | } | ||
| 667 | |||
| 668 | state.type = _type; | ||
| 669 | state.channel = _channel; | ||
| 670 | } | ||
| 671 | finally { | ||
| 672 | } | ||
| 673 | } | ||
| 674 | // $ANTLR end "T__42" | ||
| 675 | |||
| 676 | // $ANTLR start "T__43" | ||
| 677 | public final void mT__43() throws RecognitionException { | ||
| 678 | try { | ||
| 679 | int _type = T__43; | ||
| 680 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 681 | // InternalSolverLanguage.g:39:7: ( 'extends' ) | ||
| 682 | // InternalSolverLanguage.g:39:9: 'extends' | ||
| 683 | { | ||
| 684 | match("extends"); | ||
| 685 | |||
| 686 | |||
| 687 | } | ||
| 688 | |||
| 689 | state.type = _type; | ||
| 690 | state.channel = _channel; | ||
| 691 | } | ||
| 692 | finally { | ||
| 693 | } | ||
| 694 | } | ||
| 695 | // $ANTLR end "T__43" | ||
| 696 | |||
| 697 | // $ANTLR start "T__44" | ||
| 698 | public final void mT__44() throws RecognitionException { | ||
| 699 | try { | ||
| 700 | int _type = T__44; | ||
| 701 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 702 | // InternalSolverLanguage.g:40:7: ( 'contains' ) | ||
| 703 | // InternalSolverLanguage.g:40:9: 'contains' | ||
| 704 | { | ||
| 705 | match("contains"); | ||
| 706 | |||
| 707 | |||
| 708 | } | ||
| 709 | |||
| 710 | state.type = _type; | ||
| 711 | state.channel = _channel; | ||
| 712 | } | ||
| 713 | finally { | ||
| 714 | } | ||
| 715 | } | ||
| 716 | // $ANTLR end "T__44" | ||
| 717 | |||
| 718 | // $ANTLR start "T__45" | ||
| 719 | public final void mT__45() throws RecognitionException { | ||
| 720 | try { | ||
| 721 | int _type = T__45; | ||
| 722 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 723 | // InternalSolverLanguage.g:41:7: ( 'opposite' ) | ||
| 724 | // InternalSolverLanguage.g:41:9: 'opposite' | ||
| 725 | { | ||
| 726 | match("opposite"); | ||
| 727 | |||
| 728 | |||
| 729 | } | ||
| 730 | |||
| 731 | state.type = _type; | ||
| 732 | state.channel = _channel; | ||
| 733 | } | ||
| 734 | finally { | ||
| 735 | } | ||
| 736 | } | ||
| 737 | // $ANTLR end "T__45" | ||
| 738 | |||
| 739 | // $ANTLR start "T__46" | ||
| 740 | public final void mT__46() throws RecognitionException { | ||
| 741 | try { | ||
| 742 | int _type = T__46; | ||
| 743 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 744 | // InternalSolverLanguage.g:42:7: ( 'scope' ) | ||
| 745 | // InternalSolverLanguage.g:42:9: 'scope' | ||
| 746 | { | ||
| 747 | match("scope"); | ||
| 748 | |||
| 749 | |||
| 750 | } | ||
| 751 | |||
| 752 | state.type = _type; | ||
| 753 | state.channel = _channel; | ||
| 754 | } | ||
| 755 | finally { | ||
| 756 | } | ||
| 757 | } | ||
| 758 | // $ANTLR end "T__46" | ||
| 759 | |||
| 760 | // $ANTLR start "T__47" | ||
| 761 | public final void mT__47() throws RecognitionException { | ||
| 762 | try { | ||
| 763 | int _type = T__47; | ||
| 764 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 765 | // InternalSolverLanguage.g:43:7: ( '==' ) | ||
| 766 | // InternalSolverLanguage.g:43:9: '==' | ||
| 767 | { | ||
| 768 | match("=="); | ||
| 769 | |||
| 770 | |||
| 771 | } | ||
| 772 | |||
| 773 | state.type = _type; | ||
| 774 | state.channel = _channel; | ||
| 775 | } | ||
| 776 | finally { | ||
| 777 | } | ||
| 778 | } | ||
| 779 | // $ANTLR end "T__47" | ||
| 780 | |||
| 781 | // $ANTLR start "T__48" | ||
| 782 | public final void mT__48() throws RecognitionException { | ||
| 783 | try { | ||
| 784 | int _type = T__48; | ||
| 785 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 786 | // InternalSolverLanguage.g:44:7: ( '<=' ) | ||
| 787 | // InternalSolverLanguage.g:44:9: '<=' | ||
| 788 | { | ||
| 789 | match("<="); | ||
| 790 | |||
| 791 | |||
| 792 | } | ||
| 793 | |||
| 794 | state.type = _type; | ||
| 795 | state.channel = _channel; | ||
| 796 | } | ||
| 797 | finally { | ||
| 798 | } | ||
| 799 | } | ||
| 800 | // $ANTLR end "T__48" | ||
| 801 | |||
| 802 | // $ANTLR start "T__49" | ||
| 803 | public final void mT__49() throws RecognitionException { | ||
| 804 | try { | ||
| 805 | int _type = T__49; | ||
| 806 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 807 | // InternalSolverLanguage.g:45:7: ( '>=' ) | ||
| 808 | // InternalSolverLanguage.g:45:9: '>=' | ||
| 809 | { | ||
| 810 | match(">="); | ||
| 811 | |||
| 812 | |||
| 813 | } | ||
| 814 | |||
| 815 | state.type = _type; | ||
| 816 | state.channel = _channel; | ||
| 817 | } | ||
| 818 | finally { | ||
| 819 | } | ||
| 820 | } | ||
| 821 | // $ANTLR end "T__49" | ||
| 822 | |||
| 823 | // $ANTLR start "T__50" | ||
| 824 | public final void mT__50() throws RecognitionException { | ||
| 825 | try { | ||
| 826 | int _type = T__50; | ||
| 827 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 828 | // InternalSolverLanguage.g:46:7: ( 'int' ) | ||
| 829 | // InternalSolverLanguage.g:46:9: 'int' | ||
| 830 | { | ||
| 831 | match("int"); | ||
| 832 | |||
| 833 | |||
| 834 | } | ||
| 835 | |||
| 836 | state.type = _type; | ||
| 837 | state.channel = _channel; | ||
| 838 | } | ||
| 839 | finally { | ||
| 840 | } | ||
| 841 | } | ||
| 842 | // $ANTLR end "T__50" | ||
| 843 | |||
| 844 | // $ANTLR start "T__51" | ||
| 845 | public final void mT__51() throws RecognitionException { | ||
| 846 | try { | ||
| 847 | int _type = T__51; | ||
| 848 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 849 | // InternalSolverLanguage.g:47:7: ( 'real' ) | ||
| 850 | // InternalSolverLanguage.g:47:9: 'real' | ||
| 851 | { | ||
| 852 | match("real"); | ||
| 853 | |||
| 854 | |||
| 855 | } | ||
| 856 | |||
| 857 | state.type = _type; | ||
| 858 | state.channel = _channel; | ||
| 859 | } | ||
| 860 | finally { | ||
| 861 | } | ||
| 862 | } | ||
| 863 | // $ANTLR end "T__51" | ||
| 864 | |||
| 865 | // $ANTLR start "T__52" | ||
| 866 | public final void mT__52() throws RecognitionException { | ||
| 867 | try { | ||
| 868 | int _type = T__52; | ||
| 869 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 870 | // InternalSolverLanguage.g:48:7: ( '!=' ) | ||
| 871 | // InternalSolverLanguage.g:48:9: '!=' | ||
| 872 | { | ||
| 873 | match("!="); | ||
| 874 | |||
| 875 | |||
| 876 | } | ||
| 877 | |||
| 878 | state.type = _type; | ||
| 879 | state.channel = _channel; | ||
| 880 | } | ||
| 881 | finally { | ||
| 882 | } | ||
| 883 | } | ||
| 884 | // $ANTLR end "T__52" | ||
| 885 | |||
| 886 | // $ANTLR start "T__53" | ||
| 887 | public final void mT__53() throws RecognitionException { | ||
| 888 | try { | ||
| 889 | int _type = T__53; | ||
| 890 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 891 | // InternalSolverLanguage.g:49:7: ( '<' ) | ||
| 892 | // InternalSolverLanguage.g:49:9: '<' | ||
| 893 | { | ||
| 894 | match('<'); | ||
| 895 | |||
| 896 | } | ||
| 897 | |||
| 898 | state.type = _type; | ||
| 899 | state.channel = _channel; | ||
| 900 | } | ||
| 901 | finally { | ||
| 902 | } | ||
| 903 | } | ||
| 904 | // $ANTLR end "T__53" | ||
| 905 | |||
| 906 | // $ANTLR start "T__54" | ||
| 907 | public final void mT__54() throws RecognitionException { | ||
| 908 | try { | ||
| 909 | int _type = T__54; | ||
| 910 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 911 | // InternalSolverLanguage.g:50:7: ( '>' ) | ||
| 912 | // InternalSolverLanguage.g:50:9: '>' | ||
| 913 | { | ||
| 914 | match('>'); | ||
| 915 | |||
| 916 | } | ||
| 917 | |||
| 918 | state.type = _type; | ||
| 919 | state.channel = _channel; | ||
| 920 | } | ||
| 921 | finally { | ||
| 922 | } | ||
| 923 | } | ||
| 924 | // $ANTLR end "T__54" | ||
| 925 | |||
| 926 | // $ANTLR start "T__55" | ||
| 927 | public final void mT__55() throws RecognitionException { | ||
| 928 | try { | ||
| 929 | int _type = T__55; | ||
| 930 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 931 | // InternalSolverLanguage.g:51:7: ( 'in' ) | ||
| 932 | // InternalSolverLanguage.g:51:9: 'in' | ||
| 933 | { | ||
| 934 | match("in"); | ||
| 935 | |||
| 936 | |||
| 937 | } | ||
| 938 | |||
| 939 | state.type = _type; | ||
| 940 | state.channel = _channel; | ||
| 941 | } | ||
| 942 | finally { | ||
| 943 | } | ||
| 944 | } | ||
| 945 | // $ANTLR end "T__55" | ||
| 946 | |||
| 947 | // $ANTLR start "T__56" | ||
| 948 | public final void mT__56() throws RecognitionException { | ||
| 949 | try { | ||
| 950 | int _type = T__56; | ||
| 951 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 952 | // InternalSolverLanguage.g:52:7: ( '+' ) | ||
| 953 | // InternalSolverLanguage.g:52:9: '+' | ||
| 954 | { | ||
| 955 | match('+'); | ||
| 956 | |||
| 957 | } | ||
| 958 | |||
| 959 | state.type = _type; | ||
| 960 | state.channel = _channel; | ||
| 961 | } | ||
| 962 | finally { | ||
| 963 | } | ||
| 964 | } | ||
| 965 | // $ANTLR end "T__56" | ||
| 966 | |||
| 967 | // $ANTLR start "T__57" | ||
| 968 | public final void mT__57() throws RecognitionException { | ||
| 969 | try { | ||
| 970 | int _type = T__57; | ||
| 971 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 972 | // InternalSolverLanguage.g:53:7: ( '-' ) | ||
| 973 | // InternalSolverLanguage.g:53:9: '-' | ||
| 974 | { | ||
| 975 | match('-'); | ||
| 976 | |||
| 977 | } | ||
| 978 | |||
| 979 | state.type = _type; | ||
| 980 | state.channel = _channel; | ||
| 981 | } | ||
| 982 | finally { | ||
| 983 | } | ||
| 984 | } | ||
| 985 | // $ANTLR end "T__57" | ||
| 986 | |||
| 987 | // $ANTLR start "T__58" | ||
| 988 | public final void mT__58() throws RecognitionException { | ||
| 989 | try { | ||
| 990 | int _type = T__58; | ||
| 991 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 992 | // InternalSolverLanguage.g:54:7: ( '/' ) | ||
| 993 | // InternalSolverLanguage.g:54:9: '/' | ||
| 994 | { | ||
| 995 | match('/'); | ||
| 996 | |||
| 997 | } | ||
| 998 | |||
| 999 | state.type = _type; | ||
| 1000 | state.channel = _channel; | ||
| 1001 | } | ||
| 1002 | finally { | ||
| 1003 | } | ||
| 1004 | } | ||
| 1005 | // $ANTLR end "T__58" | ||
| 1006 | |||
| 1007 | // $ANTLR start "T__59" | ||
| 1008 | public final void mT__59() throws RecognitionException { | ||
| 1009 | try { | ||
| 1010 | int _type = T__59; | ||
| 1011 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1012 | // InternalSolverLanguage.g:55:7: ( '^' ) | ||
| 1013 | // InternalSolverLanguage.g:55:9: '^' | ||
| 1014 | { | ||
| 1015 | match('^'); | ||
| 1016 | |||
| 1017 | } | ||
| 1018 | |||
| 1019 | state.type = _type; | ||
| 1020 | state.channel = _channel; | ||
| 1021 | } | ||
| 1022 | finally { | ||
| 1023 | } | ||
| 1024 | } | ||
| 1025 | // $ANTLR end "T__59" | ||
| 1026 | |||
| 1027 | // $ANTLR start "T__60" | ||
| 1028 | public final void mT__60() throws RecognitionException { | ||
| 1029 | try { | ||
| 1030 | int _type = T__60; | ||
| 1031 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1032 | // InternalSolverLanguage.g:56:7: ( '!' ) | ||
| 1033 | // InternalSolverLanguage.g:56:9: '!' | ||
| 1034 | { | ||
| 1035 | match('!'); | ||
| 1036 | |||
| 1037 | } | ||
| 1038 | |||
| 1039 | state.type = _type; | ||
| 1040 | state.channel = _channel; | ||
| 1041 | } | ||
| 1042 | finally { | ||
| 1043 | } | ||
| 1044 | } | ||
| 1045 | // $ANTLR end "T__60" | ||
| 1046 | |||
| 1047 | // $ANTLR start "T__61" | ||
| 1048 | public final void mT__61() throws RecognitionException { | ||
| 1049 | try { | ||
| 1050 | int _type = T__61; | ||
| 1051 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1052 | // InternalSolverLanguage.g:57:7: ( 'may' ) | ||
| 1053 | // InternalSolverLanguage.g:57:9: 'may' | ||
| 1054 | { | ||
| 1055 | match("may"); | ||
| 1056 | |||
| 1057 | |||
| 1058 | } | ||
| 1059 | |||
| 1060 | state.type = _type; | ||
| 1061 | state.channel = _channel; | ||
| 1062 | } | ||
| 1063 | finally { | ||
| 1064 | } | ||
| 1065 | } | ||
| 1066 | // $ANTLR end "T__61" | ||
| 1067 | |||
| 1068 | // $ANTLR start "T__62" | ||
| 1069 | public final void mT__62() throws RecognitionException { | ||
| 1070 | try { | ||
| 1071 | int _type = T__62; | ||
| 1072 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1073 | // InternalSolverLanguage.g:58:7: ( 'must' ) | ||
| 1074 | // InternalSolverLanguage.g:58:9: 'must' | ||
| 1075 | { | ||
| 1076 | match("must"); | ||
| 1077 | |||
| 1078 | |||
| 1079 | } | ||
| 1080 | |||
| 1081 | state.type = _type; | ||
| 1082 | state.channel = _channel; | ||
| 1083 | } | ||
| 1084 | finally { | ||
| 1085 | } | ||
| 1086 | } | ||
| 1087 | // $ANTLR end "T__62" | ||
| 1088 | |||
| 1089 | // $ANTLR start "T__63" | ||
| 1090 | public final void mT__63() throws RecognitionException { | ||
| 1091 | try { | ||
| 1092 | int _type = T__63; | ||
| 1093 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1094 | // InternalSolverLanguage.g:59:7: ( 'current' ) | ||
| 1095 | // InternalSolverLanguage.g:59:9: 'current' | ||
| 1096 | { | ||
| 1097 | match("current"); | ||
| 1098 | |||
| 1099 | |||
| 1100 | } | ||
| 1101 | |||
| 1102 | state.type = _type; | ||
| 1103 | state.channel = _channel; | ||
| 1104 | } | ||
| 1105 | finally { | ||
| 1106 | } | ||
| 1107 | } | ||
| 1108 | // $ANTLR end "T__63" | ||
| 1109 | |||
| 1110 | // $ANTLR start "T__64" | ||
| 1111 | public final void mT__64() throws RecognitionException { | ||
| 1112 | try { | ||
| 1113 | int _type = T__64; | ||
| 1114 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1115 | // InternalSolverLanguage.g:60:7: ( 'only' ) | ||
| 1116 | // InternalSolverLanguage.g:60:9: 'only' | ||
| 1117 | { | ||
| 1118 | match("only"); | ||
| 1119 | |||
| 1120 | |||
| 1121 | } | ||
| 1122 | |||
| 1123 | state.type = _type; | ||
| 1124 | state.channel = _channel; | ||
| 1125 | } | ||
| 1126 | finally { | ||
| 1127 | } | ||
| 1128 | } | ||
| 1129 | // $ANTLR end "T__64" | ||
| 1130 | |||
| 1131 | // $ANTLR start "T__65" | ||
| 1132 | public final void mT__65() throws RecognitionException { | ||
| 1133 | try { | ||
| 1134 | int _type = T__65; | ||
| 1135 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1136 | // InternalSolverLanguage.g:61:7: ( 'sum' ) | ||
| 1137 | // InternalSolverLanguage.g:61:9: 'sum' | ||
| 1138 | { | ||
| 1139 | match("sum"); | ||
| 1140 | |||
| 1141 | |||
| 1142 | } | ||
| 1143 | |||
| 1144 | state.type = _type; | ||
| 1145 | state.channel = _channel; | ||
| 1146 | } | ||
| 1147 | finally { | ||
| 1148 | } | ||
| 1149 | } | ||
| 1150 | // $ANTLR end "T__65" | ||
| 1151 | |||
| 1152 | // $ANTLR start "T__66" | ||
| 1153 | public final void mT__66() throws RecognitionException { | ||
| 1154 | try { | ||
| 1155 | int _type = T__66; | ||
| 1156 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1157 | // InternalSolverLanguage.g:62:7: ( 'prod' ) | ||
| 1158 | // InternalSolverLanguage.g:62:9: 'prod' | ||
| 1159 | { | ||
| 1160 | match("prod"); | ||
| 1161 | |||
| 1162 | |||
| 1163 | } | ||
| 1164 | |||
| 1165 | state.type = _type; | ||
| 1166 | state.channel = _channel; | ||
| 1167 | } | ||
| 1168 | finally { | ||
| 1169 | } | ||
| 1170 | } | ||
| 1171 | // $ANTLR end "T__66" | ||
| 1172 | |||
| 1173 | // $ANTLR start "T__67" | ||
| 1174 | public final void mT__67() throws RecognitionException { | ||
| 1175 | try { | ||
| 1176 | int _type = T__67; | ||
| 1177 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1178 | // InternalSolverLanguage.g:63:7: ( 'avg' ) | ||
| 1179 | // InternalSolverLanguage.g:63:9: 'avg' | ||
| 1180 | { | ||
| 1181 | match("avg"); | ||
| 1182 | |||
| 1183 | |||
| 1184 | } | ||
| 1185 | |||
| 1186 | state.type = _type; | ||
| 1187 | state.channel = _channel; | ||
| 1188 | } | ||
| 1189 | finally { | ||
| 1190 | } | ||
| 1191 | } | ||
| 1192 | // $ANTLR end "T__67" | ||
| 1193 | |||
| 1194 | // $ANTLR start "T__68" | ||
| 1195 | public final void mT__68() throws RecognitionException { | ||
| 1196 | try { | ||
| 1197 | int _type = T__68; | ||
| 1198 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1199 | // InternalSolverLanguage.g:64:7: ( 'min' ) | ||
| 1200 | // InternalSolverLanguage.g:64:9: 'min' | ||
| 1201 | { | ||
| 1202 | match("min"); | ||
| 1203 | |||
| 1204 | |||
| 1205 | } | ||
| 1206 | |||
| 1207 | state.type = _type; | ||
| 1208 | state.channel = _channel; | ||
| 1209 | } | ||
| 1210 | finally { | ||
| 1211 | } | ||
| 1212 | } | ||
| 1213 | // $ANTLR end "T__68" | ||
| 1214 | |||
| 1215 | // $ANTLR start "T__69" | ||
| 1216 | public final void mT__69() throws RecognitionException { | ||
| 1217 | try { | ||
| 1218 | int _type = T__69; | ||
| 1219 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1220 | // InternalSolverLanguage.g:65:7: ( 'max' ) | ||
| 1221 | // InternalSolverLanguage.g:65:9: 'max' | ||
| 1222 | { | ||
| 1223 | match("max"); | ||
| 1224 | |||
| 1225 | |||
| 1226 | } | ||
| 1227 | |||
| 1228 | state.type = _type; | ||
| 1229 | state.channel = _channel; | ||
| 1230 | } | ||
| 1231 | finally { | ||
| 1232 | } | ||
| 1233 | } | ||
| 1234 | // $ANTLR end "T__69" | ||
| 1235 | |||
| 1236 | // $ANTLR start "T__70" | ||
| 1237 | public final void mT__70() throws RecognitionException { | ||
| 1238 | try { | ||
| 1239 | int _type = T__70; | ||
| 1240 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1241 | // InternalSolverLanguage.g:66:7: ( 'true' ) | ||
| 1242 | // InternalSolverLanguage.g:66:9: 'true' | ||
| 1243 | { | ||
| 1244 | match("true"); | ||
| 1245 | |||
| 1246 | |||
| 1247 | } | ||
| 1248 | |||
| 1249 | state.type = _type; | ||
| 1250 | state.channel = _channel; | ||
| 1251 | } | ||
| 1252 | finally { | ||
| 1253 | } | ||
| 1254 | } | ||
| 1255 | // $ANTLR end "T__70" | ||
| 1256 | |||
| 1257 | // $ANTLR start "T__71" | ||
| 1258 | public final void mT__71() throws RecognitionException { | ||
| 1259 | try { | ||
| 1260 | int _type = T__71; | ||
| 1261 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1262 | // InternalSolverLanguage.g:67:7: ( 'false' ) | ||
| 1263 | // InternalSolverLanguage.g:67:9: 'false' | ||
| 1264 | { | ||
| 1265 | match("false"); | ||
| 1266 | |||
| 1267 | |||
| 1268 | } | ||
| 1269 | |||
| 1270 | state.type = _type; | ||
| 1271 | state.channel = _channel; | ||
| 1272 | } | ||
| 1273 | finally { | ||
| 1274 | } | ||
| 1275 | } | ||
| 1276 | // $ANTLR end "T__71" | ||
| 1277 | |||
| 1278 | // $ANTLR start "T__72" | ||
| 1279 | public final void mT__72() throws RecognitionException { | ||
| 1280 | try { | ||
| 1281 | int _type = T__72; | ||
| 1282 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1283 | // InternalSolverLanguage.g:68:7: ( 'unknown' ) | ||
| 1284 | // InternalSolverLanguage.g:68:9: 'unknown' | ||
| 1285 | { | ||
| 1286 | match("unknown"); | ||
| 1287 | |||
| 1288 | |||
| 1289 | } | ||
| 1290 | |||
| 1291 | state.type = _type; | ||
| 1292 | state.channel = _channel; | ||
| 1293 | } | ||
| 1294 | finally { | ||
| 1295 | } | ||
| 1296 | } | ||
| 1297 | // $ANTLR end "T__72" | ||
| 1298 | |||
| 1299 | // $ANTLR start "T__73" | ||
| 1300 | public final void mT__73() throws RecognitionException { | ||
| 1301 | try { | ||
| 1302 | int _type = T__73; | ||
| 1303 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1304 | // InternalSolverLanguage.g:69:7: ( 'minimize' ) | ||
| 1305 | // InternalSolverLanguage.g:69:9: 'minimize' | ||
| 1306 | { | ||
| 1307 | match("minimize"); | ||
| 1308 | |||
| 1309 | |||
| 1310 | } | ||
| 1311 | |||
| 1312 | state.type = _type; | ||
| 1313 | state.channel = _channel; | ||
| 1314 | } | ||
| 1315 | finally { | ||
| 1316 | } | ||
| 1317 | } | ||
| 1318 | // $ANTLR end "T__73" | ||
| 1319 | |||
| 1320 | // $ANTLR start "T__74" | ||
| 1321 | public final void mT__74() throws RecognitionException { | ||
| 1322 | try { | ||
| 1323 | int _type = T__74; | ||
| 1324 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1325 | // InternalSolverLanguage.g:70:7: ( 'maximize' ) | ||
| 1326 | // InternalSolverLanguage.g:70:9: 'maximize' | ||
| 1327 | { | ||
| 1328 | match("maximize"); | ||
| 1329 | |||
| 1330 | |||
| 1331 | } | ||
| 1332 | |||
| 1333 | state.type = _type; | ||
| 1334 | state.channel = _channel; | ||
| 1335 | } | ||
| 1336 | finally { | ||
| 1337 | } | ||
| 1338 | } | ||
| 1339 | // $ANTLR end "T__74" | ||
| 1340 | |||
| 707 | // $ANTLR start "RULE_STRING" | 1341 | // $ANTLR start "RULE_STRING" |
| 708 | public final void mRULE_STRING() throws RecognitionException { | 1342 | public final void mRULE_STRING() throws RecognitionException { |
| 709 | try { | 1343 | try { |
| 710 | int _type = RULE_STRING; | 1344 | int _type = RULE_STRING; |
| 711 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1345 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 712 | // InternalSolverLanguage.g:2497:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | 1346 | // InternalSolverLanguage.g:3882:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) |
| 713 | // InternalSolverLanguage.g:2497:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | 1347 | // InternalSolverLanguage.g:3882:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' |
| 714 | { | 1348 | { |
| 715 | match('\"'); | 1349 | match('\"'); |
| 716 | // InternalSolverLanguage.g:2497:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | 1350 | // InternalSolverLanguage.g:3882:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* |
| 717 | loop1: | 1351 | loop1: |
| 718 | do { | 1352 | do { |
| 719 | int alt1=3; | 1353 | int alt1=3; |
| @@ -729,7 +1363,7 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 729 | 1363 | ||
| 730 | switch (alt1) { | 1364 | switch (alt1) { |
| 731 | case 1 : | 1365 | case 1 : |
| 732 | // InternalSolverLanguage.g:2497:20: '\\\\' . | 1366 | // InternalSolverLanguage.g:3882:20: '\\\\' . |
| 733 | { | 1367 | { |
| 734 | match('\\'); | 1368 | match('\\'); |
| 735 | matchAny(); | 1369 | matchAny(); |
| @@ -737,7 +1371,7 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 737 | } | 1371 | } |
| 738 | break; | 1372 | break; |
| 739 | case 2 : | 1373 | case 2 : |
| 740 | // InternalSolverLanguage.g:2497:27: ~ ( ( '\\\\' | '\"' ) ) | 1374 | // InternalSolverLanguage.g:3882:27: ~ ( ( '\\\\' | '\"' ) ) |
| 741 | { | 1375 | { |
| 742 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | 1376 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { |
| 743 | input.consume(); | 1377 | input.consume(); |
| @@ -769,24 +1403,152 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 769 | } | 1403 | } |
| 770 | // $ANTLR end "RULE_STRING" | 1404 | // $ANTLR end "RULE_STRING" |
| 771 | 1405 | ||
| 1406 | // $ANTLR start "RULE_QUOTED_ID" | ||
| 1407 | public final void mRULE_QUOTED_ID() throws RecognitionException { | ||
| 1408 | try { | ||
| 1409 | int _type = RULE_QUOTED_ID; | ||
| 1410 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1411 | // InternalSolverLanguage.g:3884:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
| 1412 | // InternalSolverLanguage.g:3884:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | ||
| 1413 | { | ||
| 1414 | match('\''); | ||
| 1415 | // InternalSolverLanguage.g:3884:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* | ||
| 1416 | loop2: | ||
| 1417 | do { | ||
| 1418 | int alt2=3; | ||
| 1419 | int LA2_0 = input.LA(1); | ||
| 1420 | |||
| 1421 | if ( (LA2_0=='\\') ) { | ||
| 1422 | alt2=1; | ||
| 1423 | } | ||
| 1424 | else if ( ((LA2_0>='\u0000' && LA2_0<='&')||(LA2_0>='(' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { | ||
| 1425 | alt2=2; | ||
| 1426 | } | ||
| 1427 | |||
| 1428 | |||
| 1429 | switch (alt2) { | ||
| 1430 | case 1 : | ||
| 1431 | // InternalSolverLanguage.g:3884:24: '\\\\' . | ||
| 1432 | { | ||
| 1433 | match('\\'); | ||
| 1434 | matchAny(); | ||
| 1435 | |||
| 1436 | } | ||
| 1437 | break; | ||
| 1438 | case 2 : | ||
| 1439 | // InternalSolverLanguage.g:3884:31: ~ ( ( '\\\\' | '\\'' ) ) | ||
| 1440 | { | ||
| 1441 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
| 1442 | input.consume(); | ||
| 1443 | |||
| 1444 | } | ||
| 1445 | else { | ||
| 1446 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 1447 | recover(mse); | ||
| 1448 | throw mse;} | ||
| 1449 | |||
| 1450 | |||
| 1451 | } | ||
| 1452 | break; | ||
| 1453 | |||
| 1454 | default : | ||
| 1455 | break loop2; | ||
| 1456 | } | ||
| 1457 | } while (true); | ||
| 1458 | |||
| 1459 | match('\''); | ||
| 1460 | |||
| 1461 | } | ||
| 1462 | |||
| 1463 | state.type = _type; | ||
| 1464 | state.channel = _channel; | ||
| 1465 | } | ||
| 1466 | finally { | ||
| 1467 | } | ||
| 1468 | } | ||
| 1469 | // $ANTLR end "RULE_QUOTED_ID" | ||
| 1470 | |||
| 1471 | // $ANTLR start "RULE_PLUS" | ||
| 1472 | public final void mRULE_PLUS() throws RecognitionException { | ||
| 1473 | try { | ||
| 1474 | int _type = RULE_PLUS; | ||
| 1475 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1476 | // InternalSolverLanguage.g:3886:11: ( 'synthetic::plus' ) | ||
| 1477 | // InternalSolverLanguage.g:3886:13: 'synthetic::plus' | ||
| 1478 | { | ||
| 1479 | match("synthetic::plus"); | ||
| 1480 | |||
| 1481 | |||
| 1482 | } | ||
| 1483 | |||
| 1484 | state.type = _type; | ||
| 1485 | state.channel = _channel; | ||
| 1486 | } | ||
| 1487 | finally { | ||
| 1488 | } | ||
| 1489 | } | ||
| 1490 | // $ANTLR end "RULE_PLUS" | ||
| 1491 | |||
| 1492 | // $ANTLR start "RULE_STAR" | ||
| 1493 | public final void mRULE_STAR() throws RecognitionException { | ||
| 1494 | try { | ||
| 1495 | int _type = RULE_STAR; | ||
| 1496 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1497 | // InternalSolverLanguage.g:3888:11: ( 'synthetic::star' ) | ||
| 1498 | // InternalSolverLanguage.g:3888:13: 'synthetic::star' | ||
| 1499 | { | ||
| 1500 | match("synthetic::star"); | ||
| 1501 | |||
| 1502 | |||
| 1503 | } | ||
| 1504 | |||
| 1505 | state.type = _type; | ||
| 1506 | state.channel = _channel; | ||
| 1507 | } | ||
| 1508 | finally { | ||
| 1509 | } | ||
| 1510 | } | ||
| 1511 | // $ANTLR end "RULE_STAR" | ||
| 1512 | |||
| 1513 | // $ANTLR start "RULE_DOT" | ||
| 1514 | public final void mRULE_DOT() throws RecognitionException { | ||
| 1515 | try { | ||
| 1516 | int _type = RULE_DOT; | ||
| 1517 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1518 | // InternalSolverLanguage.g:3890:10: ( 'synthetic::dot' ) | ||
| 1519 | // InternalSolverLanguage.g:3890:12: 'synthetic::dot' | ||
| 1520 | { | ||
| 1521 | match("synthetic::dot"); | ||
| 1522 | |||
| 1523 | |||
| 1524 | } | ||
| 1525 | |||
| 1526 | state.type = _type; | ||
| 1527 | state.channel = _channel; | ||
| 1528 | } | ||
| 1529 | finally { | ||
| 1530 | } | ||
| 1531 | } | ||
| 1532 | // $ANTLR end "RULE_DOT" | ||
| 1533 | |||
| 772 | // $ANTLR start "RULE_ID" | 1534 | // $ANTLR start "RULE_ID" |
| 773 | public final void mRULE_ID() throws RecognitionException { | 1535 | public final void mRULE_ID() throws RecognitionException { |
| 774 | try { | 1536 | try { |
| 775 | int _type = RULE_ID; | 1537 | int _type = RULE_ID; |
| 776 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1538 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 777 | // InternalSolverLanguage.g:2499:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | 1539 | // InternalSolverLanguage.g:3892:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) |
| 778 | // InternalSolverLanguage.g:2499:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | 1540 | // InternalSolverLanguage.g:3892:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* |
| 779 | { | 1541 | { |
| 780 | // InternalSolverLanguage.g:2499:11: ( '^' )? | 1542 | // InternalSolverLanguage.g:3892:11: ( '^' )? |
| 781 | int alt2=2; | 1543 | int alt3=2; |
| 782 | int LA2_0 = input.LA(1); | 1544 | int LA3_0 = input.LA(1); |
| 783 | 1545 | ||
| 784 | if ( (LA2_0=='^') ) { | 1546 | if ( (LA3_0=='^') ) { |
| 785 | alt2=1; | 1547 | alt3=1; |
| 786 | } | 1548 | } |
| 787 | switch (alt2) { | 1549 | switch (alt3) { |
| 788 | case 1 : | 1550 | case 1 : |
| 789 | // InternalSolverLanguage.g:2499:11: '^' | 1551 | // InternalSolverLanguage.g:3892:11: '^' |
| 790 | { | 1552 | { |
| 791 | match('^'); | 1553 | match('^'); |
| 792 | 1554 | ||
| @@ -804,18 +1566,18 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 804 | recover(mse); | 1566 | recover(mse); |
| 805 | throw mse;} | 1567 | throw mse;} |
| 806 | 1568 | ||
| 807 | // InternalSolverLanguage.g:2499:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | 1569 | // InternalSolverLanguage.g:3892:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* |
| 808 | loop3: | 1570 | loop4: |
| 809 | do { | 1571 | do { |
| 810 | int alt3=2; | 1572 | int alt4=2; |
| 811 | int LA3_0 = input.LA(1); | 1573 | int LA4_0 = input.LA(1); |
| 812 | 1574 | ||
| 813 | if ( ((LA3_0>='0' && LA3_0<='9')||(LA3_0>='A' && LA3_0<='Z')||LA3_0=='_'||(LA3_0>='a' && LA3_0<='z')) ) { | 1575 | if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='Z')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='z')) ) { |
| 814 | alt3=1; | 1576 | alt4=1; |
| 815 | } | 1577 | } |
| 816 | 1578 | ||
| 817 | 1579 | ||
| 818 | switch (alt3) { | 1580 | switch (alt4) { |
| 819 | case 1 : | 1581 | case 1 : |
| 820 | // InternalSolverLanguage.g: | 1582 | // InternalSolverLanguage.g: |
| 821 | { | 1583 | { |
| @@ -833,7 +1595,7 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 833 | break; | 1595 | break; |
| 834 | 1596 | ||
| 835 | default : | 1597 | default : |
| 836 | break loop3; | 1598 | break loop4; |
| 837 | } | 1599 | } |
| 838 | } while (true); | 1600 | } while (true); |
| 839 | 1601 | ||
| @@ -853,24 +1615,24 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 853 | try { | 1615 | try { |
| 854 | int _type = RULE_INT; | 1616 | int _type = RULE_INT; |
| 855 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1617 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 856 | // InternalSolverLanguage.g:2501:10: ( ( '0' .. '9' )+ ) | 1618 | // InternalSolverLanguage.g:3894:10: ( ( '0' .. '9' )+ ) |
| 857 | // InternalSolverLanguage.g:2501:12: ( '0' .. '9' )+ | 1619 | // InternalSolverLanguage.g:3894:12: ( '0' .. '9' )+ |
| 858 | { | 1620 | { |
| 859 | // InternalSolverLanguage.g:2501:12: ( '0' .. '9' )+ | 1621 | // InternalSolverLanguage.g:3894:12: ( '0' .. '9' )+ |
| 860 | int cnt4=0; | 1622 | int cnt5=0; |
| 861 | loop4: | 1623 | loop5: |
| 862 | do { | 1624 | do { |
| 863 | int alt4=2; | 1625 | int alt5=2; |
| 864 | int LA4_0 = input.LA(1); | 1626 | int LA5_0 = input.LA(1); |
| 865 | 1627 | ||
| 866 | if ( ((LA4_0>='0' && LA4_0<='9')) ) { | 1628 | if ( ((LA5_0>='0' && LA5_0<='9')) ) { |
| 867 | alt4=1; | 1629 | alt5=1; |
| 868 | } | 1630 | } |
| 869 | 1631 | ||
| 870 | 1632 | ||
| 871 | switch (alt4) { | 1633 | switch (alt5) { |
| 872 | case 1 : | 1634 | case 1 : |
| 873 | // InternalSolverLanguage.g:2501:13: '0' .. '9' | 1635 | // InternalSolverLanguage.g:3894:13: '0' .. '9' |
| 874 | { | 1636 | { |
| 875 | matchRange('0','9'); | 1637 | matchRange('0','9'); |
| 876 | 1638 | ||
| @@ -878,12 +1640,12 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 878 | break; | 1640 | break; |
| 879 | 1641 | ||
| 880 | default : | 1642 | default : |
| 881 | if ( cnt4 >= 1 ) break loop4; | 1643 | if ( cnt5 >= 1 ) break loop5; |
| 882 | EarlyExitException eee = | 1644 | EarlyExitException eee = |
| 883 | new EarlyExitException(4, input); | 1645 | new EarlyExitException(5, input); |
| 884 | throw eee; | 1646 | throw eee; |
| 885 | } | 1647 | } |
| 886 | cnt4++; | 1648 | cnt5++; |
| 887 | } while (true); | 1649 | } while (true); |
| 888 | 1650 | ||
| 889 | 1651 | ||
| @@ -902,37 +1664,37 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 902 | try { | 1664 | try { |
| 903 | int _type = RULE_ML_COMMENT; | 1665 | int _type = RULE_ML_COMMENT; |
| 904 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1666 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 905 | // InternalSolverLanguage.g:2503:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | 1667 | // InternalSolverLanguage.g:3896:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) |
| 906 | // InternalSolverLanguage.g:2503:19: '/*' ( options {greedy=false; } : . )* '*/' | 1668 | // InternalSolverLanguage.g:3896:19: '/*' ( options {greedy=false; } : . )* '*/' |
| 907 | { | 1669 | { |
| 908 | match("/*"); | 1670 | match("/*"); |
| 909 | 1671 | ||
| 910 | // InternalSolverLanguage.g:2503:24: ( options {greedy=false; } : . )* | 1672 | // InternalSolverLanguage.g:3896:24: ( options {greedy=false; } : . )* |
| 911 | loop5: | 1673 | loop6: |
| 912 | do { | 1674 | do { |
| 913 | int alt5=2; | 1675 | int alt6=2; |
| 914 | int LA5_0 = input.LA(1); | 1676 | int LA6_0 = input.LA(1); |
| 915 | 1677 | ||
| 916 | if ( (LA5_0=='*') ) { | 1678 | if ( (LA6_0=='*') ) { |
| 917 | int LA5_1 = input.LA(2); | 1679 | int LA6_1 = input.LA(2); |
| 918 | 1680 | ||
| 919 | if ( (LA5_1=='/') ) { | 1681 | if ( (LA6_1=='/') ) { |
| 920 | alt5=2; | 1682 | alt6=2; |
| 921 | } | 1683 | } |
| 922 | else if ( ((LA5_1>='\u0000' && LA5_1<='.')||(LA5_1>='0' && LA5_1<='\uFFFF')) ) { | 1684 | else if ( ((LA6_1>='\u0000' && LA6_1<='.')||(LA6_1>='0' && LA6_1<='\uFFFF')) ) { |
| 923 | alt5=1; | 1685 | alt6=1; |
| 924 | } | 1686 | } |
| 925 | 1687 | ||
| 926 | 1688 | ||
| 927 | } | 1689 | } |
| 928 | else if ( ((LA5_0>='\u0000' && LA5_0<=')')||(LA5_0>='+' && LA5_0<='\uFFFF')) ) { | 1690 | else if ( ((LA6_0>='\u0000' && LA6_0<=')')||(LA6_0>='+' && LA6_0<='\uFFFF')) ) { |
| 929 | alt5=1; | 1691 | alt6=1; |
| 930 | } | 1692 | } |
| 931 | 1693 | ||
| 932 | 1694 | ||
| 933 | switch (alt5) { | 1695 | switch (alt6) { |
| 934 | case 1 : | 1696 | case 1 : |
| 935 | // InternalSolverLanguage.g:2503:52: . | 1697 | // InternalSolverLanguage.g:3896:52: . |
| 936 | { | 1698 | { |
| 937 | matchAny(); | 1699 | matchAny(); |
| 938 | 1700 | ||
| @@ -940,7 +1702,7 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 940 | break; | 1702 | break; |
| 941 | 1703 | ||
| 942 | default : | 1704 | default : |
| 943 | break loop5; | 1705 | break loop6; |
| 944 | } | 1706 | } |
| 945 | } while (true); | 1707 | } while (true); |
| 946 | 1708 | ||
| @@ -962,25 +1724,25 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 962 | try { | 1724 | try { |
| 963 | int _type = RULE_SL_COMMENT; | 1725 | int _type = RULE_SL_COMMENT; |
| 964 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1726 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 965 | // InternalSolverLanguage.g:2505:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | 1727 | // InternalSolverLanguage.g:3898:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) |
| 966 | // InternalSolverLanguage.g:2505:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | 1728 | // InternalSolverLanguage.g:3898:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? |
| 967 | { | 1729 | { |
| 968 | match("//"); | 1730 | match("//"); |
| 969 | 1731 | ||
| 970 | // InternalSolverLanguage.g:2505:24: (~ ( ( '\\n' | '\\r' ) ) )* | 1732 | // InternalSolverLanguage.g:3898:24: (~ ( ( '\\n' | '\\r' ) ) )* |
| 971 | loop6: | 1733 | loop7: |
| 972 | do { | 1734 | do { |
| 973 | int alt6=2; | 1735 | int alt7=2; |
| 974 | int LA6_0 = input.LA(1); | 1736 | int LA7_0 = input.LA(1); |
| 975 | 1737 | ||
| 976 | if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) { | 1738 | if ( ((LA7_0>='\u0000' && LA7_0<='\t')||(LA7_0>='\u000B' && LA7_0<='\f')||(LA7_0>='\u000E' && LA7_0<='\uFFFF')) ) { |
| 977 | alt6=1; | 1739 | alt7=1; |
| 978 | } | 1740 | } |
| 979 | 1741 | ||
| 980 | 1742 | ||
| 981 | switch (alt6) { | 1743 | switch (alt7) { |
| 982 | case 1 : | 1744 | case 1 : |
| 983 | // InternalSolverLanguage.g:2505:24: ~ ( ( '\\n' | '\\r' ) ) | 1745 | // InternalSolverLanguage.g:3898:24: ~ ( ( '\\n' | '\\r' ) ) |
| 984 | { | 1746 | { |
| 985 | 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') ) { | 1747 | 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') ) { |
| 986 | input.consume(); | 1748 | input.consume(); |
| @@ -996,31 +1758,31 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 996 | break; | 1758 | break; |
| 997 | 1759 | ||
| 998 | default : | 1760 | default : |
| 999 | break loop6; | 1761 | break loop7; |
| 1000 | } | 1762 | } |
| 1001 | } while (true); | 1763 | } while (true); |
| 1002 | 1764 | ||
| 1003 | // InternalSolverLanguage.g:2505:40: ( ( '\\r' )? '\\n' )? | 1765 | // InternalSolverLanguage.g:3898:40: ( ( '\\r' )? '\\n' )? |
| 1004 | int alt8=2; | 1766 | int alt9=2; |
| 1005 | int LA8_0 = input.LA(1); | 1767 | int LA9_0 = input.LA(1); |
| 1006 | 1768 | ||
| 1007 | if ( (LA8_0=='\n'||LA8_0=='\r') ) { | 1769 | if ( (LA9_0=='\n'||LA9_0=='\r') ) { |
| 1008 | alt8=1; | 1770 | alt9=1; |
| 1009 | } | 1771 | } |
| 1010 | switch (alt8) { | 1772 | switch (alt9) { |
| 1011 | case 1 : | 1773 | case 1 : |
| 1012 | // InternalSolverLanguage.g:2505:41: ( '\\r' )? '\\n' | 1774 | // InternalSolverLanguage.g:3898:41: ( '\\r' )? '\\n' |
| 1013 | { | 1775 | { |
| 1014 | // InternalSolverLanguage.g:2505:41: ( '\\r' )? | 1776 | // InternalSolverLanguage.g:3898:41: ( '\\r' )? |
| 1015 | int alt7=2; | 1777 | int alt8=2; |
| 1016 | int LA7_0 = input.LA(1); | 1778 | int LA8_0 = input.LA(1); |
| 1017 | 1779 | ||
| 1018 | if ( (LA7_0=='\r') ) { | 1780 | if ( (LA8_0=='\r') ) { |
| 1019 | alt7=1; | 1781 | alt8=1; |
| 1020 | } | 1782 | } |
| 1021 | switch (alt7) { | 1783 | switch (alt8) { |
| 1022 | case 1 : | 1784 | case 1 : |
| 1023 | // InternalSolverLanguage.g:2505:41: '\\r' | 1785 | // InternalSolverLanguage.g:3898:41: '\\r' |
| 1024 | { | 1786 | { |
| 1025 | match('\r'); | 1787 | match('\r'); |
| 1026 | 1788 | ||
| @@ -1052,22 +1814,22 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 1052 | try { | 1814 | try { |
| 1053 | int _type = RULE_WS; | 1815 | int _type = RULE_WS; |
| 1054 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1816 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 1055 | // InternalSolverLanguage.g:2507:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | 1817 | // InternalSolverLanguage.g:3900:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) |
| 1056 | // InternalSolverLanguage.g:2507:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | 1818 | // InternalSolverLanguage.g:3900:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ |
| 1057 | { | 1819 | { |
| 1058 | // InternalSolverLanguage.g:2507:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | 1820 | // InternalSolverLanguage.g:3900:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ |
| 1059 | int cnt9=0; | 1821 | int cnt10=0; |
| 1060 | loop9: | 1822 | loop10: |
| 1061 | do { | 1823 | do { |
| 1062 | int alt9=2; | 1824 | int alt10=2; |
| 1063 | int LA9_0 = input.LA(1); | 1825 | int LA10_0 = input.LA(1); |
| 1064 | 1826 | ||
| 1065 | if ( ((LA9_0>='\t' && LA9_0<='\n')||LA9_0=='\r'||LA9_0==' ') ) { | 1827 | if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) { |
| 1066 | alt9=1; | 1828 | alt10=1; |
| 1067 | } | 1829 | } |
| 1068 | 1830 | ||
| 1069 | 1831 | ||
| 1070 | switch (alt9) { | 1832 | switch (alt10) { |
| 1071 | case 1 : | 1833 | case 1 : |
| 1072 | // InternalSolverLanguage.g: | 1834 | // InternalSolverLanguage.g: |
| 1073 | { | 1835 | { |
| @@ -1085,12 +1847,12 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 1085 | break; | 1847 | break; |
| 1086 | 1848 | ||
| 1087 | default : | 1849 | default : |
| 1088 | if ( cnt9 >= 1 ) break loop9; | 1850 | if ( cnt10 >= 1 ) break loop10; |
| 1089 | EarlyExitException eee = | 1851 | EarlyExitException eee = |
| 1090 | new EarlyExitException(9, input); | 1852 | new EarlyExitException(10, input); |
| 1091 | throw eee; | 1853 | throw eee; |
| 1092 | } | 1854 | } |
| 1093 | cnt9++; | 1855 | cnt10++; |
| 1094 | } while (true); | 1856 | } while (true); |
| 1095 | 1857 | ||
| 1096 | 1858 | ||
| @@ -1109,8 +1871,8 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 1109 | try { | 1871 | try { |
| 1110 | int _type = RULE_ANY_OTHER; | 1872 | int _type = RULE_ANY_OTHER; |
| 1111 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1873 | int _channel = DEFAULT_TOKEN_CHANNEL; |
| 1112 | // InternalSolverLanguage.g:2509:16: ( . ) | 1874 | // InternalSolverLanguage.g:3902:16: ( . ) |
| 1113 | // InternalSolverLanguage.g:2509:18: . | 1875 | // InternalSolverLanguage.g:3902:18: . |
| 1114 | { | 1876 | { |
| 1115 | matchAny(); | 1877 | matchAny(); |
| 1116 | 1878 | ||
| @@ -1125,271 +1887,502 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 1125 | // $ANTLR end "RULE_ANY_OTHER" | 1887 | // $ANTLR end "RULE_ANY_OTHER" |
| 1126 | 1888 | ||
| 1127 | public void mTokens() throws RecognitionException { | 1889 | public void mTokens() throws RecognitionException { |
| 1128 | // 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 | T__41 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) | 1890 | // InternalSolverLanguage.g:1:8: ( 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 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | RULE_STRING | RULE_QUOTED_ID | RULE_PLUS | RULE_STAR | RULE_DOT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) |
| 1129 | int alt10=38; | 1891 | int alt11=71; |
| 1130 | alt10 = dfa10.predict(input); | 1892 | alt11 = dfa11.predict(input); |
| 1131 | switch (alt10) { | 1893 | switch (alt11) { |
| 1132 | case 1 : | 1894 | case 1 : |
| 1133 | // InternalSolverLanguage.g:1:10: T__11 | 1895 | // InternalSolverLanguage.g:1:10: T__15 |
| 1134 | { | 1896 | { |
| 1135 | mT__11(); | 1897 | mT__15(); |
| 1136 | 1898 | ||
| 1137 | } | 1899 | } |
| 1138 | break; | 1900 | break; |
| 1139 | case 2 : | 1901 | case 2 : |
| 1140 | // InternalSolverLanguage.g:1:16: T__12 | 1902 | // InternalSolverLanguage.g:1:16: T__16 |
| 1141 | { | 1903 | { |
| 1142 | mT__12(); | 1904 | mT__16(); |
| 1143 | 1905 | ||
| 1144 | } | 1906 | } |
| 1145 | break; | 1907 | break; |
| 1146 | case 3 : | 1908 | case 3 : |
| 1147 | // InternalSolverLanguage.g:1:22: T__13 | 1909 | // InternalSolverLanguage.g:1:22: T__17 |
| 1148 | { | 1910 | { |
| 1149 | mT__13(); | 1911 | mT__17(); |
| 1150 | 1912 | ||
| 1151 | } | 1913 | } |
| 1152 | break; | 1914 | break; |
| 1153 | case 4 : | 1915 | case 4 : |
| 1154 | // InternalSolverLanguage.g:1:28: T__14 | 1916 | // InternalSolverLanguage.g:1:28: T__18 |
| 1155 | { | 1917 | { |
| 1156 | mT__14(); | 1918 | mT__18(); |
| 1157 | 1919 | ||
| 1158 | } | 1920 | } |
| 1159 | break; | 1921 | break; |
| 1160 | case 5 : | 1922 | case 5 : |
| 1161 | // InternalSolverLanguage.g:1:34: T__15 | 1923 | // InternalSolverLanguage.g:1:34: T__19 |
| 1162 | { | 1924 | { |
| 1163 | mT__15(); | 1925 | mT__19(); |
| 1164 | 1926 | ||
| 1165 | } | 1927 | } |
| 1166 | break; | 1928 | break; |
| 1167 | case 6 : | 1929 | case 6 : |
| 1168 | // InternalSolverLanguage.g:1:40: T__16 | 1930 | // InternalSolverLanguage.g:1:40: T__20 |
| 1169 | { | 1931 | { |
| 1170 | mT__16(); | 1932 | mT__20(); |
| 1171 | 1933 | ||
| 1172 | } | 1934 | } |
| 1173 | break; | 1935 | break; |
| 1174 | case 7 : | 1936 | case 7 : |
| 1175 | // InternalSolverLanguage.g:1:46: T__17 | 1937 | // InternalSolverLanguage.g:1:46: T__21 |
| 1176 | { | 1938 | { |
| 1177 | mT__17(); | 1939 | mT__21(); |
| 1178 | 1940 | ||
| 1179 | } | 1941 | } |
| 1180 | break; | 1942 | break; |
| 1181 | case 8 : | 1943 | case 8 : |
| 1182 | // InternalSolverLanguage.g:1:52: T__18 | 1944 | // InternalSolverLanguage.g:1:52: T__22 |
| 1183 | { | 1945 | { |
| 1184 | mT__18(); | 1946 | mT__22(); |
| 1185 | 1947 | ||
| 1186 | } | 1948 | } |
| 1187 | break; | 1949 | break; |
| 1188 | case 9 : | 1950 | case 9 : |
| 1189 | // InternalSolverLanguage.g:1:58: T__19 | 1951 | // InternalSolverLanguage.g:1:58: T__23 |
| 1190 | { | 1952 | { |
| 1191 | mT__19(); | 1953 | mT__23(); |
| 1192 | 1954 | ||
| 1193 | } | 1955 | } |
| 1194 | break; | 1956 | break; |
| 1195 | case 10 : | 1957 | case 10 : |
| 1196 | // InternalSolverLanguage.g:1:64: T__20 | 1958 | // InternalSolverLanguage.g:1:64: T__24 |
| 1197 | { | 1959 | { |
| 1198 | mT__20(); | 1960 | mT__24(); |
| 1199 | 1961 | ||
| 1200 | } | 1962 | } |
| 1201 | break; | 1963 | break; |
| 1202 | case 11 : | 1964 | case 11 : |
| 1203 | // InternalSolverLanguage.g:1:70: T__21 | 1965 | // InternalSolverLanguage.g:1:70: T__25 |
| 1204 | { | 1966 | { |
| 1205 | mT__21(); | 1967 | mT__25(); |
| 1206 | 1968 | ||
| 1207 | } | 1969 | } |
| 1208 | break; | 1970 | break; |
| 1209 | case 12 : | 1971 | case 12 : |
| 1210 | // InternalSolverLanguage.g:1:76: T__22 | 1972 | // InternalSolverLanguage.g:1:76: T__26 |
| 1211 | { | 1973 | { |
| 1212 | mT__22(); | 1974 | mT__26(); |
| 1213 | 1975 | ||
| 1214 | } | 1976 | } |
| 1215 | break; | 1977 | break; |
| 1216 | case 13 : | 1978 | case 13 : |
| 1217 | // InternalSolverLanguage.g:1:82: T__23 | 1979 | // InternalSolverLanguage.g:1:82: T__27 |
| 1218 | { | 1980 | { |
| 1219 | mT__23(); | 1981 | mT__27(); |
| 1220 | 1982 | ||
| 1221 | } | 1983 | } |
| 1222 | break; | 1984 | break; |
| 1223 | case 14 : | 1985 | case 14 : |
| 1224 | // InternalSolverLanguage.g:1:88: T__24 | 1986 | // InternalSolverLanguage.g:1:88: T__28 |
| 1225 | { | 1987 | { |
| 1226 | mT__24(); | 1988 | mT__28(); |
| 1227 | 1989 | ||
| 1228 | } | 1990 | } |
| 1229 | break; | 1991 | break; |
| 1230 | case 15 : | 1992 | case 15 : |
| 1231 | // InternalSolverLanguage.g:1:94: T__25 | 1993 | // InternalSolverLanguage.g:1:94: T__29 |
| 1232 | { | 1994 | { |
| 1233 | mT__25(); | 1995 | mT__29(); |
| 1234 | 1996 | ||
| 1235 | } | 1997 | } |
| 1236 | break; | 1998 | break; |
| 1237 | case 16 : | 1999 | case 16 : |
| 1238 | // InternalSolverLanguage.g:1:100: T__26 | 2000 | // InternalSolverLanguage.g:1:100: T__30 |
| 1239 | { | 2001 | { |
| 1240 | mT__26(); | 2002 | mT__30(); |
| 1241 | 2003 | ||
| 1242 | } | 2004 | } |
| 1243 | break; | 2005 | break; |
| 1244 | case 17 : | 2006 | case 17 : |
| 1245 | // InternalSolverLanguage.g:1:106: T__27 | 2007 | // InternalSolverLanguage.g:1:106: T__31 |
| 1246 | { | 2008 | { |
| 1247 | mT__27(); | 2009 | mT__31(); |
| 1248 | 2010 | ||
| 1249 | } | 2011 | } |
| 1250 | break; | 2012 | break; |
| 1251 | case 18 : | 2013 | case 18 : |
| 1252 | // InternalSolverLanguage.g:1:112: T__28 | 2014 | // InternalSolverLanguage.g:1:112: T__32 |
| 1253 | { | 2015 | { |
| 1254 | mT__28(); | 2016 | mT__32(); |
| 1255 | 2017 | ||
| 1256 | } | 2018 | } |
| 1257 | break; | 2019 | break; |
| 1258 | case 19 : | 2020 | case 19 : |
| 1259 | // InternalSolverLanguage.g:1:118: T__29 | 2021 | // InternalSolverLanguage.g:1:118: T__33 |
| 1260 | { | 2022 | { |
| 1261 | mT__29(); | 2023 | mT__33(); |
| 1262 | 2024 | ||
| 1263 | } | 2025 | } |
| 1264 | break; | 2026 | break; |
| 1265 | case 20 : | 2027 | case 20 : |
| 1266 | // InternalSolverLanguage.g:1:124: T__30 | 2028 | // InternalSolverLanguage.g:1:124: T__34 |
| 1267 | { | 2029 | { |
| 1268 | mT__30(); | 2030 | mT__34(); |
| 1269 | 2031 | ||
| 1270 | } | 2032 | } |
| 1271 | break; | 2033 | break; |
| 1272 | case 21 : | 2034 | case 21 : |
| 1273 | // InternalSolverLanguage.g:1:130: T__31 | 2035 | // InternalSolverLanguage.g:1:130: T__35 |
| 1274 | { | 2036 | { |
| 1275 | mT__31(); | 2037 | mT__35(); |
| 1276 | 2038 | ||
| 1277 | } | 2039 | } |
| 1278 | break; | 2040 | break; |
| 1279 | case 22 : | 2041 | case 22 : |
| 1280 | // InternalSolverLanguage.g:1:136: T__32 | 2042 | // InternalSolverLanguage.g:1:136: T__36 |
| 1281 | { | 2043 | { |
| 1282 | mT__32(); | 2044 | mT__36(); |
| 1283 | 2045 | ||
| 1284 | } | 2046 | } |
| 1285 | break; | 2047 | break; |
| 1286 | case 23 : | 2048 | case 23 : |
| 1287 | // InternalSolverLanguage.g:1:142: T__33 | 2049 | // InternalSolverLanguage.g:1:142: T__37 |
| 1288 | { | 2050 | { |
| 1289 | mT__33(); | 2051 | mT__37(); |
| 1290 | 2052 | ||
| 1291 | } | 2053 | } |
| 1292 | break; | 2054 | break; |
| 1293 | case 24 : | 2055 | case 24 : |
| 1294 | // InternalSolverLanguage.g:1:148: T__34 | 2056 | // InternalSolverLanguage.g:1:148: T__38 |
| 1295 | { | 2057 | { |
| 1296 | mT__34(); | 2058 | mT__38(); |
| 1297 | 2059 | ||
| 1298 | } | 2060 | } |
| 1299 | break; | 2061 | break; |
| 1300 | case 25 : | 2062 | case 25 : |
| 1301 | // InternalSolverLanguage.g:1:154: T__35 | 2063 | // InternalSolverLanguage.g:1:154: T__39 |
| 1302 | { | 2064 | { |
| 1303 | mT__35(); | 2065 | mT__39(); |
| 1304 | 2066 | ||
| 1305 | } | 2067 | } |
| 1306 | break; | 2068 | break; |
| 1307 | case 26 : | 2069 | case 26 : |
| 1308 | // InternalSolverLanguage.g:1:160: T__36 | 2070 | // InternalSolverLanguage.g:1:160: T__40 |
| 1309 | { | 2071 | { |
| 1310 | mT__36(); | 2072 | mT__40(); |
| 1311 | 2073 | ||
| 1312 | } | 2074 | } |
| 1313 | break; | 2075 | break; |
| 1314 | case 27 : | 2076 | case 27 : |
| 1315 | // InternalSolverLanguage.g:1:166: T__37 | 2077 | // InternalSolverLanguage.g:1:166: T__41 |
| 1316 | { | 2078 | { |
| 1317 | mT__37(); | 2079 | mT__41(); |
| 1318 | 2080 | ||
| 1319 | } | 2081 | } |
| 1320 | break; | 2082 | break; |
| 1321 | case 28 : | 2083 | case 28 : |
| 1322 | // InternalSolverLanguage.g:1:172: T__38 | 2084 | // InternalSolverLanguage.g:1:172: T__42 |
| 1323 | { | 2085 | { |
| 1324 | mT__38(); | 2086 | mT__42(); |
| 1325 | 2087 | ||
| 1326 | } | 2088 | } |
| 1327 | break; | 2089 | break; |
| 1328 | case 29 : | 2090 | case 29 : |
| 1329 | // InternalSolverLanguage.g:1:178: T__39 | 2091 | // InternalSolverLanguage.g:1:178: T__43 |
| 1330 | { | 2092 | { |
| 1331 | mT__39(); | 2093 | mT__43(); |
| 1332 | 2094 | ||
| 1333 | } | 2095 | } |
| 1334 | break; | 2096 | break; |
| 1335 | case 30 : | 2097 | case 30 : |
| 1336 | // InternalSolverLanguage.g:1:184: T__40 | 2098 | // InternalSolverLanguage.g:1:184: T__44 |
| 1337 | { | 2099 | { |
| 1338 | mT__40(); | 2100 | mT__44(); |
| 1339 | 2101 | ||
| 1340 | } | 2102 | } |
| 1341 | break; | 2103 | break; |
| 1342 | case 31 : | 2104 | case 31 : |
| 1343 | // InternalSolverLanguage.g:1:190: T__41 | 2105 | // InternalSolverLanguage.g:1:190: T__45 |
| 1344 | { | 2106 | { |
| 1345 | mT__41(); | 2107 | mT__45(); |
| 1346 | 2108 | ||
| 1347 | } | 2109 | } |
| 1348 | break; | 2110 | break; |
| 1349 | case 32 : | 2111 | case 32 : |
| 1350 | // InternalSolverLanguage.g:1:196: RULE_STRING | 2112 | // InternalSolverLanguage.g:1:196: T__46 |
| 1351 | { | 2113 | { |
| 1352 | mRULE_STRING(); | 2114 | mT__46(); |
| 1353 | 2115 | ||
| 1354 | } | 2116 | } |
| 1355 | break; | 2117 | break; |
| 1356 | case 33 : | 2118 | case 33 : |
| 1357 | // InternalSolverLanguage.g:1:208: RULE_ID | 2119 | // InternalSolverLanguage.g:1:202: T__47 |
| 1358 | { | 2120 | { |
| 1359 | mRULE_ID(); | 2121 | mT__47(); |
| 1360 | 2122 | ||
| 1361 | } | 2123 | } |
| 1362 | break; | 2124 | break; |
| 1363 | case 34 : | 2125 | case 34 : |
| 1364 | // InternalSolverLanguage.g:1:216: RULE_INT | 2126 | // InternalSolverLanguage.g:1:208: T__48 |
| 1365 | { | 2127 | { |
| 1366 | mRULE_INT(); | 2128 | mT__48(); |
| 1367 | 2129 | ||
| 1368 | } | 2130 | } |
| 1369 | break; | 2131 | break; |
| 1370 | case 35 : | 2132 | case 35 : |
| 1371 | // InternalSolverLanguage.g:1:225: RULE_ML_COMMENT | 2133 | // InternalSolverLanguage.g:1:214: T__49 |
| 1372 | { | 2134 | { |
| 1373 | mRULE_ML_COMMENT(); | 2135 | mT__49(); |
| 1374 | 2136 | ||
| 1375 | } | 2137 | } |
| 1376 | break; | 2138 | break; |
| 1377 | case 36 : | 2139 | case 36 : |
| 1378 | // InternalSolverLanguage.g:1:241: RULE_SL_COMMENT | 2140 | // InternalSolverLanguage.g:1:220: T__50 |
| 1379 | { | 2141 | { |
| 1380 | mRULE_SL_COMMENT(); | 2142 | mT__50(); |
| 1381 | 2143 | ||
| 1382 | } | 2144 | } |
| 1383 | break; | 2145 | break; |
| 1384 | case 37 : | 2146 | case 37 : |
| 1385 | // InternalSolverLanguage.g:1:257: RULE_WS | 2147 | // InternalSolverLanguage.g:1:226: T__51 |
| 1386 | { | 2148 | { |
| 1387 | mRULE_WS(); | 2149 | mT__51(); |
| 1388 | 2150 | ||
| 1389 | } | 2151 | } |
| 1390 | break; | 2152 | break; |
| 1391 | case 38 : | 2153 | case 38 : |
| 1392 | // InternalSolverLanguage.g:1:265: RULE_ANY_OTHER | 2154 | // InternalSolverLanguage.g:1:232: T__52 |
| 2155 | { | ||
| 2156 | mT__52(); | ||
| 2157 | |||
| 2158 | } | ||
| 2159 | break; | ||
| 2160 | case 39 : | ||
| 2161 | // InternalSolverLanguage.g:1:238: T__53 | ||
| 2162 | { | ||
| 2163 | mT__53(); | ||
| 2164 | |||
| 2165 | } | ||
| 2166 | break; | ||
| 2167 | case 40 : | ||
| 2168 | // InternalSolverLanguage.g:1:244: T__54 | ||
| 2169 | { | ||
| 2170 | mT__54(); | ||
| 2171 | |||
| 2172 | } | ||
| 2173 | break; | ||
| 2174 | case 41 : | ||
| 2175 | // InternalSolverLanguage.g:1:250: T__55 | ||
| 2176 | { | ||
| 2177 | mT__55(); | ||
| 2178 | |||
| 2179 | } | ||
| 2180 | break; | ||
| 2181 | case 42 : | ||
| 2182 | // InternalSolverLanguage.g:1:256: T__56 | ||
| 2183 | { | ||
| 2184 | mT__56(); | ||
| 2185 | |||
| 2186 | } | ||
| 2187 | break; | ||
| 2188 | case 43 : | ||
| 2189 | // InternalSolverLanguage.g:1:262: T__57 | ||
| 2190 | { | ||
| 2191 | mT__57(); | ||
| 2192 | |||
| 2193 | } | ||
| 2194 | break; | ||
| 2195 | case 44 : | ||
| 2196 | // InternalSolverLanguage.g:1:268: T__58 | ||
| 2197 | { | ||
| 2198 | mT__58(); | ||
| 2199 | |||
| 2200 | } | ||
| 2201 | break; | ||
| 2202 | case 45 : | ||
| 2203 | // InternalSolverLanguage.g:1:274: T__59 | ||
| 2204 | { | ||
| 2205 | mT__59(); | ||
| 2206 | |||
| 2207 | } | ||
| 2208 | break; | ||
| 2209 | case 46 : | ||
| 2210 | // InternalSolverLanguage.g:1:280: T__60 | ||
| 2211 | { | ||
| 2212 | mT__60(); | ||
| 2213 | |||
| 2214 | } | ||
| 2215 | break; | ||
| 2216 | case 47 : | ||
| 2217 | // InternalSolverLanguage.g:1:286: T__61 | ||
| 2218 | { | ||
| 2219 | mT__61(); | ||
| 2220 | |||
| 2221 | } | ||
| 2222 | break; | ||
| 2223 | case 48 : | ||
| 2224 | // InternalSolverLanguage.g:1:292: T__62 | ||
| 2225 | { | ||
| 2226 | mT__62(); | ||
| 2227 | |||
| 2228 | } | ||
| 2229 | break; | ||
| 2230 | case 49 : | ||
| 2231 | // InternalSolverLanguage.g:1:298: T__63 | ||
| 2232 | { | ||
| 2233 | mT__63(); | ||
| 2234 | |||
| 2235 | } | ||
| 2236 | break; | ||
| 2237 | case 50 : | ||
| 2238 | // InternalSolverLanguage.g:1:304: T__64 | ||
| 2239 | { | ||
| 2240 | mT__64(); | ||
| 2241 | |||
| 2242 | } | ||
| 2243 | break; | ||
| 2244 | case 51 : | ||
| 2245 | // InternalSolverLanguage.g:1:310: T__65 | ||
| 2246 | { | ||
| 2247 | mT__65(); | ||
| 2248 | |||
| 2249 | } | ||
| 2250 | break; | ||
| 2251 | case 52 : | ||
| 2252 | // InternalSolverLanguage.g:1:316: T__66 | ||
| 2253 | { | ||
| 2254 | mT__66(); | ||
| 2255 | |||
| 2256 | } | ||
| 2257 | break; | ||
| 2258 | case 53 : | ||
| 2259 | // InternalSolverLanguage.g:1:322: T__67 | ||
| 2260 | { | ||
| 2261 | mT__67(); | ||
| 2262 | |||
| 2263 | } | ||
| 2264 | break; | ||
| 2265 | case 54 : | ||
| 2266 | // InternalSolverLanguage.g:1:328: T__68 | ||
| 2267 | { | ||
| 2268 | mT__68(); | ||
| 2269 | |||
| 2270 | } | ||
| 2271 | break; | ||
| 2272 | case 55 : | ||
| 2273 | // InternalSolverLanguage.g:1:334: T__69 | ||
| 2274 | { | ||
| 2275 | mT__69(); | ||
| 2276 | |||
| 2277 | } | ||
| 2278 | break; | ||
| 2279 | case 56 : | ||
| 2280 | // InternalSolverLanguage.g:1:340: T__70 | ||
| 2281 | { | ||
| 2282 | mT__70(); | ||
| 2283 | |||
| 2284 | } | ||
| 2285 | break; | ||
| 2286 | case 57 : | ||
| 2287 | // InternalSolverLanguage.g:1:346: T__71 | ||
| 2288 | { | ||
| 2289 | mT__71(); | ||
| 2290 | |||
| 2291 | } | ||
| 2292 | break; | ||
| 2293 | case 58 : | ||
| 2294 | // InternalSolverLanguage.g:1:352: T__72 | ||
| 2295 | { | ||
| 2296 | mT__72(); | ||
| 2297 | |||
| 2298 | } | ||
| 2299 | break; | ||
| 2300 | case 59 : | ||
| 2301 | // InternalSolverLanguage.g:1:358: T__73 | ||
| 2302 | { | ||
| 2303 | mT__73(); | ||
| 2304 | |||
| 2305 | } | ||
| 2306 | break; | ||
| 2307 | case 60 : | ||
| 2308 | // InternalSolverLanguage.g:1:364: T__74 | ||
| 2309 | { | ||
| 2310 | mT__74(); | ||
| 2311 | |||
| 2312 | } | ||
| 2313 | break; | ||
| 2314 | case 61 : | ||
| 2315 | // InternalSolverLanguage.g:1:370: RULE_STRING | ||
| 2316 | { | ||
| 2317 | mRULE_STRING(); | ||
| 2318 | |||
| 2319 | } | ||
| 2320 | break; | ||
| 2321 | case 62 : | ||
| 2322 | // InternalSolverLanguage.g:1:382: RULE_QUOTED_ID | ||
| 2323 | { | ||
| 2324 | mRULE_QUOTED_ID(); | ||
| 2325 | |||
| 2326 | } | ||
| 2327 | break; | ||
| 2328 | case 63 : | ||
| 2329 | // InternalSolverLanguage.g:1:397: RULE_PLUS | ||
| 2330 | { | ||
| 2331 | mRULE_PLUS(); | ||
| 2332 | |||
| 2333 | } | ||
| 2334 | break; | ||
| 2335 | case 64 : | ||
| 2336 | // InternalSolverLanguage.g:1:407: RULE_STAR | ||
| 2337 | { | ||
| 2338 | mRULE_STAR(); | ||
| 2339 | |||
| 2340 | } | ||
| 2341 | break; | ||
| 2342 | case 65 : | ||
| 2343 | // InternalSolverLanguage.g:1:417: RULE_DOT | ||
| 2344 | { | ||
| 2345 | mRULE_DOT(); | ||
| 2346 | |||
| 2347 | } | ||
| 2348 | break; | ||
| 2349 | case 66 : | ||
| 2350 | // InternalSolverLanguage.g:1:426: RULE_ID | ||
| 2351 | { | ||
| 2352 | mRULE_ID(); | ||
| 2353 | |||
| 2354 | } | ||
| 2355 | break; | ||
| 2356 | case 67 : | ||
| 2357 | // InternalSolverLanguage.g:1:434: RULE_INT | ||
| 2358 | { | ||
| 2359 | mRULE_INT(); | ||
| 2360 | |||
| 2361 | } | ||
| 2362 | break; | ||
| 2363 | case 68 : | ||
| 2364 | // InternalSolverLanguage.g:1:443: RULE_ML_COMMENT | ||
| 2365 | { | ||
| 2366 | mRULE_ML_COMMENT(); | ||
| 2367 | |||
| 2368 | } | ||
| 2369 | break; | ||
| 2370 | case 69 : | ||
| 2371 | // InternalSolverLanguage.g:1:459: RULE_SL_COMMENT | ||
| 2372 | { | ||
| 2373 | mRULE_SL_COMMENT(); | ||
| 2374 | |||
| 2375 | } | ||
| 2376 | break; | ||
| 2377 | case 70 : | ||
| 2378 | // InternalSolverLanguage.g:1:475: RULE_WS | ||
| 2379 | { | ||
| 2380 | mRULE_WS(); | ||
| 2381 | |||
| 2382 | } | ||
| 2383 | break; | ||
| 2384 | case 71 : | ||
| 2385 | // InternalSolverLanguage.g:1:483: RULE_ANY_OTHER | ||
| 1393 | { | 2386 | { |
| 1394 | mRULE_ANY_OTHER(); | 2387 | mRULE_ANY_OTHER(); |
| 1395 | 2388 | ||
| @@ -1401,286 +2394,408 @@ public class InternalSolverLanguageLexer extends Lexer { | |||
| 1401 | } | 2394 | } |
| 1402 | 2395 | ||
| 1403 | 2396 | ||
| 1404 | protected DFA10 dfa10 = new DFA10(this); | 2397 | protected DFA11 dfa11 = new DFA11(this); |
| 1405 | static final String DFA10_eotS = | 2398 | static final String DFA11_eotS = |
| 1406 | "\2\uffff\1\41\4\43\3\uffff\1\56\4\43\4\uffff\3\43\2\uffff\2\36\2\uffff\1\36\5\uffff\1\43\1\uffff\6\43\5\uffff\4\43\4\uffff\4\43\7\uffff\11\43\1\134\7\43\1\144\6\43\1\153\1\154\1\uffff\1\155\6\43\1\uffff\1\164\1\43\1\166\3\43\3\uffff\4\43\1\176\1\43\1\uffff\1\43\1\uffff\1\u0081\1\43\1\u0083\1\43\1\u0085\2\43\1\uffff\1\43\1\u0089\1\uffff\1\u008a\1\uffff\1\43\1\uffff\1\u008c\2\43\2\uffff\1\u008f\1\uffff\1\u0090\1\43\2\uffff\2\43\1\u0094\1\uffff"; | 2399 | "\1\uffff\1\51\1\53\3\56\1\65\2\56\1\uffff\1\74\1\uffff\1\56\10\uffff\3\56\1\121\1\123\1\56\1\126\1\uffff\1\132\1\133\3\56\2\47\10\uffff\2\56\1\uffff\5\56\2\uffff\1\154\1\157\2\56\4\uffff\3\56\10\uffff\7\56\4\uffff\1\56\7\uffff\5\56\4\uffff\7\56\1\uffff\1\u008b\1\u008c\1\uffff\7\56\1\u0094\3\56\1\u0098\2\56\1\u009b\1\u009d\1\56\1\u00a0\6\56\1\u00a8\2\56\2\uffff\1\u00ab\1\u00ac\5\56\1\uffff\1\56\1\u00b3\1\56\1\uffff\1\56\1\u00b6\1\uffff\1\56\1\uffff\1\u00b8\1\56\1\uffff\1\u00ba\2\56\1\u00bd\1\u00be\2\56\1\uffff\1\u00c1\1\56\2\uffff\1\u00c3\1\56\1\u00c5\3\56\1\uffff\1\u00c9\1\56\1\uffff\1\56\1\uffff\1\56\1\uffff\2\56\2\uffff\1\u00cf\1\56\1\uffff\1\56\1\uffff\1\56\1\uffff\3\56\1\uffff\5\56\1\uffff\1\u00db\1\u00dc\1\56\1\u00de\5\56\1\u00e4\1\56\2\uffff\1\u00e6\1\uffff\1\u00e7\1\u00e8\1\56\1\u00ea\1\u00eb\1\uffff\1\56\3\uffff\1\56\2\uffff\1\u00ee\6\uffff"; |
| 1407 | static final String DFA10_eofS = | 2400 | static final String DFA11_eofS = |
| 1408 | "\u0095\uffff"; | 2401 | "\u00f3\uffff"; |
| 1409 | static final String DFA10_minS = | 2402 | static final String DFA11_minS = |
| 1410 | "\1\0\1\uffff\1\56\1\162\1\141\2\156\3\uffff\1\55\1\157\1\156\1\145\1\164\4\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\5\uffff\1\157\1\164\1\141\1\162\4\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\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\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\154\1\141\1\60\1\151\1\uffff\1\156\1\uffff\1\60\1\163\1\60\1\157\1\60\1\164\1\143\1\uffff\1\156\1\60\1\uffff\1\60\1\uffff\1\156\1\uffff\1\60\1\164\1\155\2\uffff\1\60\1\uffff\1\60\1\145\2\uffff\1\156\1\164\1\60\1\uffff"; | 2403 | "\1\0\1\55\1\75\1\141\1\154\1\145\1\56\1\146\1\150\1\uffff\1\76\1\uffff\1\154\10\uffff\1\142\1\156\1\143\2\75\1\145\1\75\1\uffff\1\52\1\101\1\141\1\162\1\156\2\0\10\uffff\1\156\1\154\1\uffff\1\162\1\164\1\163\1\160\1\146\2\uffff\2\60\1\145\1\165\4\uffff\1\156\1\141\1\162\10\uffff\1\163\1\147\1\160\1\154\1\157\1\155\1\156\4\uffff\1\141\7\uffff\1\170\1\163\1\156\1\157\1\153\4\uffff\1\143\1\163\1\157\2\145\1\164\1\141\1\uffff\2\60\1\uffff\1\156\1\145\1\156\1\164\1\163\1\162\1\164\1\60\1\157\1\171\1\160\1\60\1\164\1\154\2\60\1\164\1\60\1\144\1\156\1\164\1\145\1\162\1\156\1\60\1\171\1\165\2\uffff\2\60\1\164\1\141\1\163\1\145\1\162\1\uffff\1\163\1\60\1\145\1\uffff\1\150\1\60\1\uffff\1\155\1\uffff\1\60\1\155\1\uffff\1\60\1\157\1\151\2\60\1\156\1\144\1\uffff\1\60\1\154\2\uffff\1\60\1\151\1\60\1\156\1\141\1\151\1\uffff\1\60\1\145\1\uffff\1\151\1\uffff\1\151\1\uffff\1\167\1\157\2\uffff\1\60\1\163\1\uffff\1\164\1\uffff\1\156\1\uffff\1\164\1\143\1\164\1\uffff\1\164\2\172\2\156\1\uffff\2\60\1\163\1\60\1\164\1\145\1\151\2\145\1\60\1\141\2\uffff\1\60\1\uffff\2\60\1\143\2\60\1\uffff\1\154\3\uffff\1\72\2\uffff\1\60\1\72\1\uffff\1\144\3\uffff"; |
| 1411 | static final String DFA10_maxS = | 2404 | static final String DFA11_maxS = |
| 1412 | "\1\uffff\1\uffff\1\56\1\162\1\141\1\156\1\170\3\uffff\1\55\1\157\1\156\1\145\1\164\4\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\5\uffff\1\157\1\164\1\154\1\162\4\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\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\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\154\1\141\1\172\1\151\1\uffff\1\156\1\uffff\1\172\1\163\1\172\1\157\1\172\1\164\1\143\1\uffff\1\156\1\172\1\uffff\1\172\1\uffff\1\156\1\uffff\1\172\1\164\1\155\2\uffff\1\172\1\uffff\1\172\1\145\2\uffff\1\156\1\164\1\172\1\uffff"; | 2405 | "\1\uffff\1\55\1\75\1\165\1\170\1\145\1\56\1\156\1\162\1\uffff\1\76\1\uffff\1\165\10\uffff\1\166\1\160\1\171\2\75\1\145\1\75\1\uffff\1\57\1\172\1\165\1\162\1\156\2\uffff\10\uffff\1\156\1\154\1\uffff\1\162\1\164\1\163\1\160\1\146\2\uffff\2\172\1\145\1\165\4\uffff\1\165\1\141\1\162\10\uffff\1\163\1\147\1\160\1\154\1\157\1\155\1\156\4\uffff\1\141\7\uffff\1\171\1\163\1\156\1\157\1\153\4\uffff\1\143\1\163\1\157\2\145\1\164\1\141\1\uffff\2\172\1\uffff\1\156\1\145\1\156\1\164\1\163\1\162\1\164\1\172\1\157\1\171\1\160\1\172\1\164\1\154\2\172\1\164\1\172\1\144\1\156\1\164\1\145\2\162\1\172\1\171\1\165\2\uffff\2\172\1\164\1\141\1\163\1\145\1\162\1\uffff\1\163\1\172\1\145\1\uffff\1\150\1\172\1\uffff\1\155\1\uffff\1\172\1\155\1\uffff\1\172\1\157\1\151\2\172\1\156\1\144\1\uffff\1\172\1\154\2\uffff\1\172\1\151\1\172\1\156\1\141\1\151\1\uffff\1\172\1\145\1\uffff\1\151\1\uffff\1\151\1\uffff\1\167\1\157\2\uffff\1\172\1\163\1\uffff\1\164\1\uffff\1\156\1\uffff\1\164\1\143\1\164\1\uffff\1\164\2\172\2\156\1\uffff\2\172\1\163\1\172\1\164\1\145\1\151\2\145\1\172\1\141\2\uffff\1\172\1\uffff\2\172\1\143\2\172\1\uffff\1\154\3\uffff\1\72\2\uffff\1\172\1\72\1\uffff\1\163\3\uffff"; |
| 1413 | static final String DFA10_acceptS = | 2406 | static final String DFA11_acceptS = |
| 1414 | "\1\uffff\1\1\5\uffff\1\7\1\10\1\11\5\uffff\1\21\1\23\1\24\1\25\3\uffff\1\32\1\33\2\uffff\1\41\1\42\1\uffff\1\45\1\46\1\1\1\37\1\2\1\uffff\1\41\6\uffff\1\7\1\10\1\11\1\22\1\12\4\uffff\1\21\1\23\1\24\1\25\4\uffff\1\32\1\33\1\40\1\42\1\43\1\44\1\45\32\uffff\1\16\7\uffff\1\3\6\uffff\1\34\1\15\1\17\6\uffff\1\4\1\uffff\1\6\7\uffff\1\30\2\uffff\1\13\1\uffff\1\14\1\uffff\1\20\3\uffff\1\5\1\31\1\uffff\1\26\2\uffff\1\36\1\27\3\uffff\1\35"; | 2407 | "\11\uffff\1\14\1\uffff\1\16\1\uffff\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\30\7\uffff\1\52\7\uffff\1\102\1\103\1\106\1\107\1\2\1\1\1\41\1\3\2\uffff\1\102\5\uffff\1\27\1\10\4\uffff\1\14\1\15\1\53\1\16\3\uffff\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\30\7\uffff\1\42\1\47\1\43\1\50\1\uffff\1\46\1\56\1\52\1\104\1\105\1\54\1\55\5\uffff\1\75\1\76\1\103\1\106\7\uffff\1\11\2\uffff\1\51\33\uffff\1\31\1\44\7\uffff\1\65\3\uffff\1\63\2\uffff\1\57\1\uffff\1\67\2\uffff\1\66\7\uffff\1\13\2\uffff\1\12\1\70\6\uffff\1\62\2\uffff\1\45\1\uffff\1\60\1\uffff\1\64\2\uffff\1\71\1\5\2\uffff\1\32\1\uffff\1\17\1\uffff\1\34\3\uffff\1\40\5\uffff\1\7\13\uffff\1\35\1\6\1\uffff\1\61\5\uffff\1\72\1\uffff\1\36\1\33\1\37\1\uffff\1\74\1\73\2\uffff\1\4\1\uffff\1\77\1\100\1\101"; |
| 1415 | static final String DFA10_specialS = | 2408 | static final String DFA11_specialS = |
| 1416 | "\1\0\27\uffff\1\1\174\uffff}>"; | 2409 | "\1\1\41\uffff\1\2\1\0\u00cf\uffff}>"; |
| 1417 | static final String[] DFA10_transitionS = { | 2410 | static final String[] DFA11_transitionS = { |
| 1418 | "\11\36\2\35\2\36\1\35\22\36\1\35\1\36\1\30\4\36\1\17\1\7\1\11\1\22\1\21\1\10\1\1\1\2\1\34\12\33\1\12\6\36\32\32\3\36\1\31\1\32\1\36\1\24\1\13\1\25\1\23\1\6\1\4\2\32\1\14\10\32\1\15\1\16\1\3\1\5\5\32\1\26\1\20\1\27\uff82\36", | 2411 | "\11\47\2\46\2\47\1\46\22\47\1\46\1\33\1\42\4\47\1\43\1\20\1\21\1\22\1\34\1\13\1\12\1\6\1\35\12\45\1\1\1\11\1\30\1\2\1\31\2\47\32\44\1\23\1\47\1\24\1\36\1\44\1\47\1\25\1\44\1\14\1\5\1\4\1\3\2\44\1\7\3\44\1\37\1\44\1\26\1\40\1\44\1\32\1\27\1\10\1\41\5\44\1\15\1\17\1\16\uff82\47", |
| 2412 | "\1\50", | ||
| 2413 | "\1\52", | ||
| 2414 | "\1\55\23\uffff\1\54", | ||
| 2415 | "\1\61\1\62\4\uffff\1\57\5\uffff\1\60", | ||
| 2416 | "\1\63", | ||
| 2417 | "\1\64", | ||
| 2418 | "\1\66\7\uffff\1\67", | ||
| 2419 | "\1\70\11\uffff\1\71", | ||
| 1419 | "", | 2420 | "", |
| 1420 | "\1\40", | 2421 | "\1\73", |
| 1421 | "\1\42", | ||
| 1422 | "\1\44", | ||
| 1423 | "\1\45", | ||
| 1424 | "\1\51\2\uffff\1\50\1\46\5\uffff\1\47", | ||
| 1425 | "", | 2422 | "", |
| 2423 | "\1\77\2\uffff\1\76\5\uffff\1\100", | ||
| 1426 | "", | 2424 | "", |
| 1427 | "", | 2425 | "", |
| 1428 | "\1\55", | ||
| 1429 | "\1\57", | ||
| 1430 | "\1\60", | ||
| 1431 | "\1\61", | ||
| 1432 | "\1\62", | ||
| 1433 | "", | 2426 | "", |
| 1434 | "", | 2427 | "", |
| 1435 | "", | 2428 | "", |
| 1436 | "", | 2429 | "", |
| 1437 | "\1\67", | ||
| 1438 | "\1\70", | ||
| 1439 | "\1\71\2\uffff\1\72", | ||
| 1440 | "", | 2430 | "", |
| 1441 | "", | 2431 | "", |
| 1442 | "\0\75", | 2432 | "\1\111\23\uffff\1\112", |
| 1443 | "\32\43\4\uffff\1\43\1\uffff\32\43", | 2433 | "\1\114\1\uffff\1\113", |
| 1444 | "", | 2434 | "\1\115\21\uffff\1\116\3\uffff\1\117", |
| 1445 | "", | 2435 | "\1\120", |
| 1446 | "\1\77\4\uffff\1\100", | 2436 | "\1\122", |
| 2437 | "\1\124", | ||
| 2438 | "\1\125", | ||
| 1447 | "", | 2439 | "", |
| 2440 | "\1\130\4\uffff\1\131", | ||
| 2441 | "\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2442 | "\1\134\7\uffff\1\136\13\uffff\1\135", | ||
| 2443 | "\1\137", | ||
| 2444 | "\1\140", | ||
| 2445 | "\0\141", | ||
| 2446 | "\0\142", | ||
| 1448 | "", | 2447 | "", |
| 1449 | "", | 2448 | "", |
| 1450 | "", | 2449 | "", |
| 1451 | "", | 2450 | "", |
| 1452 | "\1\102", | ||
| 1453 | "", | 2451 | "", |
| 1454 | "\1\103", | ||
| 1455 | "\1\104", | ||
| 1456 | "\1\105", | ||
| 1457 | "\1\106\12\uffff\1\107", | ||
| 1458 | "\1\110", | ||
| 1459 | "\1\111", | ||
| 1460 | "", | 2452 | "", |
| 1461 | "", | 2453 | "", |
| 1462 | "", | 2454 | "", |
| 2455 | "\1\145", | ||
| 2456 | "\1\146", | ||
| 1463 | "", | 2457 | "", |
| 2458 | "\1\147", | ||
| 2459 | "\1\150", | ||
| 2460 | "\1\151", | ||
| 2461 | "\1\152", | ||
| 2462 | "\1\153", | ||
| 1464 | "", | 2463 | "", |
| 1465 | "\1\112", | ||
| 1466 | "\1\113", | ||
| 1467 | "\1\114\12\uffff\1\115", | ||
| 1468 | "\1\116", | ||
| 1469 | "", | 2464 | "", |
| 2465 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2466 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\5\56\1\155\15\56\1\156\6\56", | ||
| 2467 | "\1\160", | ||
| 2468 | "\1\161", | ||
| 1470 | "", | 2469 | "", |
| 1471 | "", | 2470 | "", |
| 1472 | "", | 2471 | "", |
| 1473 | "\1\117", | ||
| 1474 | "\1\120", | ||
| 1475 | "\1\121", | ||
| 1476 | "\1\122", | ||
| 1477 | "", | 2472 | "", |
| 2473 | "\1\163\6\uffff\1\162", | ||
| 2474 | "\1\164", | ||
| 2475 | "\1\165", | ||
| 1478 | "", | 2476 | "", |
| 1479 | "", | 2477 | "", |
| 1480 | "", | 2478 | "", |
| 1481 | "", | 2479 | "", |
| 1482 | "", | 2480 | "", |
| 1483 | "", | 2481 | "", |
| 1484 | "\1\123", | ||
| 1485 | "\1\124", | ||
| 1486 | "\1\125", | ||
| 1487 | "\1\126", | ||
| 1488 | "\1\127", | ||
| 1489 | "\1\130", | ||
| 1490 | "\1\131", | ||
| 1491 | "\1\132", | ||
| 1492 | "\1\133", | ||
| 1493 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1494 | "\1\135", | ||
| 1495 | "\1\136", | ||
| 1496 | "\1\137", | ||
| 1497 | "\1\140", | ||
| 1498 | "\1\141", | ||
| 1499 | "\1\142", | ||
| 1500 | "\1\143", | ||
| 1501 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1502 | "\1\145", | ||
| 1503 | "\1\146", | ||
| 1504 | "\1\147", | ||
| 1505 | "\1\150", | ||
| 1506 | "\1\151", | ||
| 1507 | "\1\152", | ||
| 1508 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1509 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1510 | "", | 2482 | "", |
| 1511 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1512 | "\1\156", | ||
| 1513 | "\1\157", | ||
| 1514 | "\1\160", | ||
| 1515 | "\1\161", | ||
| 1516 | "\1\162", | ||
| 1517 | "\1\163", | ||
| 1518 | "", | 2483 | "", |
| 1519 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | 2484 | "\1\166", |
| 1520 | "\1\165", | ||
| 1521 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1522 | "\1\167", | 2485 | "\1\167", |
| 1523 | "\1\170", | 2486 | "\1\170", |
| 1524 | "\1\171", | 2487 | "\1\171", |
| 1525 | "", | ||
| 1526 | "", | ||
| 1527 | "", | ||
| 1528 | "\1\172", | 2488 | "\1\172", |
| 1529 | "\1\173", | 2489 | "\1\173", |
| 1530 | "\1\174", | 2490 | "\1\174", |
| 2491 | "", | ||
| 2492 | "", | ||
| 2493 | "", | ||
| 2494 | "", | ||
| 1531 | "\1\175", | 2495 | "\1\175", |
| 1532 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1533 | "\1\177", | ||
| 1534 | "", | 2496 | "", |
| 1535 | "\1\u0080", | ||
| 1536 | "", | 2497 | "", |
| 1537 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | 2498 | "", |
| 2499 | "", | ||
| 2500 | "", | ||
| 2501 | "", | ||
| 2502 | "", | ||
| 2503 | "\1\177\1\176", | ||
| 2504 | "\1\u0080", | ||
| 2505 | "\1\u0081", | ||
| 1538 | "\1\u0082", | 2506 | "\1\u0082", |
| 1539 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | 2507 | "\1\u0083", |
| 2508 | "", | ||
| 2509 | "", | ||
| 2510 | "", | ||
| 2511 | "", | ||
| 1540 | "\1\u0084", | 2512 | "\1\u0084", |
| 1541 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | 2513 | "\1\u0085", |
| 1542 | "\1\u0086", | 2514 | "\1\u0086", |
| 1543 | "\1\u0087", | 2515 | "\1\u0087", |
| 1544 | "", | ||
| 1545 | "\1\u0088", | 2516 | "\1\u0088", |
| 1546 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | 2517 | "\1\u0089", |
| 1547 | "", | 2518 | "\1\u008a", |
| 1548 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1549 | "", | 2519 | "", |
| 1550 | "\1\u008b", | 2520 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", |
| 2521 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 1551 | "", | 2522 | "", |
| 1552 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1553 | "\1\u008d", | 2523 | "\1\u008d", |
| 1554 | "\1\u008e", | 2524 | "\1\u008e", |
| 2525 | "\1\u008f", | ||
| 2526 | "\1\u0090", | ||
| 2527 | "\1\u0091", | ||
| 2528 | "\1\u0092", | ||
| 2529 | "\1\u0093", | ||
| 2530 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2531 | "\1\u0095", | ||
| 2532 | "\1\u0096", | ||
| 2533 | "\1\u0097", | ||
| 2534 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2535 | "\1\u0099", | ||
| 2536 | "\1\u009a", | ||
| 2537 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2538 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\10\56\1\u009c\21\56", | ||
| 2539 | "\1\u009e", | ||
| 2540 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\10\56\1\u009f\21\56", | ||
| 2541 | "\1\u00a1", | ||
| 2542 | "\1\u00a2", | ||
| 2543 | "\1\u00a3", | ||
| 2544 | "\1\u00a4", | ||
| 2545 | "\1\u00a5", | ||
| 2546 | "\1\u00a7\3\uffff\1\u00a6", | ||
| 2547 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2548 | "\1\u00a9", | ||
| 2549 | "\1\u00aa", | ||
| 1555 | "", | 2550 | "", |
| 1556 | "", | 2551 | "", |
| 1557 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | 2552 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", |
| 2553 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2554 | "\1\u00ad", | ||
| 2555 | "\1\u00ae", | ||
| 2556 | "\1\u00af", | ||
| 2557 | "\1\u00b0", | ||
| 2558 | "\1\u00b1", | ||
| 1558 | "", | 2559 | "", |
| 1559 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | 2560 | "\1\u00b2", |
| 1560 | "\1\u0091", | 2561 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", |
| 2562 | "\1\u00b4", | ||
| 2563 | "", | ||
| 2564 | "\1\u00b5", | ||
| 2565 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2566 | "", | ||
| 2567 | "\1\u00b7", | ||
| 2568 | "", | ||
| 2569 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2570 | "\1\u00b9", | ||
| 2571 | "", | ||
| 2572 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2573 | "\1\u00bb", | ||
| 2574 | "\1\u00bc", | ||
| 2575 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2576 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2577 | "\1\u00bf", | ||
| 2578 | "\1\u00c0", | ||
| 2579 | "", | ||
| 2580 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2581 | "\1\u00c2", | ||
| 2582 | "", | ||
| 2583 | "", | ||
| 2584 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2585 | "\1\u00c4", | ||
| 2586 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2587 | "\1\u00c6", | ||
| 2588 | "\1\u00c7", | ||
| 2589 | "\1\u00c8", | ||
| 2590 | "", | ||
| 2591 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2592 | "\1\u00ca", | ||
| 2593 | "", | ||
| 2594 | "\1\u00cb", | ||
| 2595 | "", | ||
| 2596 | "\1\u00cc", | ||
| 2597 | "", | ||
| 2598 | "\1\u00cd", | ||
| 2599 | "\1\u00ce", | ||
| 2600 | "", | ||
| 2601 | "", | ||
| 2602 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2603 | "\1\u00d0", | ||
| 2604 | "", | ||
| 2605 | "\1\u00d1", | ||
| 2606 | "", | ||
| 2607 | "\1\u00d2", | ||
| 2608 | "", | ||
| 2609 | "\1\u00d3", | ||
| 2610 | "\1\u00d4", | ||
| 2611 | "\1\u00d5", | ||
| 2612 | "", | ||
| 2613 | "\1\u00d6", | ||
| 2614 | "\1\u00d7", | ||
| 2615 | "\1\u00d8", | ||
| 2616 | "\1\u00d9", | ||
| 2617 | "\1\u00da", | ||
| 2618 | "", | ||
| 2619 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2620 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2621 | "\1\u00dd", | ||
| 2622 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2623 | "\1\u00df", | ||
| 2624 | "\1\u00e0", | ||
| 2625 | "\1\u00e1", | ||
| 2626 | "\1\u00e2", | ||
| 2627 | "\1\u00e3", | ||
| 2628 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2629 | "\1\u00e5", | ||
| 2630 | "", | ||
| 2631 | "", | ||
| 2632 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2633 | "", | ||
| 2634 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2635 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2636 | "\1\u00e9", | ||
| 2637 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2638 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2639 | "", | ||
| 2640 | "\1\u00ec", | ||
| 2641 | "", | ||
| 2642 | "", | ||
| 2643 | "", | ||
| 2644 | "\1\u00ed", | ||
| 2645 | "", | ||
| 2646 | "", | ||
| 2647 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
| 2648 | "\1\u00ef", | ||
| 2649 | "", | ||
| 2650 | "\1\u00f2\13\uffff\1\u00f0\2\uffff\1\u00f1", | ||
| 1561 | "", | 2651 | "", |
| 1562 | "", | 2652 | "", |
| 1563 | "\1\u0092", | ||
| 1564 | "\1\u0093", | ||
| 1565 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1566 | "" | 2653 | "" |
| 1567 | }; | 2654 | }; |
| 1568 | 2655 | ||
| 1569 | static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS); | 2656 | static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); |
| 1570 | static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS); | 2657 | static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); |
| 1571 | static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS); | 2658 | static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); |
| 1572 | static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS); | 2659 | static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); |
| 1573 | static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS); | 2660 | static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); |
| 1574 | static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS); | 2661 | static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); |
| 1575 | static final short[][] DFA10_transition; | 2662 | static final short[][] DFA11_transition; |
| 1576 | 2663 | ||
| 1577 | static { | 2664 | static { |
| 1578 | int numStates = DFA10_transitionS.length; | 2665 | int numStates = DFA11_transitionS.length; |
| 1579 | DFA10_transition = new short[numStates][]; | 2666 | DFA11_transition = new short[numStates][]; |
| 1580 | for (int i=0; i<numStates; i++) { | 2667 | for (int i=0; i<numStates; i++) { |
| 1581 | DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]); | 2668 | DFA11_transition[i] = DFA.unpackEncodedString(DFA11_transitionS[i]); |
| 1582 | } | 2669 | } |
| 1583 | } | 2670 | } |
| 1584 | 2671 | ||
| 1585 | class DFA10 extends DFA { | 2672 | class DFA11 extends DFA { |
| 1586 | 2673 | ||
| 1587 | public DFA10(BaseRecognizer recognizer) { | 2674 | public DFA11(BaseRecognizer recognizer) { |
| 1588 | this.recognizer = recognizer; | 2675 | this.recognizer = recognizer; |
| 1589 | this.decisionNumber = 10; | 2676 | this.decisionNumber = 11; |
| 1590 | this.eot = DFA10_eot; | 2677 | this.eot = DFA11_eot; |
| 1591 | this.eof = DFA10_eof; | 2678 | this.eof = DFA11_eof; |
| 1592 | this.min = DFA10_min; | 2679 | this.min = DFA11_min; |
| 1593 | this.max = DFA10_max; | 2680 | this.max = DFA11_max; |
| 1594 | this.accept = DFA10_accept; | 2681 | this.accept = DFA11_accept; |
| 1595 | this.special = DFA10_special; | 2682 | this.special = DFA11_special; |
| 1596 | this.transition = DFA10_transition; | 2683 | this.transition = DFA11_transition; |
| 1597 | } | 2684 | } |
| 1598 | public String getDescription() { | 2685 | public String getDescription() { |
| 1599 | 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 | T__41 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | 2686 | return "1:1: Tokens : ( 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 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | RULE_STRING | RULE_QUOTED_ID | RULE_PLUS | RULE_STAR | RULE_DOT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );"; |
| 1600 | } | 2687 | } |
| 1601 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | 2688 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| 1602 | IntStream input = _input; | 2689 | IntStream input = _input; |
| 1603 | int _s = s; | 2690 | int _s = s; |
| 1604 | switch ( s ) { | 2691 | switch ( s ) { |
| 1605 | case 0 : | 2692 | case 0 : |
| 1606 | int LA10_0 = input.LA(1); | 2693 | int LA11_35 = input.LA(1); |
| 1607 | 2694 | ||
| 1608 | s = -1; | 2695 | s = -1; |
| 1609 | if ( (LA10_0=='-') ) {s = 1;} | 2696 | if ( ((LA11_35>='\u0000' && LA11_35<='\uFFFF')) ) {s = 98;} |
| 1610 | 2697 | ||
| 1611 | else if ( (LA10_0=='.') ) {s = 2;} | 2698 | else s = 39; |
| 1612 | 2699 | ||
| 1613 | else if ( (LA10_0=='t') ) {s = 3;} | 2700 | if ( s>=0 ) return s; |
| 2701 | break; | ||
| 2702 | case 1 : | ||
| 2703 | int LA11_0 = input.LA(1); | ||
| 2704 | |||
| 2705 | s = -1; | ||
| 2706 | if ( (LA11_0==':') ) {s = 1;} | ||
| 2707 | |||
| 2708 | else if ( (LA11_0=='=') ) {s = 2;} | ||
| 2709 | |||
| 2710 | else if ( (LA11_0=='f') ) {s = 3;} | ||
| 2711 | |||
| 2712 | else if ( (LA11_0=='e') ) {s = 4;} | ||
| 2713 | |||
| 2714 | else if ( (LA11_0=='d') ) {s = 5;} | ||
| 2715 | |||
| 2716 | else if ( (LA11_0=='.') ) {s = 6;} | ||
| 1614 | 2717 | ||
| 1615 | else if ( (LA10_0=='f') ) {s = 4;} | 2718 | else if ( (LA11_0=='i') ) {s = 7;} |
| 1616 | 2719 | ||
| 1617 | else if ( (LA10_0=='u') ) {s = 5;} | 2720 | else if ( (LA11_0=='t') ) {s = 8;} |
| 1618 | 2721 | ||
| 1619 | else if ( (LA10_0=='e') ) {s = 6;} | 2722 | else if ( (LA11_0==';') ) {s = 9;} |
| 1620 | 2723 | ||
| 1621 | else if ( (LA10_0=='(') ) {s = 7;} | 2724 | else if ( (LA11_0=='-') ) {s = 10;} |
| 1622 | 2725 | ||
| 1623 | else if ( (LA10_0==',') ) {s = 8;} | 2726 | else if ( (LA11_0==',') ) {s = 11;} |
| 1624 | 2727 | ||
| 1625 | else if ( (LA10_0==')') ) {s = 9;} | 2728 | else if ( (LA11_0=='c') ) {s = 12;} |
| 1626 | 2729 | ||
| 1627 | else if ( (LA10_0==':') ) {s = 10;} | 2730 | else if ( (LA11_0=='{') ) {s = 13;} |
| 1628 | 2731 | ||
| 1629 | else if ( (LA10_0=='b') ) {s = 11;} | 2732 | else if ( (LA11_0=='}') ) {s = 14;} |
| 1630 | 2733 | ||
| 1631 | else if ( (LA10_0=='i') ) {s = 12;} | 2734 | else if ( (LA11_0=='|') ) {s = 15;} |
| 1632 | 2735 | ||
| 1633 | else if ( (LA10_0=='r') ) {s = 13;} | 2736 | else if ( (LA11_0=='(') ) {s = 16;} |
| 1634 | 2737 | ||
| 1635 | else if ( (LA10_0=='s') ) {s = 14;} | 2738 | else if ( (LA11_0==')') ) {s = 17;} |
| 1636 | 2739 | ||
| 1637 | else if ( (LA10_0=='\'') ) {s = 15;} | 2740 | else if ( (LA11_0=='*') ) {s = 18;} |
| 1638 | 2741 | ||
| 1639 | else if ( (LA10_0=='|') ) {s = 16;} | 2742 | else if ( (LA11_0=='[') ) {s = 19;} |
| 1640 | 2743 | ||
| 1641 | else if ( (LA10_0=='+') ) {s = 17;} | 2744 | else if ( (LA11_0==']') ) {s = 20;} |
| 1642 | 2745 | ||
| 1643 | else if ( (LA10_0=='*') ) {s = 18;} | 2746 | else if ( (LA11_0=='a') ) {s = 21;} |
| 1644 | 2747 | ||
| 1645 | else if ( (LA10_0=='d') ) {s = 19;} | 2748 | else if ( (LA11_0=='o') ) {s = 22;} |
| 1646 | 2749 | ||
| 1647 | else if ( (LA10_0=='a') ) {s = 20;} | 2750 | else if ( (LA11_0=='s') ) {s = 23;} |
| 1648 | 2751 | ||
| 1649 | else if ( (LA10_0=='c') ) {s = 21;} | 2752 | else if ( (LA11_0=='<') ) {s = 24;} |
| 1650 | 2753 | ||
| 1651 | else if ( (LA10_0=='{') ) {s = 22;} | 2754 | else if ( (LA11_0=='>') ) {s = 25;} |
| 1652 | 2755 | ||
| 1653 | else if ( (LA10_0=='}') ) {s = 23;} | 2756 | else if ( (LA11_0=='r') ) {s = 26;} |
| 1654 | 2757 | ||
| 1655 | else if ( (LA10_0=='\"') ) {s = 24;} | 2758 | else if ( (LA11_0=='!') ) {s = 27;} |
| 1656 | 2759 | ||
| 1657 | else if ( (LA10_0=='^') ) {s = 25;} | 2760 | else if ( (LA11_0=='+') ) {s = 28;} |
| 1658 | 2761 | ||
| 1659 | else if ( ((LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='g' && LA10_0<='h')||(LA10_0>='j' && LA10_0<='q')||(LA10_0>='v' && LA10_0<='z')) ) {s = 26;} | 2762 | else if ( (LA11_0=='/') ) {s = 29;} |
| 1660 | 2763 | ||
| 1661 | else if ( ((LA10_0>='0' && LA10_0<='9')) ) {s = 27;} | 2764 | else if ( (LA11_0=='^') ) {s = 30;} |
| 1662 | 2765 | ||
| 1663 | else if ( (LA10_0=='/') ) {s = 28;} | 2766 | else if ( (LA11_0=='m') ) {s = 31;} |
| 1664 | 2767 | ||
| 1665 | else if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {s = 29;} | 2768 | else if ( (LA11_0=='p') ) {s = 32;} |
| 1666 | 2769 | ||
| 1667 | 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<='\uFFFF')) ) {s = 30;} | 2770 | else if ( (LA11_0=='u') ) {s = 33;} |
| 2771 | |||
| 2772 | else if ( (LA11_0=='\"') ) {s = 34;} | ||
| 2773 | |||
| 2774 | else if ( (LA11_0=='\'') ) {s = 35;} | ||
| 2775 | |||
| 2776 | else if ( ((LA11_0>='A' && LA11_0<='Z')||LA11_0=='_'||LA11_0=='b'||(LA11_0>='g' && LA11_0<='h')||(LA11_0>='j' && LA11_0<='l')||LA11_0=='n'||LA11_0=='q'||(LA11_0>='v' && LA11_0<='z')) ) {s = 36;} | ||
| 2777 | |||
| 2778 | else if ( ((LA11_0>='0' && LA11_0<='9')) ) {s = 37;} | ||
| 2779 | |||
| 2780 | else if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {s = 38;} | ||
| 2781 | |||
| 2782 | else if ( ((LA11_0>='\u0000' && LA11_0<='\b')||(LA11_0>='\u000B' && LA11_0<='\f')||(LA11_0>='\u000E' && LA11_0<='\u001F')||(LA11_0>='#' && LA11_0<='&')||(LA11_0>='?' && LA11_0<='@')||LA11_0=='\\'||LA11_0=='`'||(LA11_0>='~' && LA11_0<='\uFFFF')) ) {s = 39;} | ||
| 1668 | 2783 | ||
| 1669 | if ( s>=0 ) return s; | 2784 | if ( s>=0 ) return s; |
| 1670 | break; | 2785 | break; |
| 1671 | case 1 : | 2786 | case 2 : |
| 1672 | int LA10_24 = input.LA(1); | 2787 | int LA11_34 = input.LA(1); |
| 1673 | 2788 | ||
| 1674 | s = -1; | 2789 | s = -1; |
| 1675 | if ( ((LA10_24>='\u0000' && LA10_24<='\uFFFF')) ) {s = 61;} | 2790 | if ( ((LA11_34>='\u0000' && LA11_34<='\uFFFF')) ) {s = 97;} |
| 1676 | 2791 | ||
| 1677 | else s = 30; | 2792 | else s = 39; |
| 1678 | 2793 | ||
| 1679 | if ( s>=0 ) return s; | 2794 | if ( s>=0 ) return s; |
| 1680 | break; | 2795 | break; |
| 1681 | } | 2796 | } |
| 1682 | NoViableAltException nvae = | 2797 | NoViableAltException nvae = |
| 1683 | new NoViableAltException(getDescription(), 10, _s, input); | 2798 | new NoViableAltException(getDescription(), 11, _s, input); |
| 1684 | error(nvae); | 2799 | error(nvae); |
| 1685 | throw nvae; | 2800 | throw nvae; |
| 1686 | } | 2801 | } |
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 index 1d449e49..ee2f6175 100644 --- 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 | |||
| @@ -5,6 +5,7 @@ import org.eclipse.xtext.parser.*; | |||
| 5 | import org.eclipse.xtext.parser.impl.*; | 5 | import org.eclipse.xtext.parser.impl.*; |
| 6 | import org.eclipse.emf.ecore.util.EcoreUtil; | 6 | import org.eclipse.emf.ecore.util.EcoreUtil; |
| 7 | import org.eclipse.emf.ecore.EObject; | 7 | import org.eclipse.emf.ecore.EObject; |
| 8 | import org.eclipse.emf.common.util.Enumerator; | ||
| 8 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; | 9 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; |
| 9 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | 10 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; |
| 10 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | 11 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; |
| @@ -17,51 +18,85 @@ import org.antlr.runtime.*; | |||
| 17 | import java.util.Stack; | 18 | import java.util.Stack; |
| 18 | import java.util.List; | 19 | import java.util.List; |
| 19 | import java.util.ArrayList; | 20 | import java.util.ArrayList; |
| 20 | 21 | import java.util.Map; | |
| 22 | import java.util.HashMap; | ||
| 21 | @SuppressWarnings("all") | 23 | @SuppressWarnings("all") |
| 22 | public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | 24 | public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { |
| 23 | public static final String[] tokenNames = new String[] { | 25 | 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'", "'\\''", "':-'", "'|'", "'+'", "'*'", "'default'", "'abstract'", "'class'", "'extends'", "'{'", "'}'", "'enum'", "'containment'", "'relation'", "'..'" | 26 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_DOT", "RULE_STAR", "RULE_PLUS", "RULE_STRING", "RULE_ID", "RULE_INT", "RULE_QUOTED_ID", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "':'", "':-'", "'='", "'functional'", "'error'", "'default'", "'extern'", "'.'", "'if'", "'then'", "'else'", "';'", "'->'", "','", "'count'", "'{'", "'}'", "'|'", "'('", "')'", "'*'", "'['", "'..'", "']'", "'inf'", "'empty'", "'abstract'", "'class'", "'extends'", "'contains'", "'opposite'", "'scope'", "'=='", "'<='", "'>='", "'int'", "'real'", "'!='", "'<'", "'>'", "'in'", "'+'", "'-'", "'/'", "'^'", "'!'", "'may'", "'must'", "'current'", "'only'", "'sum'", "'prod'", "'avg'", "'min'", "'max'", "'true'", "'false'", "'unknown'", "'minimize'", "'maximize'" |
| 25 | }; | 27 | }; |
| 26 | public static final int RULE_STRING=6; | 28 | public static final int T__50=50; |
| 27 | public static final int RULE_SL_COMMENT=8; | ||
| 28 | public static final int T__19=19; | 29 | public static final int T__19=19; |
| 29 | public static final int T__15=15; | 30 | public static final int T__15=15; |
| 30 | public static final int T__37=37; | 31 | public static final int T__59=59; |
| 31 | public static final int T__16=16; | 32 | public static final int T__16=16; |
| 32 | public static final int T__38=38; | ||
| 33 | public static final int T__17=17; | 33 | public static final int T__17=17; |
| 34 | public static final int T__39=39; | ||
| 35 | public static final int T__18=18; | 34 | public static final int T__18=18; |
| 36 | public static final int T__11=11; | 35 | public static final int T__55=55; |
| 37 | public static final int T__33=33; | 36 | public static final int T__56=56; |
| 38 | public static final int T__12=12; | 37 | public static final int T__57=57; |
| 39 | public static final int T__34=34; | 38 | public static final int T__58=58; |
| 40 | public static final int T__13=13; | 39 | public static final int T__51=51; |
| 41 | public static final int T__35=35; | 40 | public static final int RULE_STAR=5; |
| 42 | public static final int T__14=14; | 41 | public static final int T__52=52; |
| 43 | public static final int T__36=36; | 42 | public static final int T__53=53; |
| 44 | public static final int EOF=-1; | 43 | public static final int T__54=54; |
| 45 | public static final int T__30=30; | 44 | public static final int T__60=60; |
| 46 | public static final int T__31=31; | 45 | public static final int T__61=61; |
| 47 | public static final int T__32=32; | 46 | public static final int RULE_ID=8; |
| 48 | public static final int RULE_ID=5; | 47 | public static final int RULE_QUOTED_ID=10; |
| 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; | 48 | public static final int T__26=26; |
| 52 | public static final int T__27=27; | 49 | public static final int T__27=27; |
| 53 | public static final int T__28=28; | 50 | public static final int T__28=28; |
| 54 | public static final int RULE_INT=4; | 51 | public static final int RULE_INT=9; |
| 55 | public static final int T__29=29; | 52 | public static final int T__29=29; |
| 56 | public static final int T__22=22; | 53 | public static final int T__22=22; |
| 57 | public static final int RULE_ML_COMMENT=7; | 54 | public static final int T__66=66; |
| 55 | public static final int RULE_ML_COMMENT=11; | ||
| 58 | public static final int T__23=23; | 56 | public static final int T__23=23; |
| 57 | public static final int T__67=67; | ||
| 59 | public static final int T__24=24; | 58 | public static final int T__24=24; |
| 59 | public static final int T__68=68; | ||
| 60 | public static final int T__25=25; | 60 | public static final int T__25=25; |
| 61 | public static final int T__40=40; | 61 | public static final int T__69=69; |
| 62 | public static final int T__41=41; | 62 | public static final int T__62=62; |
| 63 | public static final int T__63=63; | ||
| 63 | public static final int T__20=20; | 64 | public static final int T__20=20; |
| 65 | public static final int T__64=64; | ||
| 64 | public static final int T__21=21; | 66 | public static final int T__21=21; |
| 67 | public static final int T__65=65; | ||
| 68 | public static final int T__70=70; | ||
| 69 | public static final int T__71=71; | ||
| 70 | public static final int T__72=72; | ||
| 71 | public static final int RULE_STRING=7; | ||
| 72 | public static final int RULE_SL_COMMENT=12; | ||
| 73 | public static final int T__37=37; | ||
| 74 | public static final int T__38=38; | ||
| 75 | public static final int T__39=39; | ||
| 76 | public static final int T__33=33; | ||
| 77 | public static final int T__34=34; | ||
| 78 | public static final int T__35=35; | ||
| 79 | public static final int RULE_PLUS=6; | ||
| 80 | public static final int T__36=36; | ||
| 81 | public static final int T__73=73; | ||
| 82 | public static final int RULE_DOT=4; | ||
| 83 | public static final int EOF=-1; | ||
| 84 | public static final int T__30=30; | ||
| 85 | public static final int T__74=74; | ||
| 86 | public static final int T__31=31; | ||
| 87 | public static final int T__32=32; | ||
| 88 | public static final int RULE_WS=13; | ||
| 89 | public static final int RULE_ANY_OTHER=14; | ||
| 90 | public static final int T__48=48; | ||
| 91 | public static final int T__49=49; | ||
| 92 | public static final int T__44=44; | ||
| 93 | public static final int T__45=45; | ||
| 94 | public static final int T__46=46; | ||
| 95 | public static final int T__47=47; | ||
| 96 | public static final int T__40=40; | ||
| 97 | public static final int T__41=41; | ||
| 98 | public static final int T__42=42; | ||
| 99 | public static final int T__43=43; | ||
| 65 | 100 | ||
| 66 | // delegates | 101 | // delegates |
| 67 | // delegators | 102 | // delegators |
| @@ -103,7 +138,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 103 | 138 | ||
| 104 | 139 | ||
| 105 | // $ANTLR start "entryRuleProblem" | 140 | // $ANTLR start "entryRuleProblem" |
| 106 | // InternalSolverLanguage.g:64:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ; | 141 | // InternalSolverLanguage.g:65:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ; |
| 107 | public final EObject entryRuleProblem() throws RecognitionException { | 142 | public final EObject entryRuleProblem() throws RecognitionException { |
| 108 | EObject current = null; | 143 | EObject current = null; |
| 109 | 144 | ||
| @@ -111,17 +146,21 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 111 | 146 | ||
| 112 | 147 | ||
| 113 | try { | 148 | try { |
| 114 | // InternalSolverLanguage.g:64:48: (iv_ruleProblem= ruleProblem EOF ) | 149 | // InternalSolverLanguage.g:65:48: (iv_ruleProblem= ruleProblem EOF ) |
| 115 | // InternalSolverLanguage.g:65:2: iv_ruleProblem= ruleProblem EOF | 150 | // InternalSolverLanguage.g:66:2: iv_ruleProblem= ruleProblem EOF |
| 116 | { | 151 | { |
| 117 | newCompositeNode(grammarAccess.getProblemRule()); | 152 | if ( state.backtracking==0 ) { |
| 153 | newCompositeNode(grammarAccess.getProblemRule()); | ||
| 154 | } | ||
| 118 | pushFollow(FOLLOW_1); | 155 | pushFollow(FOLLOW_1); |
| 119 | iv_ruleProblem=ruleProblem(); | 156 | iv_ruleProblem=ruleProblem(); |
| 120 | 157 | ||
| 121 | state._fsp--; | 158 | state._fsp--; |
| 122 | 159 | if (state.failed) return current; | |
| 123 | current =iv_ruleProblem; | 160 | if ( state.backtracking==0 ) { |
| 124 | match(input,EOF,FOLLOW_2); | 161 | current =iv_ruleProblem; |
| 162 | } | ||
| 163 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 125 | 164 | ||
| 126 | } | 165 | } |
| 127 | 166 | ||
| @@ -139,7 +178,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 139 | 178 | ||
| 140 | 179 | ||
| 141 | // $ANTLR start "ruleProblem" | 180 | // $ANTLR start "ruleProblem" |
| 142 | // InternalSolverLanguage.g:71:1: ruleProblem returns [EObject current=null] : ( (lv_statements_0_0= ruleStatement ) )* ; | 181 | // InternalSolverLanguage.g:72:1: ruleProblem returns [EObject current=null] : ( (lv_statements_0_0= ruleStatement ) )* ; |
| 143 | public final EObject ruleProblem() throws RecognitionException { | 182 | public final EObject ruleProblem() throws RecognitionException { |
| 144 | EObject current = null; | 183 | EObject current = null; |
| 145 | 184 | ||
| @@ -150,46 +189,50 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 150 | enterRule(); | 189 | enterRule(); |
| 151 | 190 | ||
| 152 | try { | 191 | try { |
| 153 | // InternalSolverLanguage.g:77:2: ( ( (lv_statements_0_0= ruleStatement ) )* ) | 192 | // InternalSolverLanguage.g:78:2: ( ( (lv_statements_0_0= ruleStatement ) )* ) |
| 154 | // InternalSolverLanguage.g:78:2: ( (lv_statements_0_0= ruleStatement ) )* | 193 | // InternalSolverLanguage.g:79:2: ( (lv_statements_0_0= ruleStatement ) )* |
| 155 | { | 194 | { |
| 156 | // InternalSolverLanguage.g:78:2: ( (lv_statements_0_0= ruleStatement ) )* | 195 | // InternalSolverLanguage.g:79:2: ( (lv_statements_0_0= ruleStatement ) )* |
| 157 | loop1: | 196 | loop1: |
| 158 | do { | 197 | do { |
| 159 | int alt1=2; | 198 | int alt1=2; |
| 160 | int LA1_0 = input.LA(1); | 199 | int LA1_0 = input.LA(1); |
| 161 | 200 | ||
| 162 | if ( (LA1_0==RULE_ID||LA1_0==16||(LA1_0>=21 && LA1_0<=26)||(LA1_0>=32 && LA1_0<=34)||(LA1_0>=38 && LA1_0<=40)) ) { | 201 | if ( ((LA1_0>=RULE_STRING && LA1_0<=RULE_QUOTED_ID)||(LA1_0>=18 && LA1_0<=21)||LA1_0==23||LA1_0==29||LA1_0==33||LA1_0==36||(LA1_0>=39 && LA1_0<=42)||LA1_0==46||(LA1_0>=50 && LA1_0<=51)||(LA1_0>=56 && LA1_0<=57)||(LA1_0>=60 && LA1_0<=74)) ) { |
| 163 | alt1=1; | 202 | alt1=1; |
| 164 | } | 203 | } |
| 165 | 204 | ||
| 166 | 205 | ||
| 167 | switch (alt1) { | 206 | switch (alt1) { |
| 168 | case 1 : | 207 | case 1 : |
| 169 | // InternalSolverLanguage.g:79:3: (lv_statements_0_0= ruleStatement ) | 208 | // InternalSolverLanguage.g:80:3: (lv_statements_0_0= ruleStatement ) |
| 170 | { | 209 | { |
| 171 | // InternalSolverLanguage.g:79:3: (lv_statements_0_0= ruleStatement ) | 210 | // InternalSolverLanguage.g:80:3: (lv_statements_0_0= ruleStatement ) |
| 172 | // InternalSolverLanguage.g:80:4: lv_statements_0_0= ruleStatement | 211 | // InternalSolverLanguage.g:81:4: lv_statements_0_0= ruleStatement |
| 173 | { | 212 | { |
| 213 | if ( state.backtracking==0 ) { | ||
| 174 | 214 | ||
| 175 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); | 215 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); |
| 176 | 216 | ||
| 217 | } | ||
| 177 | pushFollow(FOLLOW_3); | 218 | pushFollow(FOLLOW_3); |
| 178 | lv_statements_0_0=ruleStatement(); | 219 | lv_statements_0_0=ruleStatement(); |
| 179 | 220 | ||
| 180 | state._fsp--; | 221 | state._fsp--; |
| 181 | 222 | if (state.failed) return current; | |
| 182 | 223 | if ( state.backtracking==0 ) { | |
| 183 | if (current==null) { | 224 | |
| 184 | current = createModelElementForParent(grammarAccess.getProblemRule()); | 225 | if (current==null) { |
| 185 | } | 226 | current = createModelElementForParent(grammarAccess.getProblemRule()); |
| 186 | add( | 227 | } |
| 187 | current, | 228 | add( |
| 188 | "statements", | 229 | current, |
| 189 | lv_statements_0_0, | 230 | "statements", |
| 190 | "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); | 231 | lv_statements_0_0, |
| 191 | afterParserOrEnumRuleCall(); | 232 | "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); |
| 192 | 233 | afterParserOrEnumRuleCall(); | |
| 234 | |||
| 235 | } | ||
| 193 | 236 | ||
| 194 | } | 237 | } |
| 195 | 238 | ||
| @@ -205,9 +248,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 205 | 248 | ||
| 206 | } | 249 | } |
| 207 | 250 | ||
| 251 | if ( state.backtracking==0 ) { | ||
| 208 | 252 | ||
| 209 | leaveRule(); | 253 | leaveRule(); |
| 210 | 254 | ||
| 255 | } | ||
| 211 | } | 256 | } |
| 212 | 257 | ||
| 213 | catch (RecognitionException re) { | 258 | catch (RecognitionException re) { |
| @@ -222,7 +267,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 222 | 267 | ||
| 223 | 268 | ||
| 224 | // $ANTLR start "entryRuleStatement" | 269 | // $ANTLR start "entryRuleStatement" |
| 225 | // InternalSolverLanguage.g:100:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ; | 270 | // InternalSolverLanguage.g:101:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ; |
| 226 | public final EObject entryRuleStatement() throws RecognitionException { | 271 | public final EObject entryRuleStatement() throws RecognitionException { |
| 227 | EObject current = null; | 272 | EObject current = null; |
| 228 | 273 | ||
| @@ -230,17 +275,21 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 230 | 275 | ||
| 231 | 276 | ||
| 232 | try { | 277 | try { |
| 233 | // InternalSolverLanguage.g:100:50: (iv_ruleStatement= ruleStatement EOF ) | 278 | // InternalSolverLanguage.g:101:50: (iv_ruleStatement= ruleStatement EOF ) |
| 234 | // InternalSolverLanguage.g:101:2: iv_ruleStatement= ruleStatement EOF | 279 | // InternalSolverLanguage.g:102:2: iv_ruleStatement= ruleStatement EOF |
| 235 | { | 280 | { |
| 236 | newCompositeNode(grammarAccess.getStatementRule()); | 281 | if ( state.backtracking==0 ) { |
| 282 | newCompositeNode(grammarAccess.getStatementRule()); | ||
| 283 | } | ||
| 237 | pushFollow(FOLLOW_1); | 284 | pushFollow(FOLLOW_1); |
| 238 | iv_ruleStatement=ruleStatement(); | 285 | iv_ruleStatement=ruleStatement(); |
| 239 | 286 | ||
| 240 | state._fsp--; | 287 | state._fsp--; |
| 241 | 288 | if (state.failed) return current; | |
| 242 | current =iv_ruleStatement; | 289 | if ( state.backtracking==0 ) { |
| 243 | match(input,EOF,FOLLOW_2); | 290 | current =iv_ruleStatement; |
| 291 | } | ||
| 292 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 244 | 293 | ||
| 245 | } | 294 | } |
| 246 | 295 | ||
| @@ -258,189 +307,286 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 258 | 307 | ||
| 259 | 308 | ||
| 260 | // $ANTLR start "ruleStatement" | 309 | // $ANTLR start "ruleStatement" |
| 261 | // InternalSolverLanguage.g:107:1: ruleStatement returns [EObject current=null] : (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) ; | 310 | // InternalSolverLanguage.g:108:1: ruleStatement returns [EObject current=null] : ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_DOT_10= RULE_DOT ) ; |
| 262 | public final EObject ruleStatement() throws RecognitionException { | 311 | public final EObject ruleStatement() throws RecognitionException { |
| 263 | EObject current = null; | 312 | EObject current = null; |
| 264 | 313 | ||
| 265 | EObject this_Interpretation_0 = null; | 314 | Token this_DOT_10=null; |
| 315 | EObject this_AssertionOrDefinition_0 = null; | ||
| 316 | |||
| 317 | EObject this_PredicateDefinition_1 = null; | ||
| 318 | |||
| 319 | EObject this_UnnamedErrorPrediateDefinition_2 = null; | ||
| 320 | |||
| 321 | EObject this_DefaultDefinition_3 = null; | ||
| 322 | |||
| 323 | EObject this_ExternPredicateDefinition_4 = null; | ||
| 324 | |||
| 325 | EObject this_MetricDefinition_5 = null; | ||
| 326 | |||
| 327 | EObject this_ExternMetricDefinition_6 = null; | ||
| 328 | |||
| 329 | EObject this_ClassDefinition_7 = null; | ||
| 266 | 330 | ||
| 267 | EObject this_Predicate_1 = null; | 331 | EObject this_ScopeDefinition_8 = null; |
| 332 | |||
| 333 | EObject this_ObjectiveDefinition_9 = null; | ||
| 268 | 334 | ||
| 269 | 335 | ||
| 270 | 336 | ||
| 271 | enterRule(); | 337 | enterRule(); |
| 272 | 338 | ||
| 273 | try { | 339 | try { |
| 274 | // InternalSolverLanguage.g:113:2: ( (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) ) | 340 | // InternalSolverLanguage.g:114:2: ( ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_DOT_10= RULE_DOT ) ) |
| 275 | // InternalSolverLanguage.g:114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) | 341 | // InternalSolverLanguage.g:115:2: ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_DOT_10= RULE_DOT ) |
| 342 | { | ||
| 343 | // InternalSolverLanguage.g:115:2: ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_DOT_10= RULE_DOT ) | ||
| 344 | // InternalSolverLanguage.g:116:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_DOT_10= RULE_DOT | ||
| 276 | { | 345 | { |
| 277 | // InternalSolverLanguage.g:114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) | 346 | // InternalSolverLanguage.g:116:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) |
| 278 | int alt2=2; | 347 | int alt2=10; |
| 279 | alt2 = dfa2.predict(input); | 348 | alt2 = dfa2.predict(input); |
| 280 | switch (alt2) { | 349 | switch (alt2) { |
| 281 | case 1 : | 350 | case 1 : |
| 282 | // InternalSolverLanguage.g:115:3: this_Interpretation_0= ruleInterpretation | 351 | // InternalSolverLanguage.g:117:4: this_AssertionOrDefinition_0= ruleAssertionOrDefinition |
| 283 | { | 352 | { |
| 353 | if ( state.backtracking==0 ) { | ||
| 284 | 354 | ||
| 285 | newCompositeNode(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); | 355 | newCompositeNode(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); |
| 286 | 356 | ||
| 287 | pushFollow(FOLLOW_2); | 357 | } |
| 288 | this_Interpretation_0=ruleInterpretation(); | 358 | pushFollow(FOLLOW_4); |
| 359 | this_AssertionOrDefinition_0=ruleAssertionOrDefinition(); | ||
| 289 | 360 | ||
| 290 | state._fsp--; | 361 | state._fsp--; |
| 362 | if (state.failed) return current; | ||
| 363 | if ( state.backtracking==0 ) { | ||
| 291 | 364 | ||
| 292 | 365 | current = this_AssertionOrDefinition_0; | |
| 293 | current = this_Interpretation_0; | 366 | afterParserOrEnumRuleCall(); |
| 294 | afterParserOrEnumRuleCall(); | 367 | |
| 295 | 368 | } | |
| 296 | 369 | ||
| 297 | } | 370 | } |
| 298 | break; | 371 | break; |
| 299 | case 2 : | 372 | case 2 : |
| 300 | // InternalSolverLanguage.g:124:3: this_Predicate_1= rulePredicate | 373 | // InternalSolverLanguage.g:126:4: this_PredicateDefinition_1= rulePredicateDefinition |
| 301 | { | 374 | { |
| 375 | if ( state.backtracking==0 ) { | ||
| 302 | 376 | ||
| 303 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); | 377 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); |
| 304 | 378 | ||
| 305 | pushFollow(FOLLOW_2); | 379 | } |
| 306 | this_Predicate_1=rulePredicate(); | 380 | pushFollow(FOLLOW_4); |
| 381 | this_PredicateDefinition_1=rulePredicateDefinition(); | ||
| 307 | 382 | ||
| 308 | state._fsp--; | 383 | state._fsp--; |
| 384 | if (state.failed) return current; | ||
| 385 | if ( state.backtracking==0 ) { | ||
| 309 | 386 | ||
| 310 | 387 | current = this_PredicateDefinition_1; | |
| 311 | current = this_Predicate_1; | 388 | afterParserOrEnumRuleCall(); |
| 312 | afterParserOrEnumRuleCall(); | 389 | |
| 313 | 390 | } | |
| 314 | 391 | ||
| 315 | } | 392 | } |
| 316 | break; | 393 | break; |
| 394 | case 3 : | ||
| 395 | // InternalSolverLanguage.g:135:4: this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | ||
| 396 | { | ||
| 397 | if ( state.backtracking==0 ) { | ||
| 317 | 398 | ||
| 318 | } | 399 | newCompositeNode(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); |
| 400 | |||
| 401 | } | ||
| 402 | pushFollow(FOLLOW_4); | ||
| 403 | this_UnnamedErrorPrediateDefinition_2=ruleUnnamedErrorPrediateDefinition(); | ||
| 319 | 404 | ||
| 405 | state._fsp--; | ||
| 406 | if (state.failed) return current; | ||
| 407 | if ( state.backtracking==0 ) { | ||
| 320 | 408 | ||
| 321 | } | 409 | current = this_UnnamedErrorPrediateDefinition_2; |
| 410 | afterParserOrEnumRuleCall(); | ||
| 411 | |||
| 412 | } | ||
| 322 | 413 | ||
| 414 | } | ||
| 415 | break; | ||
| 416 | case 4 : | ||
| 417 | // InternalSolverLanguage.g:144:4: this_DefaultDefinition_3= ruleDefaultDefinition | ||
| 418 | { | ||
| 419 | if ( state.backtracking==0 ) { | ||
| 323 | 420 | ||
| 324 | leaveRule(); | 421 | newCompositeNode(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); |
| 422 | |||
| 423 | } | ||
| 424 | pushFollow(FOLLOW_4); | ||
| 425 | this_DefaultDefinition_3=ruleDefaultDefinition(); | ||
| 325 | 426 | ||
| 326 | } | 427 | state._fsp--; |
| 428 | if (state.failed) return current; | ||
| 429 | if ( state.backtracking==0 ) { | ||
| 327 | 430 | ||
| 328 | catch (RecognitionException re) { | 431 | current = this_DefaultDefinition_3; |
| 329 | recover(input,re); | 432 | afterParserOrEnumRuleCall(); |
| 330 | appendSkippedTokens(); | 433 | |
| 331 | } | 434 | } |
| 332 | finally { | ||
| 333 | } | ||
| 334 | return current; | ||
| 335 | } | ||
| 336 | // $ANTLR end "ruleStatement" | ||
| 337 | 435 | ||
| 436 | } | ||
| 437 | break; | ||
| 438 | case 5 : | ||
| 439 | // InternalSolverLanguage.g:153:4: this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | ||
| 440 | { | ||
| 441 | if ( state.backtracking==0 ) { | ||
| 338 | 442 | ||
| 339 | // $ANTLR start "entryRuleREALLiteral" | 443 | newCompositeNode(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); |
| 340 | // InternalSolverLanguage.g:136:1: entryRuleREALLiteral returns [String current=null] : iv_ruleREALLiteral= ruleREALLiteral EOF ; | 444 | |
| 341 | public final String entryRuleREALLiteral() throws RecognitionException { | 445 | } |
| 342 | String current = null; | 446 | pushFollow(FOLLOW_4); |
| 447 | this_ExternPredicateDefinition_4=ruleExternPredicateDefinition(); | ||
| 343 | 448 | ||
| 344 | AntlrDatatypeRuleToken iv_ruleREALLiteral = null; | 449 | state._fsp--; |
| 450 | if (state.failed) return current; | ||
| 451 | if ( state.backtracking==0 ) { | ||
| 345 | 452 | ||
| 453 | current = this_ExternPredicateDefinition_4; | ||
| 454 | afterParserOrEnumRuleCall(); | ||
| 455 | |||
| 456 | } | ||
| 346 | 457 | ||
| 347 | try { | 458 | } |
| 348 | // InternalSolverLanguage.g:136:51: (iv_ruleREALLiteral= ruleREALLiteral EOF ) | 459 | break; |
| 349 | // InternalSolverLanguage.g:137:2: iv_ruleREALLiteral= ruleREALLiteral EOF | 460 | case 6 : |
| 350 | { | 461 | // InternalSolverLanguage.g:162:4: this_MetricDefinition_5= ruleMetricDefinition |
| 351 | newCompositeNode(grammarAccess.getREALLiteralRule()); | 462 | { |
| 352 | pushFollow(FOLLOW_1); | 463 | if ( state.backtracking==0 ) { |
| 353 | iv_ruleREALLiteral=ruleREALLiteral(); | ||
| 354 | 464 | ||
| 355 | state._fsp--; | 465 | newCompositeNode(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); |
| 466 | |||
| 467 | } | ||
| 468 | pushFollow(FOLLOW_4); | ||
| 469 | this_MetricDefinition_5=ruleMetricDefinition(); | ||
| 356 | 470 | ||
| 357 | current =iv_ruleREALLiteral.getText(); | 471 | state._fsp--; |
| 358 | match(input,EOF,FOLLOW_2); | 472 | if (state.failed) return current; |
| 473 | if ( state.backtracking==0 ) { | ||
| 359 | 474 | ||
| 360 | } | 475 | current = this_MetricDefinition_5; |
| 476 | afterParserOrEnumRuleCall(); | ||
| 477 | |||
| 478 | } | ||
| 361 | 479 | ||
| 362 | } | 480 | } |
| 481 | break; | ||
| 482 | case 7 : | ||
| 483 | // InternalSolverLanguage.g:171:4: this_ExternMetricDefinition_6= ruleExternMetricDefinition | ||
| 484 | { | ||
| 485 | if ( state.backtracking==0 ) { | ||
| 363 | 486 | ||
| 364 | catch (RecognitionException re) { | 487 | newCompositeNode(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); |
| 365 | recover(input,re); | 488 | |
| 366 | appendSkippedTokens(); | 489 | } |
| 367 | } | 490 | pushFollow(FOLLOW_4); |
| 368 | finally { | 491 | this_ExternMetricDefinition_6=ruleExternMetricDefinition(); |
| 369 | } | ||
| 370 | return current; | ||
| 371 | } | ||
| 372 | // $ANTLR end "entryRuleREALLiteral" | ||
| 373 | 492 | ||
| 493 | state._fsp--; | ||
| 494 | if (state.failed) return current; | ||
| 495 | if ( state.backtracking==0 ) { | ||
| 374 | 496 | ||
| 375 | // $ANTLR start "ruleREALLiteral" | 497 | current = this_ExternMetricDefinition_6; |
| 376 | // InternalSolverLanguage.g:143:1: ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) ; | 498 | afterParserOrEnumRuleCall(); |
| 377 | public final AntlrDatatypeRuleToken ruleREALLiteral() throws RecognitionException { | 499 | |
| 378 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | 500 | } |
| 379 | 501 | ||
| 380 | Token kw=null; | 502 | } |
| 381 | Token this_INT_1=null; | 503 | break; |
| 382 | Token this_INT_3=null; | 504 | case 8 : |
| 505 | // InternalSolverLanguage.g:180:4: this_ClassDefinition_7= ruleClassDefinition | ||
| 506 | { | ||
| 507 | if ( state.backtracking==0 ) { | ||
| 383 | 508 | ||
| 509 | newCompositeNode(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); | ||
| 510 | |||
| 511 | } | ||
| 512 | pushFollow(FOLLOW_4); | ||
| 513 | this_ClassDefinition_7=ruleClassDefinition(); | ||
| 384 | 514 | ||
| 385 | enterRule(); | 515 | state._fsp--; |
| 516 | if (state.failed) return current; | ||
| 517 | if ( state.backtracking==0 ) { | ||
| 386 | 518 | ||
| 387 | try { | 519 | current = this_ClassDefinition_7; |
| 388 | // InternalSolverLanguage.g:149:2: ( ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) ) | 520 | afterParserOrEnumRuleCall(); |
| 389 | // InternalSolverLanguage.g:150:2: ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) | 521 | |
| 390 | { | 522 | } |
| 391 | // InternalSolverLanguage.g:150:2: ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) | ||
| 392 | // InternalSolverLanguage.g:151:3: (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT | ||
| 393 | { | ||
| 394 | // InternalSolverLanguage.g:151:3: (kw= '-' )? | ||
| 395 | int alt3=2; | ||
| 396 | int LA3_0 = input.LA(1); | ||
| 397 | 523 | ||
| 398 | if ( (LA3_0==11) ) { | 524 | } |
| 399 | alt3=1; | 525 | break; |
| 400 | } | 526 | case 9 : |
| 401 | switch (alt3) { | 527 | // InternalSolverLanguage.g:189:4: this_ScopeDefinition_8= ruleScopeDefinition |
| 402 | case 1 : | ||
| 403 | // InternalSolverLanguage.g:152:4: kw= '-' | ||
| 404 | { | 528 | { |
| 405 | kw=(Token)match(input,11,FOLLOW_4); | 529 | if ( state.backtracking==0 ) { |
| 406 | 530 | ||
| 407 | current.merge(kw); | 531 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); |
| 408 | newLeafNode(kw, grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); | 532 | |
| 409 | 533 | } | |
| 534 | pushFollow(FOLLOW_4); | ||
| 535 | this_ScopeDefinition_8=ruleScopeDefinition(); | ||
| 536 | |||
| 537 | state._fsp--; | ||
| 538 | if (state.failed) return current; | ||
| 539 | if ( state.backtracking==0 ) { | ||
| 540 | |||
| 541 | current = this_ScopeDefinition_8; | ||
| 542 | afterParserOrEnumRuleCall(); | ||
| 543 | |||
| 544 | } | ||
| 410 | 545 | ||
| 411 | } | 546 | } |
| 412 | break; | 547 | break; |
| 548 | case 10 : | ||
| 549 | // InternalSolverLanguage.g:198:4: this_ObjectiveDefinition_9= ruleObjectiveDefinition | ||
| 550 | { | ||
| 551 | if ( state.backtracking==0 ) { | ||
| 413 | 552 | ||
| 414 | } | 553 | newCompositeNode(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); |
| 554 | |||
| 555 | } | ||
| 556 | pushFollow(FOLLOW_4); | ||
| 557 | this_ObjectiveDefinition_9=ruleObjectiveDefinition(); | ||
| 415 | 558 | ||
| 416 | this_INT_1=(Token)match(input,RULE_INT,FOLLOW_5); | 559 | state._fsp--; |
| 560 | if (state.failed) return current; | ||
| 561 | if ( state.backtracking==0 ) { | ||
| 417 | 562 | ||
| 418 | current.merge(this_INT_1); | 563 | current = this_ObjectiveDefinition_9; |
| 419 | 564 | afterParserOrEnumRuleCall(); | |
| 565 | |||
| 566 | } | ||
| 420 | 567 | ||
| 421 | newLeafNode(this_INT_1, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); | 568 | } |
| 422 | 569 | break; | |
| 423 | kw=(Token)match(input,12,FOLLOW_4); | ||
| 424 | 570 | ||
| 425 | current.merge(kw); | 571 | } |
| 426 | newLeafNode(kw, grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); | ||
| 427 | |||
| 428 | this_INT_3=(Token)match(input,RULE_INT,FOLLOW_2); | ||
| 429 | 572 | ||
| 430 | current.merge(this_INT_3); | 573 | this_DOT_10=(Token)match(input,RULE_DOT,FOLLOW_2); if (state.failed) return current; |
| 431 | 574 | if ( state.backtracking==0 ) { | |
| 432 | 575 | ||
| 433 | newLeafNode(this_INT_3, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); | 576 | newLeafNode(this_DOT_10, grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1()); |
| 434 | 577 | ||
| 578 | } | ||
| 435 | 579 | ||
| 436 | } | 580 | } |
| 437 | 581 | ||
| 438 | 582 | ||
| 439 | } | 583 | } |
| 440 | 584 | ||
| 585 | if ( state.backtracking==0 ) { | ||
| 441 | 586 | ||
| 442 | leaveRule(); | 587 | leaveRule(); |
| 443 | 588 | ||
| 589 | } | ||
| 444 | } | 590 | } |
| 445 | 591 | ||
| 446 | catch (RecognitionException re) { | 592 | catch (RecognitionException re) { |
| @@ -451,29 +597,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 451 | } | 597 | } |
| 452 | return current; | 598 | return current; |
| 453 | } | 599 | } |
| 454 | // $ANTLR end "ruleREALLiteral" | 600 | // $ANTLR end "ruleStatement" |
| 455 | 601 | ||
| 456 | 602 | ||
| 457 | // $ANTLR start "entryRuleINTLiteral" | 603 | // $ANTLR start "entryRuleAssertionOrDefinition" |
| 458 | // InternalSolverLanguage.g:181:1: entryRuleINTLiteral returns [String current=null] : iv_ruleINTLiteral= ruleINTLiteral EOF ; | 604 | // InternalSolverLanguage.g:215:1: entryRuleAssertionOrDefinition returns [EObject current=null] : iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF ; |
| 459 | public final String entryRuleINTLiteral() throws RecognitionException { | 605 | public final EObject entryRuleAssertionOrDefinition() throws RecognitionException { |
| 460 | String current = null; | 606 | EObject current = null; |
| 461 | 607 | ||
| 462 | AntlrDatatypeRuleToken iv_ruleINTLiteral = null; | 608 | EObject iv_ruleAssertionOrDefinition = null; |
| 463 | 609 | ||
| 464 | 610 | ||
| 465 | try { | 611 | try { |
| 466 | // InternalSolverLanguage.g:181:50: (iv_ruleINTLiteral= ruleINTLiteral EOF ) | 612 | // InternalSolverLanguage.g:215:62: (iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF ) |
| 467 | // InternalSolverLanguage.g:182:2: iv_ruleINTLiteral= ruleINTLiteral EOF | 613 | // InternalSolverLanguage.g:216:2: iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF |
| 468 | { | 614 | { |
| 469 | newCompositeNode(grammarAccess.getINTLiteralRule()); | 615 | if ( state.backtracking==0 ) { |
| 616 | newCompositeNode(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 617 | } | ||
| 470 | pushFollow(FOLLOW_1); | 618 | pushFollow(FOLLOW_1); |
| 471 | iv_ruleINTLiteral=ruleINTLiteral(); | 619 | iv_ruleAssertionOrDefinition=ruleAssertionOrDefinition(); |
| 472 | 620 | ||
| 473 | state._fsp--; | 621 | state._fsp--; |
| 474 | 622 | if (state.failed) return current; | |
| 475 | current =iv_ruleINTLiteral.getText(); | 623 | if ( state.backtracking==0 ) { |
| 476 | match(input,EOF,FOLLOW_2); | 624 | current =iv_ruleAssertionOrDefinition; |
| 625 | } | ||
| 626 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 477 | 627 | ||
| 478 | } | 628 | } |
| 479 | 629 | ||
| @@ -487,191 +637,287 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 487 | } | 637 | } |
| 488 | return current; | 638 | return current; |
| 489 | } | 639 | } |
| 490 | // $ANTLR end "entryRuleINTLiteral" | 640 | // $ANTLR end "entryRuleAssertionOrDefinition" |
| 491 | 641 | ||
| 492 | 642 | ||
| 493 | // $ANTLR start "ruleINTLiteral" | 643 | // $ANTLR start "ruleAssertionOrDefinition" |
| 494 | // InternalSolverLanguage.g:188:1: ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT ) ; | 644 | // InternalSolverLanguage.g:222:1: ruleAssertionOrDefinition returns [EObject current=null] : (this_Expression_0= ruleExpression ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) ) ; |
| 495 | public final AntlrDatatypeRuleToken ruleINTLiteral() throws RecognitionException { | 645 | public final EObject ruleAssertionOrDefinition() throws RecognitionException { |
| 496 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | 646 | EObject current = null; |
| 647 | |||
| 648 | Token otherlv_2=null; | ||
| 649 | Token otherlv_5=null; | ||
| 650 | Token otherlv_8=null; | ||
| 651 | EObject this_Expression_0 = null; | ||
| 652 | |||
| 653 | EObject lv_range_3_0 = null; | ||
| 654 | |||
| 655 | EObject lv_body_6_0 = null; | ||
| 656 | |||
| 657 | EObject lv_body_9_0 = null; | ||
| 497 | 658 | ||
| 498 | Token kw=null; | ||
| 499 | Token this_INT_1=null; | ||
| 500 | 659 | ||
| 501 | 660 | ||
| 502 | enterRule(); | 661 | enterRule(); |
| 503 | 662 | ||
| 504 | try { | 663 | try { |
| 505 | // InternalSolverLanguage.g:194:2: ( ( (kw= '-' )? this_INT_1= RULE_INT ) ) | 664 | // InternalSolverLanguage.g:228:2: ( (this_Expression_0= ruleExpression ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) ) ) |
| 506 | // InternalSolverLanguage.g:195:2: ( (kw= '-' )? this_INT_1= RULE_INT ) | 665 | // InternalSolverLanguage.g:229:2: (this_Expression_0= ruleExpression ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) ) |
| 507 | { | 666 | { |
| 508 | // InternalSolverLanguage.g:195:2: ( (kw= '-' )? this_INT_1= RULE_INT ) | 667 | // InternalSolverLanguage.g:229:2: (this_Expression_0= ruleExpression ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) ) |
| 509 | // InternalSolverLanguage.g:196:3: (kw= '-' )? this_INT_1= RULE_INT | 668 | // InternalSolverLanguage.g:230:3: this_Expression_0= ruleExpression ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) |
| 510 | { | 669 | { |
| 511 | // InternalSolverLanguage.g:196:3: (kw= '-' )? | 670 | if ( state.backtracking==0 ) { |
| 512 | int alt4=2; | 671 | |
| 513 | int LA4_0 = input.LA(1); | 672 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); |
| 673 | |||
| 674 | } | ||
| 675 | pushFollow(FOLLOW_5); | ||
| 676 | this_Expression_0=ruleExpression(); | ||
| 514 | 677 | ||
| 515 | if ( (LA4_0==11) ) { | 678 | state._fsp--; |
| 679 | if (state.failed) return current; | ||
| 680 | if ( state.backtracking==0 ) { | ||
| 681 | |||
| 682 | current = this_Expression_0; | ||
| 683 | afterParserOrEnumRuleCall(); | ||
| 684 | |||
| 685 | } | ||
| 686 | // InternalSolverLanguage.g:238:3: ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) | ||
| 687 | int alt4=3; | ||
| 688 | switch ( input.LA(1) ) { | ||
| 689 | case EOF: | ||
| 690 | case RULE_DOT: | ||
| 691 | case 15: | ||
| 692 | { | ||
| 516 | alt4=1; | 693 | alt4=1; |
| 694 | } | ||
| 695 | break; | ||
| 696 | case 16: | ||
| 697 | { | ||
| 698 | alt4=2; | ||
| 699 | } | ||
| 700 | break; | ||
| 701 | case 17: | ||
| 702 | { | ||
| 703 | alt4=3; | ||
| 704 | } | ||
| 705 | break; | ||
| 706 | default: | ||
| 707 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 708 | NoViableAltException nvae = | ||
| 709 | new NoViableAltException("", 4, 0, input); | ||
| 710 | |||
| 711 | throw nvae; | ||
| 517 | } | 712 | } |
| 713 | |||
| 518 | switch (alt4) { | 714 | switch (alt4) { |
| 519 | case 1 : | 715 | case 1 : |
| 520 | // InternalSolverLanguage.g:197:4: kw= '-' | 716 | // InternalSolverLanguage.g:239:4: ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) |
| 521 | { | 717 | { |
| 522 | kw=(Token)match(input,11,FOLLOW_4); | 718 | // InternalSolverLanguage.g:239:4: ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) |
| 523 | 719 | // InternalSolverLanguage.g:240:5: () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? | |
| 524 | current.merge(kw); | 720 | { |
| 525 | newLeafNode(kw, grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); | 721 | // InternalSolverLanguage.g:240:5: () |
| 526 | 722 | // InternalSolverLanguage.g:241:6: | |
| 723 | { | ||
| 724 | if ( state.backtracking==0 ) { | ||
| 527 | 725 | ||
| 726 | current = forceCreateModelElementAndSet( | ||
| 727 | grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0(), | ||
| 728 | current); | ||
| 729 | |||
| 528 | } | 730 | } |
| 529 | break; | ||
| 530 | 731 | ||
| 531 | } | 732 | } |
| 532 | 733 | ||
| 533 | this_INT_1=(Token)match(input,RULE_INT,FOLLOW_2); | 734 | // InternalSolverLanguage.g:247:5: (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? |
| 735 | int alt3=2; | ||
| 736 | int LA3_0 = input.LA(1); | ||
| 534 | 737 | ||
| 535 | current.merge(this_INT_1); | 738 | if ( (LA3_0==15) ) { |
| 536 | 739 | alt3=1; | |
| 740 | } | ||
| 741 | switch (alt3) { | ||
| 742 | case 1 : | ||
| 743 | // InternalSolverLanguage.g:248:6: otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) | ||
| 744 | { | ||
| 745 | otherlv_2=(Token)match(input,15,FOLLOW_6); if (state.failed) return current; | ||
| 746 | if ( state.backtracking==0 ) { | ||
| 537 | 747 | ||
| 538 | newLeafNode(this_INT_1, grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); | 748 | newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); |
| 539 | 749 | ||
| 750 | } | ||
| 751 | // InternalSolverLanguage.g:252:6: ( (lv_range_3_0= ruleExpression ) ) | ||
| 752 | // InternalSolverLanguage.g:253:7: (lv_range_3_0= ruleExpression ) | ||
| 753 | { | ||
| 754 | // InternalSolverLanguage.g:253:7: (lv_range_3_0= ruleExpression ) | ||
| 755 | // InternalSolverLanguage.g:254:8: lv_range_3_0= ruleExpression | ||
| 756 | { | ||
| 757 | if ( state.backtracking==0 ) { | ||
| 540 | 758 | ||
| 541 | } | 759 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); |
| 760 | |||
| 761 | } | ||
| 762 | pushFollow(FOLLOW_2); | ||
| 763 | lv_range_3_0=ruleExpression(); | ||
| 542 | 764 | ||
| 765 | state._fsp--; | ||
| 766 | if (state.failed) return current; | ||
| 767 | if ( state.backtracking==0 ) { | ||
| 768 | |||
| 769 | if (current==null) { | ||
| 770 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 771 | } | ||
| 772 | set( | ||
| 773 | current, | ||
| 774 | "range", | ||
| 775 | lv_range_3_0, | ||
| 776 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 777 | afterParserOrEnumRuleCall(); | ||
| 778 | |||
| 779 | } | ||
| 543 | 780 | ||
| 544 | } | 781 | } |
| 545 | 782 | ||
| 546 | 783 | ||
| 547 | leaveRule(); | 784 | } |
| 548 | 785 | ||
| 549 | } | ||
| 550 | 786 | ||
| 551 | catch (RecognitionException re) { | 787 | } |
| 552 | recover(input,re); | 788 | break; |
| 553 | appendSkippedTokens(); | ||
| 554 | } | ||
| 555 | finally { | ||
| 556 | } | ||
| 557 | return current; | ||
| 558 | } | ||
| 559 | // $ANTLR end "ruleINTLiteral" | ||
| 560 | 789 | ||
| 790 | } | ||
| 561 | 791 | ||
| 562 | // $ANTLR start "entryRuleBooleanValue" | ||
| 563 | // InternalSolverLanguage.g:214:1: entryRuleBooleanValue returns [EObject current=null] : iv_ruleBooleanValue= ruleBooleanValue EOF ; | ||
| 564 | public final EObject entryRuleBooleanValue() throws RecognitionException { | ||
| 565 | EObject current = null; | ||
| 566 | 792 | ||
| 567 | EObject iv_ruleBooleanValue = null; | 793 | } |
| 568 | 794 | ||
| 569 | 795 | ||
| 570 | try { | 796 | } |
| 571 | // InternalSolverLanguage.g:214:53: (iv_ruleBooleanValue= ruleBooleanValue EOF ) | 797 | break; |
| 572 | // InternalSolverLanguage.g:215:2: iv_ruleBooleanValue= ruleBooleanValue EOF | 798 | case 2 : |
| 573 | { | 799 | // InternalSolverLanguage.g:274:4: ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) |
| 574 | newCompositeNode(grammarAccess.getBooleanValueRule()); | 800 | { |
| 575 | pushFollow(FOLLOW_1); | 801 | // InternalSolverLanguage.g:274:4: ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) |
| 576 | iv_ruleBooleanValue=ruleBooleanValue(); | 802 | // InternalSolverLanguage.g:275:5: () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) |
| 803 | { | ||
| 804 | // InternalSolverLanguage.g:275:5: () | ||
| 805 | // InternalSolverLanguage.g:276:6: | ||
| 806 | { | ||
| 807 | if ( state.backtracking==0 ) { | ||
| 577 | 808 | ||
| 578 | state._fsp--; | 809 | current = forceCreateModelElementAndSet( |
| 810 | grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), | ||
| 811 | current); | ||
| 812 | |||
| 813 | } | ||
| 579 | 814 | ||
| 580 | current =iv_ruleBooleanValue; | 815 | } |
| 581 | match(input,EOF,FOLLOW_2); | ||
| 582 | 816 | ||
| 583 | } | 817 | otherlv_5=(Token)match(input,16,FOLLOW_6); if (state.failed) return current; |
| 818 | if ( state.backtracking==0 ) { | ||
| 584 | 819 | ||
| 585 | } | 820 | newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); |
| 821 | |||
| 822 | } | ||
| 823 | // InternalSolverLanguage.g:286:5: ( (lv_body_6_0= ruleExpression ) ) | ||
| 824 | // InternalSolverLanguage.g:287:6: (lv_body_6_0= ruleExpression ) | ||
| 825 | { | ||
| 826 | // InternalSolverLanguage.g:287:6: (lv_body_6_0= ruleExpression ) | ||
| 827 | // InternalSolverLanguage.g:288:7: lv_body_6_0= ruleExpression | ||
| 828 | { | ||
| 829 | if ( state.backtracking==0 ) { | ||
| 586 | 830 | ||
| 587 | catch (RecognitionException re) { | 831 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); |
| 588 | recover(input,re); | 832 | |
| 589 | appendSkippedTokens(); | 833 | } |
| 590 | } | 834 | pushFollow(FOLLOW_2); |
| 591 | finally { | 835 | lv_body_6_0=ruleExpression(); |
| 592 | } | ||
| 593 | return current; | ||
| 594 | } | ||
| 595 | // $ANTLR end "entryRuleBooleanValue" | ||
| 596 | 836 | ||
| 837 | state._fsp--; | ||
| 838 | if (state.failed) return current; | ||
| 839 | if ( state.backtracking==0 ) { | ||
| 840 | |||
| 841 | if (current==null) { | ||
| 842 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 843 | } | ||
| 844 | set( | ||
| 845 | current, | ||
| 846 | "body", | ||
| 847 | lv_body_6_0, | ||
| 848 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 849 | afterParserOrEnumRuleCall(); | ||
| 850 | |||
| 851 | } | ||
| 597 | 852 | ||
| 598 | // $ANTLR start "ruleBooleanValue" | 853 | } |
| 599 | // InternalSolverLanguage.g:221:1: ruleBooleanValue returns [EObject current=null] : ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) ; | ||
| 600 | public final EObject ruleBooleanValue() throws RecognitionException { | ||
| 601 | EObject current = null; | ||
| 602 | 854 | ||
| 603 | Token otherlv_1=null; | ||
| 604 | Token otherlv_2=null; | ||
| 605 | 855 | ||
| 856 | } | ||
| 606 | 857 | ||
| 607 | enterRule(); | ||
| 608 | 858 | ||
| 609 | try { | 859 | } |
| 610 | // InternalSolverLanguage.g:227:2: ( ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) ) | ||
| 611 | // InternalSolverLanguage.g:228:2: ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) | ||
| 612 | { | ||
| 613 | // InternalSolverLanguage.g:228:2: ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) | ||
| 614 | int alt5=2; | ||
| 615 | int LA5_0 = input.LA(1); | ||
| 616 | 860 | ||
| 617 | if ( (LA5_0==13) ) { | ||
| 618 | alt5=1; | ||
| 619 | } | ||
| 620 | else if ( (LA5_0==14) ) { | ||
| 621 | alt5=2; | ||
| 622 | } | ||
| 623 | else { | ||
| 624 | NoViableAltException nvae = | ||
| 625 | new NoViableAltException("", 5, 0, input); | ||
| 626 | 861 | ||
| 627 | throw nvae; | 862 | } |
| 628 | } | 863 | break; |
| 629 | switch (alt5) { | 864 | case 3 : |
| 630 | case 1 : | 865 | // InternalSolverLanguage.g:307:4: ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) |
| 631 | // InternalSolverLanguage.g:229:3: ( () otherlv_1= 'true' ) | ||
| 632 | { | 866 | { |
| 633 | // InternalSolverLanguage.g:229:3: ( () otherlv_1= 'true' ) | 867 | // InternalSolverLanguage.g:307:4: ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) |
| 634 | // InternalSolverLanguage.g:230:4: () otherlv_1= 'true' | 868 | // InternalSolverLanguage.g:308:5: () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) |
| 635 | { | 869 | { |
| 636 | // InternalSolverLanguage.g:230:4: () | 870 | // InternalSolverLanguage.g:308:5: () |
| 637 | // InternalSolverLanguage.g:231:5: | 871 | // InternalSolverLanguage.g:309:6: |
| 638 | { | 872 | { |
| 873 | if ( state.backtracking==0 ) { | ||
| 639 | 874 | ||
| 640 | current = forceCreateModelElement( | 875 | current = forceCreateModelElementAndSet( |
| 641 | grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0(), | 876 | grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(), |
| 642 | current); | 877 | current); |
| 643 | 878 | ||
| 644 | |||
| 645 | } | 879 | } |
| 646 | 880 | ||
| 647 | otherlv_1=(Token)match(input,13,FOLLOW_2); | ||
| 648 | |||
| 649 | newLeafNode(otherlv_1, grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); | ||
| 650 | |||
| 651 | |||
| 652 | } | 881 | } |
| 653 | 882 | ||
| 883 | otherlv_8=(Token)match(input,17,FOLLOW_6); if (state.failed) return current; | ||
| 884 | if ( state.backtracking==0 ) { | ||
| 654 | 885 | ||
| 886 | newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); | ||
| 887 | |||
| 655 | } | 888 | } |
| 656 | break; | 889 | // InternalSolverLanguage.g:319:5: ( (lv_body_9_0= ruleExpression ) ) |
| 657 | case 2 : | 890 | // InternalSolverLanguage.g:320:6: (lv_body_9_0= ruleExpression ) |
| 658 | // InternalSolverLanguage.g:243:3: (otherlv_2= 'false' () ) | ||
| 659 | { | 891 | { |
| 660 | // InternalSolverLanguage.g:243:3: (otherlv_2= 'false' () ) | 892 | // InternalSolverLanguage.g:320:6: (lv_body_9_0= ruleExpression ) |
| 661 | // InternalSolverLanguage.g:244:4: otherlv_2= 'false' () | 893 | // InternalSolverLanguage.g:321:7: lv_body_9_0= ruleExpression |
| 662 | { | 894 | { |
| 663 | otherlv_2=(Token)match(input,14,FOLLOW_2); | 895 | if ( state.backtracking==0 ) { |
| 664 | 896 | ||
| 665 | newLeafNode(otherlv_2, grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); | 897 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); |
| 666 | 898 | ||
| 667 | // InternalSolverLanguage.g:248:4: () | 899 | } |
| 668 | // InternalSolverLanguage.g:249:5: | 900 | pushFollow(FOLLOW_2); |
| 669 | { | 901 | lv_body_9_0=ruleExpression(); |
| 902 | |||
| 903 | state._fsp--; | ||
| 904 | if (state.failed) return current; | ||
| 905 | if ( state.backtracking==0 ) { | ||
| 906 | |||
| 907 | if (current==null) { | ||
| 908 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 909 | } | ||
| 910 | set( | ||
| 911 | current, | ||
| 912 | "body", | ||
| 913 | lv_body_9_0, | ||
| 914 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 915 | afterParserOrEnumRuleCall(); | ||
| 916 | |||
| 917 | } | ||
| 918 | |||
| 919 | } | ||
| 670 | 920 | ||
| 671 | current = forceCreateModelElement( | ||
| 672 | grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1(), | ||
| 673 | current); | ||
| 674 | |||
| 675 | 921 | ||
| 676 | } | 922 | } |
| 677 | 923 | ||
| @@ -688,8 +934,13 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 688 | } | 934 | } |
| 689 | 935 | ||
| 690 | 936 | ||
| 691 | leaveRule(); | 937 | } |
| 938 | |||
| 939 | if ( state.backtracking==0 ) { | ||
| 692 | 940 | ||
| 941 | leaveRule(); | ||
| 942 | |||
| 943 | } | ||
| 693 | } | 944 | } |
| 694 | 945 | ||
| 695 | catch (RecognitionException re) { | 946 | catch (RecognitionException re) { |
| @@ -700,29 +951,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 700 | } | 951 | } |
| 701 | return current; | 952 | return current; |
| 702 | } | 953 | } |
| 703 | // $ANTLR end "ruleBooleanValue" | 954 | // $ANTLR end "ruleAssertionOrDefinition" |
| 704 | 955 | ||
| 705 | 956 | ||
| 706 | // $ANTLR start "entryRuleTruthValue" | 957 | // $ANTLR start "entryRulePredicateDefinition" |
| 707 | // InternalSolverLanguage.g:260:1: entryRuleTruthValue returns [EObject current=null] : iv_ruleTruthValue= ruleTruthValue EOF ; | 958 | // InternalSolverLanguage.g:344:1: entryRulePredicateDefinition returns [EObject current=null] : iv_rulePredicateDefinition= rulePredicateDefinition EOF ; |
| 708 | public final EObject entryRuleTruthValue() throws RecognitionException { | 959 | public final EObject entryRulePredicateDefinition() throws RecognitionException { |
| 709 | EObject current = null; | 960 | EObject current = null; |
| 710 | 961 | ||
| 711 | EObject iv_ruleTruthValue = null; | 962 | EObject iv_rulePredicateDefinition = null; |
| 712 | 963 | ||
| 713 | 964 | ||
| 714 | try { | 965 | try { |
| 715 | // InternalSolverLanguage.g:260:51: (iv_ruleTruthValue= ruleTruthValue EOF ) | 966 | // InternalSolverLanguage.g:344:60: (iv_rulePredicateDefinition= rulePredicateDefinition EOF ) |
| 716 | // InternalSolverLanguage.g:261:2: iv_ruleTruthValue= ruleTruthValue EOF | 967 | // InternalSolverLanguage.g:345:2: iv_rulePredicateDefinition= rulePredicateDefinition EOF |
| 717 | { | 968 | { |
| 718 | newCompositeNode(grammarAccess.getTruthValueRule()); | 969 | if ( state.backtracking==0 ) { |
| 970 | newCompositeNode(grammarAccess.getPredicateDefinitionRule()); | ||
| 971 | } | ||
| 719 | pushFollow(FOLLOW_1); | 972 | pushFollow(FOLLOW_1); |
| 720 | iv_ruleTruthValue=ruleTruthValue(); | 973 | iv_rulePredicateDefinition=rulePredicateDefinition(); |
| 721 | 974 | ||
| 722 | state._fsp--; | 975 | state._fsp--; |
| 723 | 976 | if (state.failed) return current; | |
| 724 | current =iv_ruleTruthValue; | 977 | if ( state.backtracking==0 ) { |
| 725 | match(input,EOF,FOLLOW_2); | 978 | current =iv_rulePredicateDefinition; |
| 979 | } | ||
| 980 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 726 | 981 | ||
| 727 | } | 982 | } |
| 728 | 983 | ||
| @@ -736,159 +991,196 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 736 | } | 991 | } |
| 737 | return current; | 992 | return current; |
| 738 | } | 993 | } |
| 739 | // $ANTLR end "entryRuleTruthValue" | 994 | // $ANTLR end "entryRulePredicateDefinition" |
| 740 | 995 | ||
| 741 | 996 | ||
| 742 | // $ANTLR start "ruleTruthValue" | 997 | // $ANTLR start "rulePredicateDefinition" |
| 743 | // InternalSolverLanguage.g:267:1: ruleTruthValue returns [EObject current=null] : ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) ; | 998 | // InternalSolverLanguage.g:351:1: rulePredicateDefinition returns [EObject current=null] : ( ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) ; |
| 744 | public final EObject ruleTruthValue() throws RecognitionException { | 999 | public final EObject rulePredicateDefinition() throws RecognitionException { |
| 745 | EObject current = null; | 1000 | EObject current = null; |
| 746 | 1001 | ||
| 747 | Token otherlv_1=null; | 1002 | Token lv_functional_0_0=null; |
| 748 | Token otherlv_3=null; | 1003 | Token lv_error_1_0=null; |
| 1004 | Token lv_error_2_0=null; | ||
| 1005 | Token lv_functional_3_0=null; | ||
| 749 | Token otherlv_5=null; | 1006 | Token otherlv_5=null; |
| 750 | Token otherlv_7=null; | 1007 | EObject lv_head_4_0 = null; |
| 1008 | |||
| 1009 | EObject lv_body_6_0 = null; | ||
| 1010 | |||
| 751 | 1011 | ||
| 752 | 1012 | ||
| 753 | enterRule(); | 1013 | enterRule(); |
| 754 | 1014 | ||
| 755 | try { | 1015 | try { |
| 756 | // InternalSolverLanguage.g:273:2: ( ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) ) | 1016 | // InternalSolverLanguage.g:357:2: ( ( ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) ) |
| 757 | // InternalSolverLanguage.g:274:2: ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) | 1017 | // InternalSolverLanguage.g:358:2: ( ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) |
| 758 | { | 1018 | { |
| 759 | // InternalSolverLanguage.g:274:2: ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) | 1019 | // InternalSolverLanguage.g:358:2: ( ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) |
| 760 | int alt6=4; | 1020 | // InternalSolverLanguage.g:359:3: ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) |
| 761 | switch ( input.LA(1) ) { | 1021 | { |
| 762 | case 13: | 1022 | // InternalSolverLanguage.g:359:3: ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) |
| 763 | { | 1023 | int alt7=2; |
| 764 | alt6=1; | 1024 | int LA7_0 = input.LA(1); |
| 765 | } | 1025 | |
| 766 | break; | 1026 | if ( (LA7_0==18) ) { |
| 767 | case 14: | 1027 | alt7=1; |
| 768 | { | 1028 | } |
| 769 | alt6=2; | 1029 | else if ( (LA7_0==19) ) { |
| 770 | } | 1030 | alt7=2; |
| 771 | break; | 1031 | } |
| 772 | case 15: | 1032 | else { |
| 773 | { | 1033 | if (state.backtracking>0) {state.failed=true; return current;} |
| 774 | alt6=3; | ||
| 775 | } | ||
| 776 | break; | ||
| 777 | case 16: | ||
| 778 | { | ||
| 779 | alt6=4; | ||
| 780 | } | ||
| 781 | break; | ||
| 782 | default: | ||
| 783 | NoViableAltException nvae = | 1034 | NoViableAltException nvae = |
| 784 | new NoViableAltException("", 6, 0, input); | 1035 | new NoViableAltException("", 7, 0, input); |
| 785 | 1036 | ||
| 786 | throw nvae; | 1037 | throw nvae; |
| 787 | } | 1038 | } |
| 788 | 1039 | switch (alt7) { | |
| 789 | switch (alt6) { | ||
| 790 | case 1 : | 1040 | case 1 : |
| 791 | // InternalSolverLanguage.g:275:3: ( () otherlv_1= 'true' ) | 1041 | // InternalSolverLanguage.g:360:4: ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) |
| 1042 | { | ||
| 1043 | // InternalSolverLanguage.g:360:4: ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ||
| 1044 | // InternalSolverLanguage.g:361:5: ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? | ||
| 792 | { | 1045 | { |
| 793 | // InternalSolverLanguage.g:275:3: ( () otherlv_1= 'true' ) | 1046 | // InternalSolverLanguage.g:361:5: ( (lv_functional_0_0= 'functional' ) ) |
| 794 | // InternalSolverLanguage.g:276:4: () otherlv_1= 'true' | 1047 | // InternalSolverLanguage.g:362:6: (lv_functional_0_0= 'functional' ) |
| 795 | { | 1048 | { |
| 796 | // InternalSolverLanguage.g:276:4: () | 1049 | // InternalSolverLanguage.g:362:6: (lv_functional_0_0= 'functional' ) |
| 797 | // InternalSolverLanguage.g:277:5: | 1050 | // InternalSolverLanguage.g:363:7: lv_functional_0_0= 'functional' |
| 798 | { | 1051 | { |
| 1052 | lv_functional_0_0=(Token)match(input,18,FOLLOW_7); if (state.failed) return current; | ||
| 1053 | if ( state.backtracking==0 ) { | ||
| 799 | 1054 | ||
| 800 | current = forceCreateModelElement( | 1055 | newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); |
| 801 | grammarAccess.getTruthValueAccess().getTrueAction_0_0(), | 1056 | |
| 802 | current); | 1057 | } |
| 803 | 1058 | if ( state.backtracking==0 ) { | |
| 804 | 1059 | ||
| 1060 | if (current==null) { | ||
| 1061 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 1062 | } | ||
| 1063 | setWithLastConsumed(current, "functional", true, "functional"); | ||
| 1064 | |||
| 805 | } | 1065 | } |
| 806 | 1066 | ||
| 807 | otherlv_1=(Token)match(input,13,FOLLOW_2); | 1067 | } |
| 808 | 1068 | ||
| 809 | newLeafNode(otherlv_1, grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); | ||
| 810 | |||
| 811 | 1069 | ||
| 812 | } | 1070 | } |
| 813 | 1071 | ||
| 1072 | // InternalSolverLanguage.g:375:5: ( (lv_error_1_0= 'error' ) )? | ||
| 1073 | int alt5=2; | ||
| 1074 | int LA5_0 = input.LA(1); | ||
| 814 | 1075 | ||
| 1076 | if ( (LA5_0==19) ) { | ||
| 1077 | alt5=1; | ||
| 815 | } | 1078 | } |
| 816 | break; | 1079 | switch (alt5) { |
| 817 | case 2 : | 1080 | case 1 : |
| 818 | // InternalSolverLanguage.g:289:3: ( () otherlv_3= 'false' ) | 1081 | // InternalSolverLanguage.g:376:6: (lv_error_1_0= 'error' ) |
| 819 | { | 1082 | { |
| 820 | // InternalSolverLanguage.g:289:3: ( () otherlv_3= 'false' ) | 1083 | // InternalSolverLanguage.g:376:6: (lv_error_1_0= 'error' ) |
| 821 | // InternalSolverLanguage.g:290:4: () otherlv_3= 'false' | 1084 | // InternalSolverLanguage.g:377:7: lv_error_1_0= 'error' |
| 822 | { | 1085 | { |
| 823 | // InternalSolverLanguage.g:290:4: () | 1086 | lv_error_1_0=(Token)match(input,19,FOLLOW_7); if (state.failed) return current; |
| 824 | // InternalSolverLanguage.g:291:5: | 1087 | if ( state.backtracking==0 ) { |
| 825 | { | ||
| 826 | 1088 | ||
| 827 | current = forceCreateModelElement( | 1089 | newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); |
| 828 | grammarAccess.getTruthValueAccess().getFalseAction_1_0(), | 1090 | |
| 829 | current); | 1091 | } |
| 830 | 1092 | if ( state.backtracking==0 ) { | |
| 831 | 1093 | ||
| 832 | } | 1094 | if (current==null) { |
| 1095 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 1096 | } | ||
| 1097 | setWithLastConsumed(current, "error", true, "error"); | ||
| 1098 | |||
| 1099 | } | ||
| 833 | 1100 | ||
| 834 | otherlv_3=(Token)match(input,14,FOLLOW_2); | 1101 | } |
| 1102 | |||
| 1103 | |||
| 1104 | } | ||
| 1105 | break; | ||
| 1106 | |||
| 1107 | } | ||
| 835 | 1108 | ||
| 836 | newLeafNode(otherlv_3, grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); | ||
| 837 | |||
| 838 | 1109 | ||
| 839 | } | 1110 | } |
| 840 | 1111 | ||
| 841 | 1112 | ||
| 842 | } | 1113 | } |
| 843 | break; | 1114 | break; |
| 844 | case 3 : | 1115 | case 2 : |
| 845 | // InternalSolverLanguage.g:303:3: ( () otherlv_5= 'unknown' ) | 1116 | // InternalSolverLanguage.g:391:4: ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) |
| 1117 | { | ||
| 1118 | // InternalSolverLanguage.g:391:4: ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) | ||
| 1119 | // InternalSolverLanguage.g:392:5: ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? | ||
| 846 | { | 1120 | { |
| 847 | // InternalSolverLanguage.g:303:3: ( () otherlv_5= 'unknown' ) | 1121 | // InternalSolverLanguage.g:392:5: ( (lv_error_2_0= 'error' ) ) |
| 848 | // InternalSolverLanguage.g:304:4: () otherlv_5= 'unknown' | 1122 | // InternalSolverLanguage.g:393:6: (lv_error_2_0= 'error' ) |
| 849 | { | 1123 | { |
| 850 | // InternalSolverLanguage.g:304:4: () | 1124 | // InternalSolverLanguage.g:393:6: (lv_error_2_0= 'error' ) |
| 851 | // InternalSolverLanguage.g:305:5: | 1125 | // InternalSolverLanguage.g:394:7: lv_error_2_0= 'error' |
| 852 | { | 1126 | { |
| 1127 | lv_error_2_0=(Token)match(input,19,FOLLOW_8); if (state.failed) return current; | ||
| 1128 | if ( state.backtracking==0 ) { | ||
| 853 | 1129 | ||
| 854 | current = forceCreateModelElement( | 1130 | newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); |
| 855 | grammarAccess.getTruthValueAccess().getUnknownAction_2_0(), | 1131 | |
| 856 | current); | 1132 | } |
| 857 | 1133 | if ( state.backtracking==0 ) { | |
| 858 | 1134 | ||
| 1135 | if (current==null) { | ||
| 1136 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 1137 | } | ||
| 1138 | setWithLastConsumed(current, "error", true, "error"); | ||
| 1139 | |||
| 859 | } | 1140 | } |
| 860 | 1141 | ||
| 861 | otherlv_5=(Token)match(input,15,FOLLOW_2); | 1142 | } |
| 862 | 1143 | ||
| 863 | newLeafNode(otherlv_5, grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); | ||
| 864 | |||
| 865 | 1144 | ||
| 866 | } | 1145 | } |
| 867 | 1146 | ||
| 1147 | // InternalSolverLanguage.g:406:5: ( (lv_functional_3_0= 'functional' ) )? | ||
| 1148 | int alt6=2; | ||
| 1149 | int LA6_0 = input.LA(1); | ||
| 868 | 1150 | ||
| 1151 | if ( (LA6_0==18) ) { | ||
| 1152 | alt6=1; | ||
| 869 | } | 1153 | } |
| 870 | break; | 1154 | switch (alt6) { |
| 871 | case 4 : | 1155 | case 1 : |
| 872 | // InternalSolverLanguage.g:317:3: ( () otherlv_7= 'error' ) | 1156 | // InternalSolverLanguage.g:407:6: (lv_functional_3_0= 'functional' ) |
| 873 | { | 1157 | { |
| 874 | // InternalSolverLanguage.g:317:3: ( () otherlv_7= 'error' ) | 1158 | // InternalSolverLanguage.g:407:6: (lv_functional_3_0= 'functional' ) |
| 875 | // InternalSolverLanguage.g:318:4: () otherlv_7= 'error' | 1159 | // InternalSolverLanguage.g:408:7: lv_functional_3_0= 'functional' |
| 876 | { | 1160 | { |
| 877 | // InternalSolverLanguage.g:318:4: () | 1161 | lv_functional_3_0=(Token)match(input,18,FOLLOW_7); if (state.failed) return current; |
| 878 | // InternalSolverLanguage.g:319:5: | 1162 | if ( state.backtracking==0 ) { |
| 879 | { | ||
| 880 | 1163 | ||
| 881 | current = forceCreateModelElement( | 1164 | newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); |
| 882 | grammarAccess.getTruthValueAccess().getErrorAction_3_0(), | 1165 | |
| 883 | current); | 1166 | } |
| 884 | 1167 | if ( state.backtracking==0 ) { | |
| 885 | 1168 | ||
| 886 | } | 1169 | if (current==null) { |
| 1170 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 1171 | } | ||
| 1172 | setWithLastConsumed(current, "functional", true, "functional"); | ||
| 1173 | |||
| 1174 | } | ||
| 1175 | |||
| 1176 | } | ||
| 887 | 1177 | ||
| 888 | otherlv_7=(Token)match(input,16,FOLLOW_2); | ||
| 889 | 1178 | ||
| 890 | newLeafNode(otherlv_7, grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); | 1179 | } |
| 891 | 1180 | break; | |
| 1181 | |||
| 1182 | } | ||
| 1183 | |||
| 892 | 1184 | ||
| 893 | } | 1185 | } |
| 894 | 1186 | ||
| @@ -898,12 +1190,93 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 898 | 1190 | ||
| 899 | } | 1191 | } |
| 900 | 1192 | ||
| 1193 | // InternalSolverLanguage.g:422:3: ( (lv_head_4_0= ruleCall ) ) | ||
| 1194 | // InternalSolverLanguage.g:423:4: (lv_head_4_0= ruleCall ) | ||
| 1195 | { | ||
| 1196 | // InternalSolverLanguage.g:423:4: (lv_head_4_0= ruleCall ) | ||
| 1197 | // InternalSolverLanguage.g:424:5: lv_head_4_0= ruleCall | ||
| 1198 | { | ||
| 1199 | if ( state.backtracking==0 ) { | ||
| 1200 | |||
| 1201 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
| 1202 | |||
| 1203 | } | ||
| 1204 | pushFollow(FOLLOW_9); | ||
| 1205 | lv_head_4_0=ruleCall(); | ||
| 1206 | |||
| 1207 | state._fsp--; | ||
| 1208 | if (state.failed) return current; | ||
| 1209 | if ( state.backtracking==0 ) { | ||
| 1210 | |||
| 1211 | if (current==null) { | ||
| 1212 | current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
| 1213 | } | ||
| 1214 | set( | ||
| 1215 | current, | ||
| 1216 | "head", | ||
| 1217 | lv_head_4_0, | ||
| 1218 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 1219 | afterParserOrEnumRuleCall(); | ||
| 1220 | |||
| 1221 | } | ||
| 1222 | |||
| 1223 | } | ||
| 1224 | |||
| 1225 | |||
| 1226 | } | ||
| 1227 | |||
| 1228 | otherlv_5=(Token)match(input,16,FOLLOW_6); if (state.failed) return current; | ||
| 1229 | if ( state.backtracking==0 ) { | ||
| 1230 | |||
| 1231 | newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); | ||
| 1232 | |||
| 1233 | } | ||
| 1234 | // InternalSolverLanguage.g:445:3: ( (lv_body_6_0= ruleExpression ) ) | ||
| 1235 | // InternalSolverLanguage.g:446:4: (lv_body_6_0= ruleExpression ) | ||
| 1236 | { | ||
| 1237 | // InternalSolverLanguage.g:446:4: (lv_body_6_0= ruleExpression ) | ||
| 1238 | // InternalSolverLanguage.g:447:5: lv_body_6_0= ruleExpression | ||
| 1239 | { | ||
| 1240 | if ( state.backtracking==0 ) { | ||
| 1241 | |||
| 1242 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
| 1243 | |||
| 1244 | } | ||
| 1245 | pushFollow(FOLLOW_2); | ||
| 1246 | lv_body_6_0=ruleExpression(); | ||
| 1247 | |||
| 1248 | state._fsp--; | ||
| 1249 | if (state.failed) return current; | ||
| 1250 | if ( state.backtracking==0 ) { | ||
| 1251 | |||
| 1252 | if (current==null) { | ||
| 1253 | current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
| 1254 | } | ||
| 1255 | set( | ||
| 1256 | current, | ||
| 1257 | "body", | ||
| 1258 | lv_body_6_0, | ||
| 1259 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1260 | afterParserOrEnumRuleCall(); | ||
| 1261 | |||
| 1262 | } | ||
| 1263 | |||
| 1264 | } | ||
| 1265 | |||
| 1266 | |||
| 1267 | } | ||
| 1268 | |||
| 901 | 1269 | ||
| 902 | } | 1270 | } |
| 903 | 1271 | ||
| 904 | 1272 | ||
| 905 | leaveRule(); | 1273 | } |
| 1274 | |||
| 1275 | if ( state.backtracking==0 ) { | ||
| 906 | 1276 | ||
| 1277 | leaveRule(); | ||
| 1278 | |||
| 1279 | } | ||
| 907 | } | 1280 | } |
| 908 | 1281 | ||
| 909 | catch (RecognitionException re) { | 1282 | catch (RecognitionException re) { |
| @@ -914,29 +1287,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 914 | } | 1287 | } |
| 915 | return current; | 1288 | return current; |
| 916 | } | 1289 | } |
| 917 | // $ANTLR end "ruleTruthValue" | 1290 | // $ANTLR end "rulePredicateDefinition" |
| 918 | 1291 | ||
| 919 | 1292 | ||
| 920 | // $ANTLR start "entryRuleInterpretation" | 1293 | // $ANTLR start "entryRuleUnnamedErrorPrediateDefinition" |
| 921 | // InternalSolverLanguage.g:334:1: entryRuleInterpretation returns [EObject current=null] : iv_ruleInterpretation= ruleInterpretation EOF ; | 1294 | // InternalSolverLanguage.g:468:1: entryRuleUnnamedErrorPrediateDefinition returns [EObject current=null] : iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF ; |
| 922 | public final EObject entryRuleInterpretation() throws RecognitionException { | 1295 | public final EObject entryRuleUnnamedErrorPrediateDefinition() throws RecognitionException { |
| 923 | EObject current = null; | 1296 | EObject current = null; |
| 924 | 1297 | ||
| 925 | EObject iv_ruleInterpretation = null; | 1298 | EObject iv_ruleUnnamedErrorPrediateDefinition = null; |
| 926 | 1299 | ||
| 927 | 1300 | ||
| 928 | try { | 1301 | try { |
| 929 | // InternalSolverLanguage.g:334:55: (iv_ruleInterpretation= ruleInterpretation EOF ) | 1302 | // InternalSolverLanguage.g:468:71: (iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF ) |
| 930 | // InternalSolverLanguage.g:335:2: iv_ruleInterpretation= ruleInterpretation EOF | 1303 | // InternalSolverLanguage.g:469:2: iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF |
| 931 | { | 1304 | { |
| 932 | newCompositeNode(grammarAccess.getInterpretationRule()); | 1305 | if ( state.backtracking==0 ) { |
| 1306 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | ||
| 1307 | } | ||
| 933 | pushFollow(FOLLOW_1); | 1308 | pushFollow(FOLLOW_1); |
| 934 | iv_ruleInterpretation=ruleInterpretation(); | 1309 | iv_ruleUnnamedErrorPrediateDefinition=ruleUnnamedErrorPrediateDefinition(); |
| 935 | 1310 | ||
| 936 | state._fsp--; | 1311 | state._fsp--; |
| 937 | 1312 | if (state.failed) return current; | |
| 938 | current =iv_ruleInterpretation; | 1313 | if ( state.backtracking==0 ) { |
| 939 | match(input,EOF,FOLLOW_2); | 1314 | current =iv_ruleUnnamedErrorPrediateDefinition; |
| 1315 | } | ||
| 1316 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 940 | 1317 | ||
| 941 | } | 1318 | } |
| 942 | 1319 | ||
| @@ -950,127 +1327,124 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 950 | } | 1327 | } |
| 951 | return current; | 1328 | return current; |
| 952 | } | 1329 | } |
| 953 | // $ANTLR end "entryRuleInterpretation" | 1330 | // $ANTLR end "entryRuleUnnamedErrorPrediateDefinition" |
| 954 | 1331 | ||
| 955 | 1332 | ||
| 956 | // $ANTLR start "ruleInterpretation" | 1333 | // $ANTLR start "ruleUnnamedErrorPrediateDefinition" |
| 957 | // InternalSolverLanguage.g:341:1: ruleInterpretation returns [EObject current=null] : (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) ; | 1334 | // InternalSolverLanguage.g:475:1: ruleUnnamedErrorPrediateDefinition returns [EObject current=null] : (otherlv_0= 'error' ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ':-' ( (lv_body_3_0= ruleExpression ) ) ) ; |
| 958 | public final EObject ruleInterpretation() throws RecognitionException { | 1335 | public final EObject ruleUnnamedErrorPrediateDefinition() throws RecognitionException { |
| 959 | EObject current = null; | 1336 | EObject current = null; |
| 960 | 1337 | ||
| 961 | EObject this_BasicInterpretation_0 = null; | 1338 | Token otherlv_0=null; |
| 962 | 1339 | Token otherlv_2=null; | |
| 963 | EObject this_DefaultInterpretation_1 = null; | 1340 | EObject lv_argumentList_1_0 = null; |
| 964 | 1341 | ||
| 965 | EObject this_CDInterpretation_2 = null; | 1342 | EObject lv_body_3_0 = null; |
| 966 | 1343 | ||
| 967 | 1344 | ||
| 968 | 1345 | ||
| 969 | enterRule(); | 1346 | enterRule(); |
| 970 | 1347 | ||
| 971 | try { | 1348 | try { |
| 972 | // InternalSolverLanguage.g:347:2: ( (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) ) | 1349 | // InternalSolverLanguage.g:481:2: ( (otherlv_0= 'error' ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ':-' ( (lv_body_3_0= ruleExpression ) ) ) ) |
| 973 | // InternalSolverLanguage.g:348:2: (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) | 1350 | // InternalSolverLanguage.g:482:2: (otherlv_0= 'error' ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ':-' ( (lv_body_3_0= ruleExpression ) ) ) |
| 974 | { | 1351 | { |
| 975 | // InternalSolverLanguage.g:348:2: (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) | 1352 | // InternalSolverLanguage.g:482:2: (otherlv_0= 'error' ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ':-' ( (lv_body_3_0= ruleExpression ) ) ) |
| 976 | int alt7=3; | 1353 | // InternalSolverLanguage.g:483:3: otherlv_0= 'error' ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ':-' ( (lv_body_3_0= ruleExpression ) ) |
| 977 | switch ( input.LA(1) ) { | 1354 | { |
| 978 | case RULE_ID: | 1355 | otherlv_0=(Token)match(input,19,FOLLOW_10); if (state.failed) return current; |
| 979 | case 21: | 1356 | if ( state.backtracking==0 ) { |
| 980 | case 22: | ||
| 981 | case 23: | ||
| 982 | case 24: | ||
| 983 | case 25: | ||
| 984 | case 26: | ||
| 985 | { | ||
| 986 | alt7=1; | ||
| 987 | } | ||
| 988 | break; | ||
| 989 | case 32: | ||
| 990 | { | ||
| 991 | alt7=2; | ||
| 992 | } | ||
| 993 | break; | ||
| 994 | case 33: | ||
| 995 | case 34: | ||
| 996 | case 38: | ||
| 997 | case 39: | ||
| 998 | case 40: | ||
| 999 | { | ||
| 1000 | alt7=3; | ||
| 1001 | } | ||
| 1002 | break; | ||
| 1003 | default: | ||
| 1004 | NoViableAltException nvae = | ||
| 1005 | new NoViableAltException("", 7, 0, input); | ||
| 1006 | 1357 | ||
| 1007 | throw nvae; | 1358 | newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); |
| 1359 | |||
| 1008 | } | 1360 | } |
| 1361 | // InternalSolverLanguage.g:487:3: ( (lv_argumentList_1_0= ruleArgumentList ) ) | ||
| 1362 | // InternalSolverLanguage.g:488:4: (lv_argumentList_1_0= ruleArgumentList ) | ||
| 1363 | { | ||
| 1364 | // InternalSolverLanguage.g:488:4: (lv_argumentList_1_0= ruleArgumentList ) | ||
| 1365 | // InternalSolverLanguage.g:489:5: lv_argumentList_1_0= ruleArgumentList | ||
| 1366 | { | ||
| 1367 | if ( state.backtracking==0 ) { | ||
| 1009 | 1368 | ||
| 1010 | switch (alt7) { | 1369 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); |
| 1011 | case 1 : | 1370 | |
| 1012 | // InternalSolverLanguage.g:349:3: this_BasicInterpretation_0= ruleBasicInterpretation | 1371 | } |
| 1013 | { | 1372 | pushFollow(FOLLOW_9); |
| 1014 | 1373 | lv_argumentList_1_0=ruleArgumentList(); | |
| 1015 | newCompositeNode(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); | ||
| 1016 | |||
| 1017 | pushFollow(FOLLOW_2); | ||
| 1018 | this_BasicInterpretation_0=ruleBasicInterpretation(); | ||
| 1019 | 1374 | ||
| 1020 | state._fsp--; | 1375 | state._fsp--; |
| 1376 | if (state.failed) return current; | ||
| 1377 | if ( state.backtracking==0 ) { | ||
| 1021 | 1378 | ||
| 1379 | if (current==null) { | ||
| 1380 | current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | ||
| 1381 | } | ||
| 1382 | set( | ||
| 1383 | current, | ||
| 1384 | "argumentList", | ||
| 1385 | lv_argumentList_1_0, | ||
| 1386 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
| 1387 | afterParserOrEnumRuleCall(); | ||
| 1388 | |||
| 1389 | } | ||
| 1022 | 1390 | ||
| 1023 | current = this_BasicInterpretation_0; | 1391 | } |
| 1024 | afterParserOrEnumRuleCall(); | ||
| 1025 | |||
| 1026 | 1392 | ||
| 1027 | } | ||
| 1028 | break; | ||
| 1029 | case 2 : | ||
| 1030 | // InternalSolverLanguage.g:358:3: this_DefaultInterpretation_1= ruleDefaultInterpretation | ||
| 1031 | { | ||
| 1032 | 1393 | ||
| 1033 | newCompositeNode(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); | 1394 | } |
| 1034 | |||
| 1035 | pushFollow(FOLLOW_2); | ||
| 1036 | this_DefaultInterpretation_1=ruleDefaultInterpretation(); | ||
| 1037 | 1395 | ||
| 1038 | state._fsp--; | 1396 | otherlv_2=(Token)match(input,16,FOLLOW_6); if (state.failed) return current; |
| 1397 | if ( state.backtracking==0 ) { | ||
| 1039 | 1398 | ||
| 1399 | newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); | ||
| 1400 | |||
| 1401 | } | ||
| 1402 | // InternalSolverLanguage.g:510:3: ( (lv_body_3_0= ruleExpression ) ) | ||
| 1403 | // InternalSolverLanguage.g:511:4: (lv_body_3_0= ruleExpression ) | ||
| 1404 | { | ||
| 1405 | // InternalSolverLanguage.g:511:4: (lv_body_3_0= ruleExpression ) | ||
| 1406 | // InternalSolverLanguage.g:512:5: lv_body_3_0= ruleExpression | ||
| 1407 | { | ||
| 1408 | if ( state.backtracking==0 ) { | ||
| 1040 | 1409 | ||
| 1041 | current = this_DefaultInterpretation_1; | 1410 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
| 1042 | afterParserOrEnumRuleCall(); | 1411 | |
| 1043 | 1412 | } | |
| 1413 | pushFollow(FOLLOW_2); | ||
| 1414 | lv_body_3_0=ruleExpression(); | ||
| 1044 | 1415 | ||
| 1045 | } | 1416 | state._fsp--; |
| 1046 | break; | 1417 | if (state.failed) return current; |
| 1047 | case 3 : | 1418 | if ( state.backtracking==0 ) { |
| 1048 | // InternalSolverLanguage.g:367:3: this_CDInterpretation_2= ruleCDInterpretation | ||
| 1049 | { | ||
| 1050 | 1419 | ||
| 1051 | newCompositeNode(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); | 1420 | if (current==null) { |
| 1052 | 1421 | current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | |
| 1053 | pushFollow(FOLLOW_2); | 1422 | } |
| 1054 | this_CDInterpretation_2=ruleCDInterpretation(); | 1423 | set( |
| 1424 | current, | ||
| 1425 | "body", | ||
| 1426 | lv_body_3_0, | ||
| 1427 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1428 | afterParserOrEnumRuleCall(); | ||
| 1429 | |||
| 1430 | } | ||
| 1055 | 1431 | ||
| 1056 | state._fsp--; | 1432 | } |
| 1057 | 1433 | ||
| 1058 | 1434 | ||
| 1059 | current = this_CDInterpretation_2; | 1435 | } |
| 1060 | afterParserOrEnumRuleCall(); | ||
| 1061 | |||
| 1062 | 1436 | ||
| 1063 | } | ||
| 1064 | break; | ||
| 1065 | 1437 | ||
| 1066 | } | 1438 | } |
| 1067 | 1439 | ||
| 1068 | 1440 | ||
| 1069 | } | 1441 | } |
| 1070 | 1442 | ||
| 1443 | if ( state.backtracking==0 ) { | ||
| 1071 | 1444 | ||
| 1072 | leaveRule(); | 1445 | leaveRule(); |
| 1073 | 1446 | ||
| 1447 | } | ||
| 1074 | } | 1448 | } |
| 1075 | 1449 | ||
| 1076 | catch (RecognitionException re) { | 1450 | catch (RecognitionException re) { |
| @@ -1081,29 +1455,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1081 | } | 1455 | } |
| 1082 | return current; | 1456 | return current; |
| 1083 | } | 1457 | } |
| 1084 | // $ANTLR end "ruleInterpretation" | 1458 | // $ANTLR end "ruleUnnamedErrorPrediateDefinition" |
| 1085 | 1459 | ||
| 1086 | 1460 | ||
| 1087 | // $ANTLR start "entryRuleBasicInterpretation" | 1461 | // $ANTLR start "entryRuleDefaultDefinition" |
| 1088 | // InternalSolverLanguage.g:379:1: entryRuleBasicInterpretation returns [EObject current=null] : iv_ruleBasicInterpretation= ruleBasicInterpretation EOF ; | 1462 | // InternalSolverLanguage.g:533:1: entryRuleDefaultDefinition returns [EObject current=null] : iv_ruleDefaultDefinition= ruleDefaultDefinition EOF ; |
| 1089 | public final EObject entryRuleBasicInterpretation() throws RecognitionException { | 1463 | public final EObject entryRuleDefaultDefinition() throws RecognitionException { |
| 1090 | EObject current = null; | 1464 | EObject current = null; |
| 1091 | 1465 | ||
| 1092 | EObject iv_ruleBasicInterpretation = null; | 1466 | EObject iv_ruleDefaultDefinition = null; |
| 1093 | 1467 | ||
| 1094 | 1468 | ||
| 1095 | try { | 1469 | try { |
| 1096 | // InternalSolverLanguage.g:379:60: (iv_ruleBasicInterpretation= ruleBasicInterpretation EOF ) | 1470 | // InternalSolverLanguage.g:533:58: (iv_ruleDefaultDefinition= ruleDefaultDefinition EOF ) |
| 1097 | // InternalSolverLanguage.g:380:2: iv_ruleBasicInterpretation= ruleBasicInterpretation EOF | 1471 | // InternalSolverLanguage.g:534:2: iv_ruleDefaultDefinition= ruleDefaultDefinition EOF |
| 1098 | { | 1472 | { |
| 1099 | newCompositeNode(grammarAccess.getBasicInterpretationRule()); | 1473 | if ( state.backtracking==0 ) { |
| 1474 | newCompositeNode(grammarAccess.getDefaultDefinitionRule()); | ||
| 1475 | } | ||
| 1100 | pushFollow(FOLLOW_1); | 1476 | pushFollow(FOLLOW_1); |
| 1101 | iv_ruleBasicInterpretation=ruleBasicInterpretation(); | 1477 | iv_ruleDefaultDefinition=ruleDefaultDefinition(); |
| 1102 | 1478 | ||
| 1103 | state._fsp--; | 1479 | state._fsp--; |
| 1104 | 1480 | if (state.failed) return current; | |
| 1105 | current =iv_ruleBasicInterpretation; | 1481 | if ( state.backtracking==0 ) { |
| 1106 | match(input,EOF,FOLLOW_2); | 1482 | current =iv_ruleDefaultDefinition; |
| 1483 | } | ||
| 1484 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 1107 | 1485 | ||
| 1108 | } | 1486 | } |
| 1109 | 1487 | ||
| @@ -1117,244 +1495,255 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1117 | } | 1495 | } |
| 1118 | return current; | 1496 | return current; |
| 1119 | } | 1497 | } |
| 1120 | // $ANTLR end "entryRuleBasicInterpretation" | 1498 | // $ANTLR end "entryRuleDefaultDefinition" |
| 1121 | 1499 | ||
| 1122 | 1500 | ||
| 1123 | // $ANTLR start "ruleBasicInterpretation" | 1501 | // $ANTLR start "ruleDefaultDefinition" |
| 1124 | // InternalSolverLanguage.g:386:1: ruleBasicInterpretation returns [EObject current=null] : ( ( (lv_symbol_0_0= ruleSymbol ) ) (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? otherlv_6= ':' ( (lv_value_7_0= ruleTruthValue ) ) ) ; | 1502 | // InternalSolverLanguage.g:540:1: ruleDefaultDefinition returns [EObject current=null] : (otherlv_0= 'default' ( (lv_head_1_0= ruleCall ) ) otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) ) ; |
| 1125 | public final EObject ruleBasicInterpretation() throws RecognitionException { | 1503 | public final EObject ruleDefaultDefinition() throws RecognitionException { |
| 1126 | EObject current = null; | 1504 | EObject current = null; |
| 1127 | 1505 | ||
| 1128 | Token otherlv_1=null; | 1506 | Token otherlv_0=null; |
| 1129 | Token otherlv_3=null; | 1507 | Token otherlv_2=null; |
| 1130 | Token otherlv_5=null; | 1508 | EObject lv_head_1_0 = null; |
| 1131 | Token otherlv_6=null; | ||
| 1132 | EObject lv_symbol_0_0 = null; | ||
| 1133 | |||
| 1134 | EObject lv_objects_2_0 = null; | ||
| 1135 | |||
| 1136 | EObject lv_objects_4_0 = null; | ||
| 1137 | 1509 | ||
| 1138 | EObject lv_value_7_0 = null; | 1510 | EObject lv_range_3_0 = null; |
| 1139 | 1511 | ||
| 1140 | 1512 | ||
| 1141 | 1513 | ||
| 1142 | enterRule(); | 1514 | enterRule(); |
| 1143 | 1515 | ||
| 1144 | try { | 1516 | try { |
| 1145 | // InternalSolverLanguage.g:392:2: ( ( ( (lv_symbol_0_0= ruleSymbol ) ) (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? otherlv_6= ':' ( (lv_value_7_0= ruleTruthValue ) ) ) ) | 1517 | // InternalSolverLanguage.g:546:2: ( (otherlv_0= 'default' ( (lv_head_1_0= ruleCall ) ) otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) ) ) |
| 1146 | // InternalSolverLanguage.g:393:2: ( ( (lv_symbol_0_0= ruleSymbol ) ) (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? otherlv_6= ':' ( (lv_value_7_0= ruleTruthValue ) ) ) | 1518 | // InternalSolverLanguage.g:547:2: (otherlv_0= 'default' ( (lv_head_1_0= ruleCall ) ) otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) ) |
| 1147 | { | 1519 | { |
| 1148 | // InternalSolverLanguage.g:393:2: ( ( (lv_symbol_0_0= ruleSymbol ) ) (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? otherlv_6= ':' ( (lv_value_7_0= ruleTruthValue ) ) ) | 1520 | // InternalSolverLanguage.g:547:2: (otherlv_0= 'default' ( (lv_head_1_0= ruleCall ) ) otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) ) |
| 1149 | // InternalSolverLanguage.g:394:3: ( (lv_symbol_0_0= ruleSymbol ) ) (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? otherlv_6= ':' ( (lv_value_7_0= ruleTruthValue ) ) | 1521 | // InternalSolverLanguage.g:548:3: otherlv_0= 'default' ( (lv_head_1_0= ruleCall ) ) otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) |
| 1150 | { | 1522 | { |
| 1151 | // InternalSolverLanguage.g:394:3: ( (lv_symbol_0_0= ruleSymbol ) ) | 1523 | otherlv_0=(Token)match(input,20,FOLLOW_7); if (state.failed) return current; |
| 1152 | // InternalSolverLanguage.g:395:4: (lv_symbol_0_0= ruleSymbol ) | 1524 | if ( state.backtracking==0 ) { |
| 1525 | |||
| 1526 | newLeafNode(otherlv_0, grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); | ||
| 1527 | |||
| 1528 | } | ||
| 1529 | // InternalSolverLanguage.g:552:3: ( (lv_head_1_0= ruleCall ) ) | ||
| 1530 | // InternalSolverLanguage.g:553:4: (lv_head_1_0= ruleCall ) | ||
| 1153 | { | 1531 | { |
| 1154 | // InternalSolverLanguage.g:395:4: (lv_symbol_0_0= ruleSymbol ) | 1532 | // InternalSolverLanguage.g:553:4: (lv_head_1_0= ruleCall ) |
| 1155 | // InternalSolverLanguage.g:396:5: lv_symbol_0_0= ruleSymbol | 1533 | // InternalSolverLanguage.g:554:5: lv_head_1_0= ruleCall |
| 1156 | { | 1534 | { |
| 1535 | if ( state.backtracking==0 ) { | ||
| 1157 | 1536 | ||
| 1158 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); | 1537 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
| 1159 | 1538 | ||
| 1160 | pushFollow(FOLLOW_6); | 1539 | } |
| 1161 | lv_symbol_0_0=ruleSymbol(); | 1540 | pushFollow(FOLLOW_11); |
| 1541 | lv_head_1_0=ruleCall(); | ||
| 1162 | 1542 | ||
| 1163 | state._fsp--; | 1543 | state._fsp--; |
| 1544 | if (state.failed) return current; | ||
| 1545 | if ( state.backtracking==0 ) { | ||
| 1164 | 1546 | ||
| 1165 | 1547 | if (current==null) { | |
| 1166 | if (current==null) { | 1548 | current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); |
| 1167 | current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | 1549 | } |
| 1168 | } | 1550 | set( |
| 1169 | set( | 1551 | current, |
| 1170 | current, | 1552 | "head", |
| 1171 | "symbol", | 1553 | lv_head_1_0, |
| 1172 | lv_symbol_0_0, | 1554 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); |
| 1173 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | 1555 | afterParserOrEnumRuleCall(); |
| 1174 | afterParserOrEnumRuleCall(); | 1556 | |
| 1175 | 1557 | } | |
| 1176 | 1558 | ||
| 1177 | } | 1559 | } |
| 1178 | 1560 | ||
| 1179 | 1561 | ||
| 1180 | } | 1562 | } |
| 1181 | 1563 | ||
| 1182 | // InternalSolverLanguage.g:413:3: (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? | 1564 | otherlv_2=(Token)match(input,15,FOLLOW_6); if (state.failed) return current; |
| 1183 | int alt10=2; | 1565 | if ( state.backtracking==0 ) { |
| 1184 | int LA10_0 = input.LA(1); | ||
| 1185 | 1566 | ||
| 1186 | if ( (LA10_0==17) ) { | 1567 | newLeafNode(otherlv_2, grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); |
| 1187 | alt10=1; | 1568 | |
| 1188 | } | 1569 | } |
| 1189 | switch (alt10) { | 1570 | // InternalSolverLanguage.g:575:3: ( (lv_range_3_0= ruleExpression ) ) |
| 1190 | case 1 : | 1571 | // InternalSolverLanguage.g:576:4: (lv_range_3_0= ruleExpression ) |
| 1191 | // InternalSolverLanguage.g:414:4: otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' | 1572 | { |
| 1192 | { | 1573 | // InternalSolverLanguage.g:576:4: (lv_range_3_0= ruleExpression ) |
| 1193 | otherlv_1=(Token)match(input,17,FOLLOW_7); | 1574 | // InternalSolverLanguage.g:577:5: lv_range_3_0= ruleExpression |
| 1575 | { | ||
| 1576 | if ( state.backtracking==0 ) { | ||
| 1194 | 1577 | ||
| 1195 | newLeafNode(otherlv_1, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1_0()); | 1578 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); |
| 1196 | 1579 | ||
| 1197 | // InternalSolverLanguage.g:418:4: ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? | 1580 | } |
| 1198 | int alt9=2; | 1581 | pushFollow(FOLLOW_2); |
| 1199 | int LA9_0 = input.LA(1); | 1582 | lv_range_3_0=ruleExpression(); |
| 1200 | 1583 | ||
| 1201 | if ( ((LA9_0>=RULE_INT && LA9_0<=RULE_STRING)||LA9_0==11||(LA9_0>=13 && LA9_0<=14)||LA9_0==20||LA9_0==27||LA9_0==31) ) { | 1584 | state._fsp--; |
| 1202 | alt9=1; | 1585 | if (state.failed) return current; |
| 1203 | } | 1586 | if ( state.backtracking==0 ) { |
| 1204 | switch (alt9) { | ||
| 1205 | case 1 : | ||
| 1206 | // InternalSolverLanguage.g:419:5: ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* | ||
| 1207 | { | ||
| 1208 | // InternalSolverLanguage.g:419:5: ( (lv_objects_2_0= ruleComplexObject ) ) | ||
| 1209 | // InternalSolverLanguage.g:420:6: (lv_objects_2_0= ruleComplexObject ) | ||
| 1210 | { | ||
| 1211 | // InternalSolverLanguage.g:420:6: (lv_objects_2_0= ruleComplexObject ) | ||
| 1212 | // InternalSolverLanguage.g:421:7: lv_objects_2_0= ruleComplexObject | ||
| 1213 | { | ||
| 1214 | 1587 | ||
| 1215 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_0_0()); | 1588 | if (current==null) { |
| 1216 | 1589 | current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); | |
| 1217 | pushFollow(FOLLOW_8); | 1590 | } |
| 1218 | lv_objects_2_0=ruleComplexObject(); | 1591 | set( |
| 1592 | current, | ||
| 1593 | "range", | ||
| 1594 | lv_range_3_0, | ||
| 1595 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1596 | afterParserOrEnumRuleCall(); | ||
| 1597 | |||
| 1598 | } | ||
| 1219 | 1599 | ||
| 1220 | state._fsp--; | 1600 | } |
| 1221 | 1601 | ||
| 1222 | 1602 | ||
| 1223 | if (current==null) { | 1603 | } |
| 1224 | current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 1225 | } | ||
| 1226 | add( | ||
| 1227 | current, | ||
| 1228 | "objects", | ||
| 1229 | lv_objects_2_0, | ||
| 1230 | "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); | ||
| 1231 | afterParserOrEnumRuleCall(); | ||
| 1232 | |||
| 1233 | 1604 | ||
| 1234 | } | ||
| 1235 | 1605 | ||
| 1606 | } | ||
| 1236 | 1607 | ||
| 1237 | } | ||
| 1238 | 1608 | ||
| 1239 | // InternalSolverLanguage.g:438:5: (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* | 1609 | } |
| 1240 | loop8: | ||
| 1241 | do { | ||
| 1242 | int alt8=2; | ||
| 1243 | int LA8_0 = input.LA(1); | ||
| 1244 | 1610 | ||
| 1245 | if ( (LA8_0==18) ) { | 1611 | if ( state.backtracking==0 ) { |
| 1246 | alt8=1; | ||
| 1247 | } | ||
| 1248 | 1612 | ||
| 1613 | leaveRule(); | ||
| 1249 | 1614 | ||
| 1250 | switch (alt8) { | 1615 | } |
| 1251 | case 1 : | 1616 | } |
| 1252 | // InternalSolverLanguage.g:439:6: otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) | ||
| 1253 | { | ||
| 1254 | otherlv_3=(Token)match(input,18,FOLLOW_9); | ||
| 1255 | 1617 | ||
| 1256 | newLeafNode(otherlv_3, grammarAccess.getBasicInterpretationAccess().getCommaKeyword_1_1_1_0()); | 1618 | catch (RecognitionException re) { |
| 1257 | 1619 | recover(input,re); | |
| 1258 | // InternalSolverLanguage.g:443:6: ( (lv_objects_4_0= ruleComplexObject ) ) | 1620 | appendSkippedTokens(); |
| 1259 | // InternalSolverLanguage.g:444:7: (lv_objects_4_0= ruleComplexObject ) | 1621 | } |
| 1260 | { | 1622 | finally { |
| 1261 | // InternalSolverLanguage.g:444:7: (lv_objects_4_0= ruleComplexObject ) | 1623 | } |
| 1262 | // InternalSolverLanguage.g:445:8: lv_objects_4_0= ruleComplexObject | 1624 | return current; |
| 1263 | { | 1625 | } |
| 1626 | // $ANTLR end "ruleDefaultDefinition" | ||
| 1264 | 1627 | ||
| 1265 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_1_1_0()); | ||
| 1266 | |||
| 1267 | pushFollow(FOLLOW_8); | ||
| 1268 | lv_objects_4_0=ruleComplexObject(); | ||
| 1269 | 1628 | ||
| 1270 | state._fsp--; | 1629 | // $ANTLR start "entryRuleExternPredicateDefinition" |
| 1630 | // InternalSolverLanguage.g:598:1: entryRuleExternPredicateDefinition returns [EObject current=null] : iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF ; | ||
| 1631 | public final EObject entryRuleExternPredicateDefinition() throws RecognitionException { | ||
| 1632 | EObject current = null; | ||
| 1271 | 1633 | ||
| 1634 | EObject iv_ruleExternPredicateDefinition = null; | ||
| 1272 | 1635 | ||
| 1273 | if (current==null) { | ||
| 1274 | current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 1275 | } | ||
| 1276 | add( | ||
| 1277 | current, | ||
| 1278 | "objects", | ||
| 1279 | lv_objects_4_0, | ||
| 1280 | "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); | ||
| 1281 | afterParserOrEnumRuleCall(); | ||
| 1282 | |||
| 1283 | 1636 | ||
| 1284 | } | 1637 | try { |
| 1638 | // InternalSolverLanguage.g:598:66: (iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF ) | ||
| 1639 | // InternalSolverLanguage.g:599:2: iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF | ||
| 1640 | { | ||
| 1641 | if ( state.backtracking==0 ) { | ||
| 1642 | newCompositeNode(grammarAccess.getExternPredicateDefinitionRule()); | ||
| 1643 | } | ||
| 1644 | pushFollow(FOLLOW_1); | ||
| 1645 | iv_ruleExternPredicateDefinition=ruleExternPredicateDefinition(); | ||
| 1285 | 1646 | ||
| 1647 | state._fsp--; | ||
| 1648 | if (state.failed) return current; | ||
| 1649 | if ( state.backtracking==0 ) { | ||
| 1650 | current =iv_ruleExternPredicateDefinition; | ||
| 1651 | } | ||
| 1652 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 1286 | 1653 | ||
| 1287 | } | 1654 | } |
| 1288 | 1655 | ||
| 1656 | } | ||
| 1289 | 1657 | ||
| 1290 | } | 1658 | catch (RecognitionException re) { |
| 1291 | break; | 1659 | recover(input,re); |
| 1660 | appendSkippedTokens(); | ||
| 1661 | } | ||
| 1662 | finally { | ||
| 1663 | } | ||
| 1664 | return current; | ||
| 1665 | } | ||
| 1666 | // $ANTLR end "entryRuleExternPredicateDefinition" | ||
| 1292 | 1667 | ||
| 1293 | default : | ||
| 1294 | break loop8; | ||
| 1295 | } | ||
| 1296 | } while (true); | ||
| 1297 | 1668 | ||
| 1669 | // $ANTLR start "ruleExternPredicateDefinition" | ||
| 1670 | // InternalSolverLanguage.g:605:1: ruleExternPredicateDefinition returns [EObject current=null] : (otherlv_0= 'extern' ( (lv_head_1_0= ruleCall ) ) otherlv_2= '.' ) ; | ||
| 1671 | public final EObject ruleExternPredicateDefinition() throws RecognitionException { | ||
| 1672 | EObject current = null; | ||
| 1298 | 1673 | ||
| 1299 | } | 1674 | Token otherlv_0=null; |
| 1300 | break; | 1675 | Token otherlv_2=null; |
| 1676 | EObject lv_head_1_0 = null; | ||
| 1301 | 1677 | ||
| 1302 | } | ||
| 1303 | 1678 | ||
| 1304 | otherlv_5=(Token)match(input,19,FOLLOW_10); | ||
| 1305 | 1679 | ||
| 1306 | newLeafNode(otherlv_5, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_1_2()); | 1680 | enterRule(); |
| 1307 | |||
| 1308 | 1681 | ||
| 1309 | } | 1682 | try { |
| 1310 | break; | 1683 | // InternalSolverLanguage.g:611:2: ( (otherlv_0= 'extern' ( (lv_head_1_0= ruleCall ) ) otherlv_2= '.' ) ) |
| 1684 | // InternalSolverLanguage.g:612:2: (otherlv_0= 'extern' ( (lv_head_1_0= ruleCall ) ) otherlv_2= '.' ) | ||
| 1685 | { | ||
| 1686 | // InternalSolverLanguage.g:612:2: (otherlv_0= 'extern' ( (lv_head_1_0= ruleCall ) ) otherlv_2= '.' ) | ||
| 1687 | // InternalSolverLanguage.g:613:3: otherlv_0= 'extern' ( (lv_head_1_0= ruleCall ) ) otherlv_2= '.' | ||
| 1688 | { | ||
| 1689 | otherlv_0=(Token)match(input,21,FOLLOW_7); if (state.failed) return current; | ||
| 1690 | if ( state.backtracking==0 ) { | ||
| 1311 | 1691 | ||
| 1692 | newLeafNode(otherlv_0, grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); | ||
| 1693 | |||
| 1312 | } | 1694 | } |
| 1313 | 1695 | // InternalSolverLanguage.g:617:3: ( (lv_head_1_0= ruleCall ) ) | |
| 1314 | otherlv_6=(Token)match(input,20,FOLLOW_11); | 1696 | // InternalSolverLanguage.g:618:4: (lv_head_1_0= ruleCall ) |
| 1315 | |||
| 1316 | newLeafNode(otherlv_6, grammarAccess.getBasicInterpretationAccess().getColonKeyword_2()); | ||
| 1317 | |||
| 1318 | // InternalSolverLanguage.g:473:3: ( (lv_value_7_0= ruleTruthValue ) ) | ||
| 1319 | // InternalSolverLanguage.g:474:4: (lv_value_7_0= ruleTruthValue ) | ||
| 1320 | { | 1697 | { |
| 1321 | // InternalSolverLanguage.g:474:4: (lv_value_7_0= ruleTruthValue ) | 1698 | // InternalSolverLanguage.g:618:4: (lv_head_1_0= ruleCall ) |
| 1322 | // InternalSolverLanguage.g:475:5: lv_value_7_0= ruleTruthValue | 1699 | // InternalSolverLanguage.g:619:5: lv_head_1_0= ruleCall |
| 1323 | { | 1700 | { |
| 1701 | if ( state.backtracking==0 ) { | ||
| 1324 | 1702 | ||
| 1325 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_3_0()); | 1703 | newCompositeNode(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
| 1326 | 1704 | ||
| 1327 | pushFollow(FOLLOW_2); | 1705 | } |
| 1328 | lv_value_7_0=ruleTruthValue(); | 1706 | pushFollow(FOLLOW_12); |
| 1707 | lv_head_1_0=ruleCall(); | ||
| 1329 | 1708 | ||
| 1330 | state._fsp--; | 1709 | state._fsp--; |
| 1710 | if (state.failed) return current; | ||
| 1711 | if ( state.backtracking==0 ) { | ||
| 1331 | 1712 | ||
| 1332 | 1713 | if (current==null) { | |
| 1333 | if (current==null) { | 1714 | current = createModelElementForParent(grammarAccess.getExternPredicateDefinitionRule()); |
| 1334 | current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | 1715 | } |
| 1335 | } | 1716 | set( |
| 1336 | set( | 1717 | current, |
| 1337 | current, | 1718 | "head", |
| 1338 | "value", | 1719 | lv_head_1_0, |
| 1339 | lv_value_7_0, | 1720 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); |
| 1340 | "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue"); | 1721 | afterParserOrEnumRuleCall(); |
| 1341 | afterParserOrEnumRuleCall(); | 1722 | |
| 1342 | 1723 | } | |
| 1343 | 1724 | ||
| 1344 | } | 1725 | } |
| 1345 | 1726 | ||
| 1346 | 1727 | ||
| 1347 | } | 1728 | } |
| 1348 | 1729 | ||
| 1730 | otherlv_2=(Token)match(input,22,FOLLOW_2); if (state.failed) return current; | ||
| 1731 | if ( state.backtracking==0 ) { | ||
| 1732 | |||
| 1733 | newLeafNode(otherlv_2, grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2()); | ||
| 1734 | |||
| 1735 | } | ||
| 1349 | 1736 | ||
| 1350 | } | 1737 | } |
| 1351 | 1738 | ||
| 1352 | 1739 | ||
| 1353 | } | 1740 | } |
| 1354 | 1741 | ||
| 1742 | if ( state.backtracking==0 ) { | ||
| 1355 | 1743 | ||
| 1356 | leaveRule(); | 1744 | leaveRule(); |
| 1357 | 1745 | ||
| 1746 | } | ||
| 1358 | } | 1747 | } |
| 1359 | 1748 | ||
| 1360 | catch (RecognitionException re) { | 1749 | catch (RecognitionException re) { |
| @@ -1365,29 +1754,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1365 | } | 1754 | } |
| 1366 | return current; | 1755 | return current; |
| 1367 | } | 1756 | } |
| 1368 | // $ANTLR end "ruleBasicInterpretation" | 1757 | // $ANTLR end "ruleExternPredicateDefinition" |
| 1369 | 1758 | ||
| 1370 | 1759 | ||
| 1371 | // $ANTLR start "entryRuleSymbol" | 1760 | // $ANTLR start "entryRuleMetricDefinition" |
| 1372 | // InternalSolverLanguage.g:496:1: entryRuleSymbol returns [EObject current=null] : iv_ruleSymbol= ruleSymbol EOF ; | 1761 | // InternalSolverLanguage.g:644:1: entryRuleMetricDefinition returns [EObject current=null] : iv_ruleMetricDefinition= ruleMetricDefinition EOF ; |
| 1373 | public final EObject entryRuleSymbol() throws RecognitionException { | 1762 | public final EObject entryRuleMetricDefinition() throws RecognitionException { |
| 1374 | EObject current = null; | 1763 | EObject current = null; |
| 1375 | 1764 | ||
| 1376 | EObject iv_ruleSymbol = null; | 1765 | EObject iv_ruleMetricDefinition = null; |
| 1377 | 1766 | ||
| 1378 | 1767 | ||
| 1379 | try { | 1768 | try { |
| 1380 | // InternalSolverLanguage.g:496:47: (iv_ruleSymbol= ruleSymbol EOF ) | 1769 | // InternalSolverLanguage.g:644:57: (iv_ruleMetricDefinition= ruleMetricDefinition EOF ) |
| 1381 | // InternalSolverLanguage.g:497:2: iv_ruleSymbol= ruleSymbol EOF | 1770 | // InternalSolverLanguage.g:645:2: iv_ruleMetricDefinition= ruleMetricDefinition EOF |
| 1382 | { | 1771 | { |
| 1383 | newCompositeNode(grammarAccess.getSymbolRule()); | 1772 | if ( state.backtracking==0 ) { |
| 1773 | newCompositeNode(grammarAccess.getMetricDefinitionRule()); | ||
| 1774 | } | ||
| 1384 | pushFollow(FOLLOW_1); | 1775 | pushFollow(FOLLOW_1); |
| 1385 | iv_ruleSymbol=ruleSymbol(); | 1776 | iv_ruleMetricDefinition=ruleMetricDefinition(); |
| 1386 | 1777 | ||
| 1387 | state._fsp--; | 1778 | state._fsp--; |
| 1388 | 1779 | if (state.failed) return current; | |
| 1389 | current =iv_ruleSymbol; | 1780 | if ( state.backtracking==0 ) { |
| 1390 | match(input,EOF,FOLLOW_2); | 1781 | current =iv_ruleMetricDefinition; |
| 1782 | } | ||
| 1783 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 1391 | 1784 | ||
| 1392 | } | 1785 | } |
| 1393 | 1786 | ||
| @@ -1401,112 +1794,137 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1401 | } | 1794 | } |
| 1402 | return current; | 1795 | return current; |
| 1403 | } | 1796 | } |
| 1404 | // $ANTLR end "entryRuleSymbol" | 1797 | // $ANTLR end "entryRuleMetricDefinition" |
| 1405 | 1798 | ||
| 1406 | 1799 | ||
| 1407 | // $ANTLR start "ruleSymbol" | 1800 | // $ANTLR start "ruleMetricDefinition" |
| 1408 | // InternalSolverLanguage.g:503:1: ruleSymbol returns [EObject current=null] : (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) ; | 1801 | // InternalSolverLanguage.g:651:1: ruleMetricDefinition returns [EObject current=null] : ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= '=' ( (lv_body_3_0= ruleExpression ) ) ) ; |
| 1409 | public final EObject ruleSymbol() throws RecognitionException { | 1802 | public final EObject ruleMetricDefinition() throws RecognitionException { |
| 1410 | EObject current = null; | 1803 | EObject current = null; |
| 1411 | 1804 | ||
| 1412 | EObject this_ModelSymbol_0 = null; | 1805 | Token otherlv_2=null; |
| 1806 | Enumerator lv_type_0_0 = null; | ||
| 1413 | 1807 | ||
| 1414 | EObject this_PartialitySymbol_1 = null; | 1808 | EObject lv_head_1_0 = null; |
| 1415 | 1809 | ||
| 1416 | EObject this_DataSymbol_2 = null; | 1810 | EObject lv_body_3_0 = null; |
| 1417 | 1811 | ||
| 1418 | 1812 | ||
| 1419 | 1813 | ||
| 1420 | enterRule(); | 1814 | enterRule(); |
| 1421 | 1815 | ||
| 1422 | try { | 1816 | try { |
| 1423 | // InternalSolverLanguage.g:509:2: ( (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) ) | 1817 | // InternalSolverLanguage.g:657:2: ( ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= '=' ( (lv_body_3_0= ruleExpression ) ) ) ) |
| 1424 | // InternalSolverLanguage.g:510:2: (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) | 1818 | // InternalSolverLanguage.g:658:2: ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= '=' ( (lv_body_3_0= ruleExpression ) ) ) |
| 1425 | { | 1819 | { |
| 1426 | // InternalSolverLanguage.g:510:2: (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) | 1820 | // InternalSolverLanguage.g:658:2: ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= '=' ( (lv_body_3_0= ruleExpression ) ) ) |
| 1427 | int alt11=3; | 1821 | // InternalSolverLanguage.g:659:3: ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= '=' ( (lv_body_3_0= ruleExpression ) ) |
| 1428 | switch ( input.LA(1) ) { | 1822 | { |
| 1429 | case RULE_ID: | 1823 | // InternalSolverLanguage.g:659:3: ( (lv_type_0_0= ruleMetricType ) ) |
| 1430 | { | 1824 | // InternalSolverLanguage.g:660:4: (lv_type_0_0= ruleMetricType ) |
| 1431 | alt11=1; | 1825 | { |
| 1432 | } | 1826 | // InternalSolverLanguage.g:660:4: (lv_type_0_0= ruleMetricType ) |
| 1433 | break; | 1827 | // InternalSolverLanguage.g:661:5: lv_type_0_0= ruleMetricType |
| 1434 | case 21: | 1828 | { |
| 1435 | case 22: | 1829 | if ( state.backtracking==0 ) { |
| 1436 | { | ||
| 1437 | alt11=2; | ||
| 1438 | } | ||
| 1439 | break; | ||
| 1440 | case 23: | ||
| 1441 | case 24: | ||
| 1442 | case 25: | ||
| 1443 | case 26: | ||
| 1444 | { | ||
| 1445 | alt11=3; | ||
| 1446 | } | ||
| 1447 | break; | ||
| 1448 | default: | ||
| 1449 | NoViableAltException nvae = | ||
| 1450 | new NoViableAltException("", 11, 0, input); | ||
| 1451 | 1830 | ||
| 1452 | throw nvae; | 1831 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); |
| 1832 | |||
| 1453 | } | 1833 | } |
| 1834 | pushFollow(FOLLOW_6); | ||
| 1835 | lv_type_0_0=ruleMetricType(); | ||
| 1454 | 1836 | ||
| 1455 | switch (alt11) { | 1837 | state._fsp--; |
| 1456 | case 1 : | 1838 | if (state.failed) return current; |
| 1457 | // InternalSolverLanguage.g:511:3: this_ModelSymbol_0= ruleModelSymbol | 1839 | if ( state.backtracking==0 ) { |
| 1458 | { | ||
| 1459 | 1840 | ||
| 1460 | newCompositeNode(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); | 1841 | if (current==null) { |
| 1461 | 1842 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | |
| 1462 | pushFollow(FOLLOW_2); | 1843 | } |
| 1463 | this_ModelSymbol_0=ruleModelSymbol(); | 1844 | set( |
| 1845 | current, | ||
| 1846 | "type", | ||
| 1847 | lv_type_0_0, | ||
| 1848 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | ||
| 1849 | afterParserOrEnumRuleCall(); | ||
| 1850 | |||
| 1851 | } | ||
| 1464 | 1852 | ||
| 1465 | state._fsp--; | 1853 | } |
| 1466 | 1854 | ||
| 1467 | 1855 | ||
| 1468 | current = this_ModelSymbol_0; | 1856 | } |
| 1469 | afterParserOrEnumRuleCall(); | ||
| 1470 | |||
| 1471 | 1857 | ||
| 1472 | } | 1858 | // InternalSolverLanguage.g:678:3: ( (lv_head_1_0= ruleExpression ) ) |
| 1473 | break; | 1859 | // InternalSolverLanguage.g:679:4: (lv_head_1_0= ruleExpression ) |
| 1474 | case 2 : | 1860 | { |
| 1475 | // InternalSolverLanguage.g:520:3: this_PartialitySymbol_1= rulePartialitySymbol | 1861 | // InternalSolverLanguage.g:679:4: (lv_head_1_0= ruleExpression ) |
| 1476 | { | 1862 | // InternalSolverLanguage.g:680:5: lv_head_1_0= ruleExpression |
| 1863 | { | ||
| 1864 | if ( state.backtracking==0 ) { | ||
| 1477 | 1865 | ||
| 1478 | newCompositeNode(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); | 1866 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); |
| 1479 | 1867 | ||
| 1480 | pushFollow(FOLLOW_2); | 1868 | } |
| 1481 | this_PartialitySymbol_1=rulePartialitySymbol(); | 1869 | pushFollow(FOLLOW_13); |
| 1870 | lv_head_1_0=ruleExpression(); | ||
| 1482 | 1871 | ||
| 1483 | state._fsp--; | 1872 | state._fsp--; |
| 1873 | if (state.failed) return current; | ||
| 1874 | if ( state.backtracking==0 ) { | ||
| 1484 | 1875 | ||
| 1876 | if (current==null) { | ||
| 1877 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | ||
| 1878 | } | ||
| 1879 | set( | ||
| 1880 | current, | ||
| 1881 | "head", | ||
| 1882 | lv_head_1_0, | ||
| 1883 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1884 | afterParserOrEnumRuleCall(); | ||
| 1885 | |||
| 1886 | } | ||
| 1485 | 1887 | ||
| 1486 | current = this_PartialitySymbol_1; | 1888 | } |
| 1487 | afterParserOrEnumRuleCall(); | ||
| 1488 | |||
| 1489 | 1889 | ||
| 1490 | } | ||
| 1491 | break; | ||
| 1492 | case 3 : | ||
| 1493 | // InternalSolverLanguage.g:529:3: this_DataSymbol_2= ruleDataSymbol | ||
| 1494 | { | ||
| 1495 | 1890 | ||
| 1496 | newCompositeNode(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); | 1891 | } |
| 1497 | |||
| 1498 | pushFollow(FOLLOW_2); | ||
| 1499 | this_DataSymbol_2=ruleDataSymbol(); | ||
| 1500 | 1892 | ||
| 1501 | state._fsp--; | 1893 | otherlv_2=(Token)match(input,17,FOLLOW_6); if (state.failed) return current; |
| 1894 | if ( state.backtracking==0 ) { | ||
| 1895 | |||
| 1896 | newLeafNode(otherlv_2, grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); | ||
| 1897 | |||
| 1898 | } | ||
| 1899 | // InternalSolverLanguage.g:701:3: ( (lv_body_3_0= ruleExpression ) ) | ||
| 1900 | // InternalSolverLanguage.g:702:4: (lv_body_3_0= ruleExpression ) | ||
| 1901 | { | ||
| 1902 | // InternalSolverLanguage.g:702:4: (lv_body_3_0= ruleExpression ) | ||
| 1903 | // InternalSolverLanguage.g:703:5: lv_body_3_0= ruleExpression | ||
| 1904 | { | ||
| 1905 | if ( state.backtracking==0 ) { | ||
| 1502 | 1906 | ||
| 1907 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
| 1908 | |||
| 1909 | } | ||
| 1910 | pushFollow(FOLLOW_2); | ||
| 1911 | lv_body_3_0=ruleExpression(); | ||
| 1503 | 1912 | ||
| 1504 | current = this_DataSymbol_2; | 1913 | state._fsp--; |
| 1505 | afterParserOrEnumRuleCall(); | 1914 | if (state.failed) return current; |
| 1506 | 1915 | if ( state.backtracking==0 ) { | |
| 1507 | 1916 | ||
| 1508 | } | 1917 | if (current==null) { |
| 1509 | break; | 1918 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); |
| 1919 | } | ||
| 1920 | set( | ||
| 1921 | current, | ||
| 1922 | "body", | ||
| 1923 | lv_body_3_0, | ||
| 1924 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1925 | afterParserOrEnumRuleCall(); | ||
| 1926 | |||
| 1927 | } | ||
| 1510 | 1928 | ||
| 1511 | } | 1929 | } |
| 1512 | 1930 | ||
| @@ -1514,8 +1932,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1514 | } | 1932 | } |
| 1515 | 1933 | ||
| 1516 | 1934 | ||
| 1517 | leaveRule(); | 1935 | } |
| 1936 | |||
| 1937 | |||
| 1938 | } | ||
| 1518 | 1939 | ||
| 1940 | if ( state.backtracking==0 ) { | ||
| 1941 | |||
| 1942 | leaveRule(); | ||
| 1943 | |||
| 1944 | } | ||
| 1519 | } | 1945 | } |
| 1520 | 1946 | ||
| 1521 | catch (RecognitionException re) { | 1947 | catch (RecognitionException re) { |
| @@ -1526,29 +1952,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1526 | } | 1952 | } |
| 1527 | return current; | 1953 | return current; |
| 1528 | } | 1954 | } |
| 1529 | // $ANTLR end "ruleSymbol" | 1955 | // $ANTLR end "ruleMetricDefinition" |
| 1530 | 1956 | ||
| 1531 | 1957 | ||
| 1532 | // $ANTLR start "entryRuleModelSymbol" | 1958 | // $ANTLR start "entryRuleExternMetricDefinition" |
| 1533 | // InternalSolverLanguage.g:541:1: entryRuleModelSymbol returns [EObject current=null] : iv_ruleModelSymbol= ruleModelSymbol EOF ; | 1959 | // InternalSolverLanguage.g:724:1: entryRuleExternMetricDefinition returns [EObject current=null] : iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF ; |
| 1534 | public final EObject entryRuleModelSymbol() throws RecognitionException { | 1960 | public final EObject entryRuleExternMetricDefinition() throws RecognitionException { |
| 1535 | EObject current = null; | 1961 | EObject current = null; |
| 1536 | 1962 | ||
| 1537 | EObject iv_ruleModelSymbol = null; | 1963 | EObject iv_ruleExternMetricDefinition = null; |
| 1538 | 1964 | ||
| 1539 | 1965 | ||
| 1540 | try { | 1966 | try { |
| 1541 | // InternalSolverLanguage.g:541:52: (iv_ruleModelSymbol= ruleModelSymbol EOF ) | 1967 | // InternalSolverLanguage.g:724:63: (iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF ) |
| 1542 | // InternalSolverLanguage.g:542:2: iv_ruleModelSymbol= ruleModelSymbol EOF | 1968 | // InternalSolverLanguage.g:725:2: iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF |
| 1543 | { | 1969 | { |
| 1544 | newCompositeNode(grammarAccess.getModelSymbolRule()); | 1970 | if ( state.backtracking==0 ) { |
| 1971 | newCompositeNode(grammarAccess.getExternMetricDefinitionRule()); | ||
| 1972 | } | ||
| 1545 | pushFollow(FOLLOW_1); | 1973 | pushFollow(FOLLOW_1); |
| 1546 | iv_ruleModelSymbol=ruleModelSymbol(); | 1974 | iv_ruleExternMetricDefinition=ruleExternMetricDefinition(); |
| 1547 | 1975 | ||
| 1548 | state._fsp--; | 1976 | state._fsp--; |
| 1549 | 1977 | if (state.failed) return current; | |
| 1550 | current =iv_ruleModelSymbol; | 1978 | if ( state.backtracking==0 ) { |
| 1551 | match(input,EOF,FOLLOW_2); | 1979 | current =iv_ruleExternMetricDefinition; |
| 1980 | } | ||
| 1981 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 1552 | 1982 | ||
| 1553 | } | 1983 | } |
| 1554 | 1984 | ||
| @@ -1562,43 +1992,103 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1562 | } | 1992 | } |
| 1563 | return current; | 1993 | return current; |
| 1564 | } | 1994 | } |
| 1565 | // $ANTLR end "entryRuleModelSymbol" | 1995 | // $ANTLR end "entryRuleExternMetricDefinition" |
| 1566 | 1996 | ||
| 1567 | 1997 | ||
| 1568 | // $ANTLR start "ruleModelSymbol" | 1998 | // $ANTLR start "ruleExternMetricDefinition" |
| 1569 | // InternalSolverLanguage.g:548:1: ruleModelSymbol returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; | 1999 | // InternalSolverLanguage.g:731:1: ruleExternMetricDefinition returns [EObject current=null] : (otherlv_0= 'extern' ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) ; |
| 1570 | public final EObject ruleModelSymbol() throws RecognitionException { | 2000 | public final EObject ruleExternMetricDefinition() throws RecognitionException { |
| 1571 | EObject current = null; | 2001 | EObject current = null; |
| 1572 | 2002 | ||
| 1573 | Token lv_name_0_0=null; | 2003 | Token otherlv_0=null; |
| 2004 | Enumerator lv_type_1_0 = null; | ||
| 2005 | |||
| 2006 | EObject lv_head_2_0 = null; | ||
| 2007 | |||
| 1574 | 2008 | ||
| 1575 | 2009 | ||
| 1576 | enterRule(); | 2010 | enterRule(); |
| 1577 | 2011 | ||
| 1578 | try { | 2012 | try { |
| 1579 | // InternalSolverLanguage.g:554:2: ( ( (lv_name_0_0= RULE_ID ) ) ) | 2013 | // InternalSolverLanguage.g:737:2: ( (otherlv_0= 'extern' ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) ) |
| 1580 | // InternalSolverLanguage.g:555:2: ( (lv_name_0_0= RULE_ID ) ) | 2014 | // InternalSolverLanguage.g:738:2: (otherlv_0= 'extern' ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) |
| 1581 | { | 2015 | { |
| 1582 | // InternalSolverLanguage.g:555:2: ( (lv_name_0_0= RULE_ID ) ) | 2016 | // InternalSolverLanguage.g:738:2: (otherlv_0= 'extern' ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) |
| 1583 | // InternalSolverLanguage.g:556:3: (lv_name_0_0= RULE_ID ) | 2017 | // InternalSolverLanguage.g:739:3: otherlv_0= 'extern' ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) |
| 2018 | { | ||
| 2019 | otherlv_0=(Token)match(input,21,FOLLOW_14); if (state.failed) return current; | ||
| 2020 | if ( state.backtracking==0 ) { | ||
| 2021 | |||
| 2022 | newLeafNode(otherlv_0, grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); | ||
| 2023 | |||
| 2024 | } | ||
| 2025 | // InternalSolverLanguage.g:743:3: ( (lv_type_1_0= ruleMetricType ) ) | ||
| 2026 | // InternalSolverLanguage.g:744:4: (lv_type_1_0= ruleMetricType ) | ||
| 2027 | { | ||
| 2028 | // InternalSolverLanguage.g:744:4: (lv_type_1_0= ruleMetricType ) | ||
| 2029 | // InternalSolverLanguage.g:745:5: lv_type_1_0= ruleMetricType | ||
| 2030 | { | ||
| 2031 | if ( state.backtracking==0 ) { | ||
| 2032 | |||
| 2033 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); | ||
| 2034 | |||
| 2035 | } | ||
| 2036 | pushFollow(FOLLOW_7); | ||
| 2037 | lv_type_1_0=ruleMetricType(); | ||
| 2038 | |||
| 2039 | state._fsp--; | ||
| 2040 | if (state.failed) return current; | ||
| 2041 | if ( state.backtracking==0 ) { | ||
| 2042 | |||
| 2043 | if (current==null) { | ||
| 2044 | current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); | ||
| 2045 | } | ||
| 2046 | set( | ||
| 2047 | current, | ||
| 2048 | "type", | ||
| 2049 | lv_type_1_0, | ||
| 2050 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | ||
| 2051 | afterParserOrEnumRuleCall(); | ||
| 2052 | |||
| 2053 | } | ||
| 2054 | |||
| 2055 | } | ||
| 2056 | |||
| 2057 | |||
| 2058 | } | ||
| 2059 | |||
| 2060 | // InternalSolverLanguage.g:762:3: ( (lv_head_2_0= ruleCall ) ) | ||
| 2061 | // InternalSolverLanguage.g:763:4: (lv_head_2_0= ruleCall ) | ||
| 1584 | { | 2062 | { |
| 1585 | // InternalSolverLanguage.g:556:3: (lv_name_0_0= RULE_ID ) | 2063 | // InternalSolverLanguage.g:763:4: (lv_head_2_0= ruleCall ) |
| 1586 | // InternalSolverLanguage.g:557:4: lv_name_0_0= RULE_ID | 2064 | // InternalSolverLanguage.g:764:5: lv_head_2_0= ruleCall |
| 1587 | { | 2065 | { |
| 1588 | lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); | 2066 | if ( state.backtracking==0 ) { |
| 2067 | |||
| 2068 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); | ||
| 2069 | |||
| 2070 | } | ||
| 2071 | pushFollow(FOLLOW_2); | ||
| 2072 | lv_head_2_0=ruleCall(); | ||
| 2073 | |||
| 2074 | state._fsp--; | ||
| 2075 | if (state.failed) return current; | ||
| 2076 | if ( state.backtracking==0 ) { | ||
| 2077 | |||
| 2078 | if (current==null) { | ||
| 2079 | current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); | ||
| 2080 | } | ||
| 2081 | set( | ||
| 2082 | current, | ||
| 2083 | "head", | ||
| 2084 | lv_head_2_0, | ||
| 2085 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 2086 | afterParserOrEnumRuleCall(); | ||
| 2087 | |||
| 2088 | } | ||
| 1589 | 2089 | ||
| 1590 | newLeafNode(lv_name_0_0, grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); | 2090 | } |
| 1591 | |||
| 1592 | 2091 | ||
| 1593 | if (current==null) { | ||
| 1594 | current = createModelElement(grammarAccess.getModelSymbolRule()); | ||
| 1595 | } | ||
| 1596 | setWithLastConsumed( | ||
| 1597 | current, | ||
| 1598 | "name", | ||
| 1599 | lv_name_0_0, | ||
| 1600 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 1601 | |||
| 1602 | 2092 | ||
| 1603 | } | 2093 | } |
| 1604 | 2094 | ||
| @@ -1608,9 +2098,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1608 | 2098 | ||
| 1609 | } | 2099 | } |
| 1610 | 2100 | ||
| 2101 | if ( state.backtracking==0 ) { | ||
| 1611 | 2102 | ||
| 1612 | leaveRule(); | 2103 | leaveRule(); |
| 1613 | 2104 | ||
| 2105 | } | ||
| 1614 | } | 2106 | } |
| 1615 | 2107 | ||
| 1616 | catch (RecognitionException re) { | 2108 | catch (RecognitionException re) { |
| @@ -1621,29 +2113,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1621 | } | 2113 | } |
| 1622 | return current; | 2114 | return current; |
| 1623 | } | 2115 | } |
| 1624 | // $ANTLR end "ruleModelSymbol" | 2116 | // $ANTLR end "ruleExternMetricDefinition" |
| 1625 | 2117 | ||
| 1626 | 2118 | ||
| 1627 | // $ANTLR start "entryRulePartialitySymbol" | 2119 | // $ANTLR start "entryRuleExpression" |
| 1628 | // InternalSolverLanguage.g:576:1: entryRulePartialitySymbol returns [EObject current=null] : iv_rulePartialitySymbol= rulePartialitySymbol EOF ; | 2120 | // InternalSolverLanguage.g:785:1: entryRuleExpression returns [EObject current=null] : iv_ruleExpression= ruleExpression EOF ; |
| 1629 | public final EObject entryRulePartialitySymbol() throws RecognitionException { | 2121 | public final EObject entryRuleExpression() throws RecognitionException { |
| 1630 | EObject current = null; | 2122 | EObject current = null; |
| 1631 | 2123 | ||
| 1632 | EObject iv_rulePartialitySymbol = null; | 2124 | EObject iv_ruleExpression = null; |
| 1633 | 2125 | ||
| 1634 | 2126 | ||
| 1635 | try { | 2127 | try { |
| 1636 | // InternalSolverLanguage.g:576:57: (iv_rulePartialitySymbol= rulePartialitySymbol EOF ) | 2128 | // InternalSolverLanguage.g:785:51: (iv_ruleExpression= ruleExpression EOF ) |
| 1637 | // InternalSolverLanguage.g:577:2: iv_rulePartialitySymbol= rulePartialitySymbol EOF | 2129 | // InternalSolverLanguage.g:786:2: iv_ruleExpression= ruleExpression EOF |
| 1638 | { | 2130 | { |
| 1639 | newCompositeNode(grammarAccess.getPartialitySymbolRule()); | 2131 | if ( state.backtracking==0 ) { |
| 2132 | newCompositeNode(grammarAccess.getExpressionRule()); | ||
| 2133 | } | ||
| 1640 | pushFollow(FOLLOW_1); | 2134 | pushFollow(FOLLOW_1); |
| 1641 | iv_rulePartialitySymbol=rulePartialitySymbol(); | 2135 | iv_ruleExpression=ruleExpression(); |
| 1642 | 2136 | ||
| 1643 | state._fsp--; | 2137 | state._fsp--; |
| 1644 | 2138 | if (state.failed) return current; | |
| 1645 | current =iv_rulePartialitySymbol; | 2139 | if ( state.backtracking==0 ) { |
| 1646 | match(input,EOF,FOLLOW_2); | 2140 | current =iv_ruleExpression; |
| 2141 | } | ||
| 2142 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 1647 | 2143 | ||
| 1648 | } | 2144 | } |
| 1649 | 2145 | ||
| @@ -1657,76 +2153,85 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1657 | } | 2153 | } |
| 1658 | return current; | 2154 | return current; |
| 1659 | } | 2155 | } |
| 1660 | // $ANTLR end "entryRulePartialitySymbol" | 2156 | // $ANTLR end "entryRuleExpression" |
| 1661 | 2157 | ||
| 1662 | 2158 | ||
| 1663 | // $ANTLR start "rulePartialitySymbol" | 2159 | // $ANTLR start "ruleExpression" |
| 1664 | // InternalSolverLanguage.g:583:1: rulePartialitySymbol returns [EObject current=null] : (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) ; | 2160 | // InternalSolverLanguage.g:792:1: ruleExpression returns [EObject current=null] : (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) ; |
| 1665 | public final EObject rulePartialitySymbol() throws RecognitionException { | 2161 | public final EObject ruleExpression() throws RecognitionException { |
| 1666 | EObject current = null; | 2162 | EObject current = null; |
| 1667 | 2163 | ||
| 1668 | EObject this_ExistSymbol_0 = null; | 2164 | EObject this_IfElse_0 = null; |
| 1669 | 2165 | ||
| 1670 | EObject this_EqualsSymbol_1 = null; | 2166 | EObject this_DisjunctiveExpression_1 = null; |
| 1671 | 2167 | ||
| 1672 | 2168 | ||
| 1673 | 2169 | ||
| 1674 | enterRule(); | 2170 | enterRule(); |
| 1675 | 2171 | ||
| 1676 | try { | 2172 | try { |
| 1677 | // InternalSolverLanguage.g:589:2: ( (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) ) | 2173 | // InternalSolverLanguage.g:798:2: ( (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) ) |
| 1678 | // InternalSolverLanguage.g:590:2: (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) | 2174 | // InternalSolverLanguage.g:799:2: (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) |
| 1679 | { | 2175 | { |
| 1680 | // InternalSolverLanguage.g:590:2: (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) | 2176 | // InternalSolverLanguage.g:799:2: (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) |
| 1681 | int alt12=2; | 2177 | int alt8=2; |
| 1682 | int LA12_0 = input.LA(1); | 2178 | int LA8_0 = input.LA(1); |
| 1683 | 2179 | ||
| 1684 | if ( (LA12_0==21) ) { | 2180 | if ( (LA8_0==23) ) { |
| 1685 | alt12=1; | 2181 | alt8=1; |
| 1686 | } | 2182 | } |
| 1687 | else if ( (LA12_0==22) ) { | 2183 | else if ( ((LA8_0>=RULE_STRING && LA8_0<=RULE_QUOTED_ID)||LA8_0==19||LA8_0==29||LA8_0==33||LA8_0==36||(LA8_0>=39 && LA8_0<=40)||(LA8_0>=56 && LA8_0<=57)||(LA8_0>=60 && LA8_0<=72)) ) { |
| 1688 | alt12=2; | 2184 | alt8=2; |
| 1689 | } | 2185 | } |
| 1690 | else { | 2186 | else { |
| 2187 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 1691 | NoViableAltException nvae = | 2188 | NoViableAltException nvae = |
| 1692 | new NoViableAltException("", 12, 0, input); | 2189 | new NoViableAltException("", 8, 0, input); |
| 1693 | 2190 | ||
| 1694 | throw nvae; | 2191 | throw nvae; |
| 1695 | } | 2192 | } |
| 1696 | switch (alt12) { | 2193 | switch (alt8) { |
| 1697 | case 1 : | 2194 | case 1 : |
| 1698 | // InternalSolverLanguage.g:591:3: this_ExistSymbol_0= ruleExistSymbol | 2195 | // InternalSolverLanguage.g:800:3: this_IfElse_0= ruleIfElse |
| 1699 | { | 2196 | { |
| 2197 | if ( state.backtracking==0 ) { | ||
| 1700 | 2198 | ||
| 1701 | newCompositeNode(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); | 2199 | newCompositeNode(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); |
| 1702 | 2200 | ||
| 2201 | } | ||
| 1703 | pushFollow(FOLLOW_2); | 2202 | pushFollow(FOLLOW_2); |
| 1704 | this_ExistSymbol_0=ruleExistSymbol(); | 2203 | this_IfElse_0=ruleIfElse(); |
| 1705 | 2204 | ||
| 1706 | state._fsp--; | 2205 | state._fsp--; |
| 2206 | if (state.failed) return current; | ||
| 2207 | if ( state.backtracking==0 ) { | ||
| 1707 | 2208 | ||
| 1708 | 2209 | current = this_IfElse_0; | |
| 1709 | current = this_ExistSymbol_0; | 2210 | afterParserOrEnumRuleCall(); |
| 1710 | afterParserOrEnumRuleCall(); | 2211 | |
| 1711 | 2212 | } | |
| 1712 | 2213 | ||
| 1713 | } | 2214 | } |
| 1714 | break; | 2215 | break; |
| 1715 | case 2 : | 2216 | case 2 : |
| 1716 | // InternalSolverLanguage.g:600:3: this_EqualsSymbol_1= ruleEqualsSymbol | 2217 | // InternalSolverLanguage.g:809:3: this_DisjunctiveExpression_1= ruleDisjunctiveExpression |
| 1717 | { | 2218 | { |
| 2219 | if ( state.backtracking==0 ) { | ||
| 1718 | 2220 | ||
| 1719 | newCompositeNode(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); | 2221 | newCompositeNode(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); |
| 1720 | 2222 | ||
| 2223 | } | ||
| 1721 | pushFollow(FOLLOW_2); | 2224 | pushFollow(FOLLOW_2); |
| 1722 | this_EqualsSymbol_1=ruleEqualsSymbol(); | 2225 | this_DisjunctiveExpression_1=ruleDisjunctiveExpression(); |
| 1723 | 2226 | ||
| 1724 | state._fsp--; | 2227 | state._fsp--; |
| 2228 | if (state.failed) return current; | ||
| 2229 | if ( state.backtracking==0 ) { | ||
| 1725 | 2230 | ||
| 1726 | 2231 | current = this_DisjunctiveExpression_1; | |
| 1727 | current = this_EqualsSymbol_1; | 2232 | afterParserOrEnumRuleCall(); |
| 1728 | afterParserOrEnumRuleCall(); | 2233 | |
| 1729 | 2234 | } | |
| 1730 | 2235 | ||
| 1731 | } | 2236 | } |
| 1732 | break; | 2237 | break; |
| @@ -1736,9 +2241,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1736 | 2241 | ||
| 1737 | } | 2242 | } |
| 1738 | 2243 | ||
| 2244 | if ( state.backtracking==0 ) { | ||
| 1739 | 2245 | ||
| 1740 | leaveRule(); | 2246 | leaveRule(); |
| 1741 | 2247 | ||
| 2248 | } | ||
| 1742 | } | 2249 | } |
| 1743 | 2250 | ||
| 1744 | catch (RecognitionException re) { | 2251 | catch (RecognitionException re) { |
| @@ -1749,29 +2256,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1749 | } | 2256 | } |
| 1750 | return current; | 2257 | return current; |
| 1751 | } | 2258 | } |
| 1752 | // $ANTLR end "rulePartialitySymbol" | 2259 | // $ANTLR end "ruleExpression" |
| 1753 | 2260 | ||
| 1754 | 2261 | ||
| 1755 | // $ANTLR start "entryRuleExistSymbol" | 2262 | // $ANTLR start "entryRuleIfElse" |
| 1756 | // InternalSolverLanguage.g:612:1: entryRuleExistSymbol returns [EObject current=null] : iv_ruleExistSymbol= ruleExistSymbol EOF ; | 2263 | // InternalSolverLanguage.g:821:1: entryRuleIfElse returns [EObject current=null] : iv_ruleIfElse= ruleIfElse EOF ; |
| 1757 | public final EObject entryRuleExistSymbol() throws RecognitionException { | 2264 | public final EObject entryRuleIfElse() throws RecognitionException { |
| 1758 | EObject current = null; | 2265 | EObject current = null; |
| 1759 | 2266 | ||
| 1760 | EObject iv_ruleExistSymbol = null; | 2267 | EObject iv_ruleIfElse = null; |
| 1761 | 2268 | ||
| 1762 | 2269 | ||
| 1763 | try { | 2270 | try { |
| 1764 | // InternalSolverLanguage.g:612:52: (iv_ruleExistSymbol= ruleExistSymbol EOF ) | 2271 | // InternalSolverLanguage.g:821:47: (iv_ruleIfElse= ruleIfElse EOF ) |
| 1765 | // InternalSolverLanguage.g:613:2: iv_ruleExistSymbol= ruleExistSymbol EOF | 2272 | // InternalSolverLanguage.g:822:2: iv_ruleIfElse= ruleIfElse EOF |
| 1766 | { | 2273 | { |
| 1767 | newCompositeNode(grammarAccess.getExistSymbolRule()); | 2274 | if ( state.backtracking==0 ) { |
| 2275 | newCompositeNode(grammarAccess.getIfElseRule()); | ||
| 2276 | } | ||
| 1768 | pushFollow(FOLLOW_1); | 2277 | pushFollow(FOLLOW_1); |
| 1769 | iv_ruleExistSymbol=ruleExistSymbol(); | 2278 | iv_ruleIfElse=ruleIfElse(); |
| 1770 | 2279 | ||
| 1771 | state._fsp--; | 2280 | state._fsp--; |
| 1772 | 2281 | if (state.failed) return current; | |
| 1773 | current =iv_ruleExistSymbol; | 2282 | if ( state.backtracking==0 ) { |
| 1774 | match(input,EOF,FOLLOW_2); | 2283 | current =iv_ruleIfElse; |
| 2284 | } | ||
| 2285 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 1775 | 2286 | ||
| 1776 | } | 2287 | } |
| 1777 | 2288 | ||
| @@ -1785,50 +2296,168 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1785 | } | 2296 | } |
| 1786 | return current; | 2297 | return current; |
| 1787 | } | 2298 | } |
| 1788 | // $ANTLR end "entryRuleExistSymbol" | 2299 | // $ANTLR end "entryRuleIfElse" |
| 1789 | 2300 | ||
| 1790 | 2301 | ||
| 1791 | // $ANTLR start "ruleExistSymbol" | 2302 | // $ANTLR start "ruleIfElse" |
| 1792 | // InternalSolverLanguage.g:619:1: ruleExistSymbol returns [EObject current=null] : (otherlv_0= 'exists' () ) ; | 2303 | // InternalSolverLanguage.g:828:1: ruleIfElse returns [EObject current=null] : (otherlv_0= 'if' ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= 'then' ( (lv_then_3_0= ruleExpression ) ) otherlv_4= 'else' ( (lv_else_5_0= ruleExpression ) ) ) ; |
| 1793 | public final EObject ruleExistSymbol() throws RecognitionException { | 2304 | public final EObject ruleIfElse() throws RecognitionException { |
| 1794 | EObject current = null; | 2305 | EObject current = null; |
| 1795 | 2306 | ||
| 1796 | Token otherlv_0=null; | 2307 | Token otherlv_0=null; |
| 2308 | Token otherlv_2=null; | ||
| 2309 | Token otherlv_4=null; | ||
| 2310 | EObject lv_condition_1_0 = null; | ||
| 2311 | |||
| 2312 | EObject lv_then_3_0 = null; | ||
| 2313 | |||
| 2314 | EObject lv_else_5_0 = null; | ||
| 2315 | |||
| 1797 | 2316 | ||
| 1798 | 2317 | ||
| 1799 | enterRule(); | 2318 | enterRule(); |
| 1800 | 2319 | ||
| 1801 | try { | 2320 | try { |
| 1802 | // InternalSolverLanguage.g:625:2: ( (otherlv_0= 'exists' () ) ) | 2321 | // InternalSolverLanguage.g:834:2: ( (otherlv_0= 'if' ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= 'then' ( (lv_then_3_0= ruleExpression ) ) otherlv_4= 'else' ( (lv_else_5_0= ruleExpression ) ) ) ) |
| 1803 | // InternalSolverLanguage.g:626:2: (otherlv_0= 'exists' () ) | 2322 | // InternalSolverLanguage.g:835:2: (otherlv_0= 'if' ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= 'then' ( (lv_then_3_0= ruleExpression ) ) otherlv_4= 'else' ( (lv_else_5_0= ruleExpression ) ) ) |
| 1804 | { | 2323 | { |
| 1805 | // InternalSolverLanguage.g:626:2: (otherlv_0= 'exists' () ) | 2324 | // InternalSolverLanguage.g:835:2: (otherlv_0= 'if' ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= 'then' ( (lv_then_3_0= ruleExpression ) ) otherlv_4= 'else' ( (lv_else_5_0= ruleExpression ) ) ) |
| 1806 | // InternalSolverLanguage.g:627:3: otherlv_0= 'exists' () | 2325 | // InternalSolverLanguage.g:836:3: otherlv_0= 'if' ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= 'then' ( (lv_then_3_0= ruleExpression ) ) otherlv_4= 'else' ( (lv_else_5_0= ruleExpression ) ) |
| 1807 | { | 2326 | { |
| 1808 | otherlv_0=(Token)match(input,21,FOLLOW_2); | 2327 | otherlv_0=(Token)match(input,23,FOLLOW_6); if (state.failed) return current; |
| 2328 | if ( state.backtracking==0 ) { | ||
| 1809 | 2329 | ||
| 1810 | newLeafNode(otherlv_0, grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); | 2330 | newLeafNode(otherlv_0, grammarAccess.getIfElseAccess().getIfKeyword_0()); |
| 1811 | 2331 | ||
| 1812 | // InternalSolverLanguage.g:631:3: () | 2332 | } |
| 1813 | // InternalSolverLanguage.g:632:4: | 2333 | // InternalSolverLanguage.g:840:3: ( (lv_condition_1_0= ruleExpression ) ) |
| 2334 | // InternalSolverLanguage.g:841:4: (lv_condition_1_0= ruleExpression ) | ||
| 1814 | { | 2335 | { |
| 2336 | // InternalSolverLanguage.g:841:4: (lv_condition_1_0= ruleExpression ) | ||
| 2337 | // InternalSolverLanguage.g:842:5: lv_condition_1_0= ruleExpression | ||
| 2338 | { | ||
| 2339 | if ( state.backtracking==0 ) { | ||
| 2340 | |||
| 2341 | newCompositeNode(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); | ||
| 2342 | |||
| 2343 | } | ||
| 2344 | pushFollow(FOLLOW_15); | ||
| 2345 | lv_condition_1_0=ruleExpression(); | ||
| 2346 | |||
| 2347 | state._fsp--; | ||
| 2348 | if (state.failed) return current; | ||
| 2349 | if ( state.backtracking==0 ) { | ||
| 2350 | |||
| 2351 | if (current==null) { | ||
| 2352 | current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 2353 | } | ||
| 2354 | set( | ||
| 2355 | current, | ||
| 2356 | "condition", | ||
| 2357 | lv_condition_1_0, | ||
| 2358 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 2359 | afterParserOrEnumRuleCall(); | ||
| 2360 | |||
| 2361 | } | ||
| 2362 | |||
| 2363 | } | ||
| 1815 | 2364 | ||
| 1816 | current = forceCreateModelElement( | ||
| 1817 | grammarAccess.getExistSymbolAccess().getExistSymbolAction_1(), | ||
| 1818 | current); | ||
| 1819 | |||
| 1820 | 2365 | ||
| 1821 | } | 2366 | } |
| 1822 | 2367 | ||
| 2368 | otherlv_2=(Token)match(input,24,FOLLOW_6); if (state.failed) return current; | ||
| 2369 | if ( state.backtracking==0 ) { | ||
| 1823 | 2370 | ||
| 2371 | newLeafNode(otherlv_2, grammarAccess.getIfElseAccess().getThenKeyword_2()); | ||
| 2372 | |||
| 1824 | } | 2373 | } |
| 2374 | // InternalSolverLanguage.g:863:3: ( (lv_then_3_0= ruleExpression ) ) | ||
| 2375 | // InternalSolverLanguage.g:864:4: (lv_then_3_0= ruleExpression ) | ||
| 2376 | { | ||
| 2377 | // InternalSolverLanguage.g:864:4: (lv_then_3_0= ruleExpression ) | ||
| 2378 | // InternalSolverLanguage.g:865:5: lv_then_3_0= ruleExpression | ||
| 2379 | { | ||
| 2380 | if ( state.backtracking==0 ) { | ||
| 2381 | |||
| 2382 | newCompositeNode(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); | ||
| 2383 | |||
| 2384 | } | ||
| 2385 | pushFollow(FOLLOW_16); | ||
| 2386 | lv_then_3_0=ruleExpression(); | ||
| 1825 | 2387 | ||
| 2388 | state._fsp--; | ||
| 2389 | if (state.failed) return current; | ||
| 2390 | if ( state.backtracking==0 ) { | ||
| 2391 | |||
| 2392 | if (current==null) { | ||
| 2393 | current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 2394 | } | ||
| 2395 | set( | ||
| 2396 | current, | ||
| 2397 | "then", | ||
| 2398 | lv_then_3_0, | ||
| 2399 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 2400 | afterParserOrEnumRuleCall(); | ||
| 2401 | |||
| 2402 | } | ||
| 1826 | 2403 | ||
| 1827 | } | 2404 | } |
| 1828 | 2405 | ||
| 1829 | 2406 | ||
| 1830 | leaveRule(); | 2407 | } |
| 1831 | 2408 | ||
| 2409 | otherlv_4=(Token)match(input,25,FOLLOW_6); if (state.failed) return current; | ||
| 2410 | if ( state.backtracking==0 ) { | ||
| 2411 | |||
| 2412 | newLeafNode(otherlv_4, grammarAccess.getIfElseAccess().getElseKeyword_4()); | ||
| 2413 | |||
| 2414 | } | ||
| 2415 | // InternalSolverLanguage.g:886:3: ( (lv_else_5_0= ruleExpression ) ) | ||
| 2416 | // InternalSolverLanguage.g:887:4: (lv_else_5_0= ruleExpression ) | ||
| 2417 | { | ||
| 2418 | // InternalSolverLanguage.g:887:4: (lv_else_5_0= ruleExpression ) | ||
| 2419 | // InternalSolverLanguage.g:888:5: lv_else_5_0= ruleExpression | ||
| 2420 | { | ||
| 2421 | if ( state.backtracking==0 ) { | ||
| 2422 | |||
| 2423 | newCompositeNode(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); | ||
| 2424 | |||
| 2425 | } | ||
| 2426 | pushFollow(FOLLOW_2); | ||
| 2427 | lv_else_5_0=ruleExpression(); | ||
| 2428 | |||
| 2429 | state._fsp--; | ||
| 2430 | if (state.failed) return current; | ||
| 2431 | if ( state.backtracking==0 ) { | ||
| 2432 | |||
| 2433 | if (current==null) { | ||
| 2434 | current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 2435 | } | ||
| 2436 | set( | ||
| 2437 | current, | ||
| 2438 | "else", | ||
| 2439 | lv_else_5_0, | ||
| 2440 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 2441 | afterParserOrEnumRuleCall(); | ||
| 2442 | |||
| 2443 | } | ||
| 2444 | |||
| 2445 | } | ||
| 2446 | |||
| 2447 | |||
| 2448 | } | ||
| 2449 | |||
| 2450 | |||
| 2451 | } | ||
| 2452 | |||
| 2453 | |||
| 2454 | } | ||
| 2455 | |||
| 2456 | if ( state.backtracking==0 ) { | ||
| 2457 | |||
| 2458 | leaveRule(); | ||
| 2459 | |||
| 2460 | } | ||
| 1832 | } | 2461 | } |
| 1833 | 2462 | ||
| 1834 | catch (RecognitionException re) { | 2463 | catch (RecognitionException re) { |
| @@ -1839,29 +2468,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1839 | } | 2468 | } |
| 1840 | return current; | 2469 | return current; |
| 1841 | } | 2470 | } |
| 1842 | // $ANTLR end "ruleExistSymbol" | 2471 | // $ANTLR end "ruleIfElse" |
| 1843 | 2472 | ||
| 1844 | 2473 | ||
| 1845 | // $ANTLR start "entryRuleEqualsSymbol" | 2474 | // $ANTLR start "entryRuleDisjunctiveExpression" |
| 1846 | // InternalSolverLanguage.g:642:1: entryRuleEqualsSymbol returns [EObject current=null] : iv_ruleEqualsSymbol= ruleEqualsSymbol EOF ; | 2475 | // InternalSolverLanguage.g:909:1: entryRuleDisjunctiveExpression returns [EObject current=null] : iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF ; |
| 1847 | public final EObject entryRuleEqualsSymbol() throws RecognitionException { | 2476 | public final EObject entryRuleDisjunctiveExpression() throws RecognitionException { |
| 1848 | EObject current = null; | 2477 | EObject current = null; |
| 1849 | 2478 | ||
| 1850 | EObject iv_ruleEqualsSymbol = null; | 2479 | EObject iv_ruleDisjunctiveExpression = null; |
| 1851 | 2480 | ||
| 1852 | 2481 | ||
| 1853 | try { | 2482 | try { |
| 1854 | // InternalSolverLanguage.g:642:53: (iv_ruleEqualsSymbol= ruleEqualsSymbol EOF ) | 2483 | // InternalSolverLanguage.g:909:62: (iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF ) |
| 1855 | // InternalSolverLanguage.g:643:2: iv_ruleEqualsSymbol= ruleEqualsSymbol EOF | 2484 | // InternalSolverLanguage.g:910:2: iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF |
| 1856 | { | 2485 | { |
| 1857 | newCompositeNode(grammarAccess.getEqualsSymbolRule()); | 2486 | if ( state.backtracking==0 ) { |
| 2487 | newCompositeNode(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 2488 | } | ||
| 1858 | pushFollow(FOLLOW_1); | 2489 | pushFollow(FOLLOW_1); |
| 1859 | iv_ruleEqualsSymbol=ruleEqualsSymbol(); | 2490 | iv_ruleDisjunctiveExpression=ruleDisjunctiveExpression(); |
| 1860 | 2491 | ||
| 1861 | state._fsp--; | 2492 | state._fsp--; |
| 1862 | 2493 | if (state.failed) return current; | |
| 1863 | current =iv_ruleEqualsSymbol; | 2494 | if ( state.backtracking==0 ) { |
| 1864 | match(input,EOF,FOLLOW_2); | 2495 | current =iv_ruleDisjunctiveExpression; |
| 2496 | } | ||
| 2497 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 1865 | 2498 | ||
| 1866 | } | 2499 | } |
| 1867 | 2500 | ||
| @@ -1875,38 +2508,303 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1875 | } | 2508 | } |
| 1876 | return current; | 2509 | return current; |
| 1877 | } | 2510 | } |
| 1878 | // $ANTLR end "entryRuleEqualsSymbol" | 2511 | // $ANTLR end "entryRuleDisjunctiveExpression" |
| 1879 | 2512 | ||
| 1880 | 2513 | ||
| 1881 | // $ANTLR start "ruleEqualsSymbol" | 2514 | // $ANTLR start "ruleDisjunctiveExpression" |
| 1882 | // InternalSolverLanguage.g:649:1: ruleEqualsSymbol returns [EObject current=null] : (otherlv_0= 'equals' () ) ; | 2515 | // InternalSolverLanguage.g:916:1: ruleDisjunctiveExpression returns [EObject current=null] : (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) ; |
| 1883 | public final EObject ruleEqualsSymbol() throws RecognitionException { | 2516 | public final EObject ruleDisjunctiveExpression() throws RecognitionException { |
| 1884 | EObject current = null; | 2517 | EObject current = null; |
| 1885 | 2518 | ||
| 1886 | Token otherlv_0=null; | 2519 | Token otherlv_2=null; |
| 2520 | Token otherlv_5=null; | ||
| 2521 | Token otherlv_8=null; | ||
| 2522 | EObject this_ConjunctiveExpression_0 = null; | ||
| 2523 | |||
| 2524 | EObject lv_children_3_0 = null; | ||
| 2525 | |||
| 2526 | EObject lv_body_6_0 = null; | ||
| 2527 | |||
| 2528 | EObject lv_cases_9_0 = null; | ||
| 2529 | |||
| 1887 | 2530 | ||
| 1888 | 2531 | ||
| 1889 | enterRule(); | 2532 | enterRule(); |
| 1890 | 2533 | ||
| 1891 | try { | 2534 | try { |
| 1892 | // InternalSolverLanguage.g:655:2: ( (otherlv_0= 'equals' () ) ) | 2535 | // InternalSolverLanguage.g:922:2: ( (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) ) |
| 1893 | // InternalSolverLanguage.g:656:2: (otherlv_0= 'equals' () ) | 2536 | // InternalSolverLanguage.g:923:2: (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) |
| 1894 | { | 2537 | { |
| 1895 | // InternalSolverLanguage.g:656:2: (otherlv_0= 'equals' () ) | 2538 | // InternalSolverLanguage.g:923:2: (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) |
| 1896 | // InternalSolverLanguage.g:657:3: otherlv_0= 'equals' () | 2539 | // InternalSolverLanguage.g:924:3: this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? |
| 1897 | { | 2540 | { |
| 1898 | otherlv_0=(Token)match(input,22,FOLLOW_2); | 2541 | if ( state.backtracking==0 ) { |
| 1899 | 2542 | ||
| 1900 | newLeafNode(otherlv_0, grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); | 2543 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); |
| 1901 | 2544 | ||
| 1902 | // InternalSolverLanguage.g:661:3: () | 2545 | } |
| 1903 | // InternalSolverLanguage.g:662:4: | 2546 | pushFollow(FOLLOW_17); |
| 1904 | { | 2547 | this_ConjunctiveExpression_0=ruleConjunctiveExpression(); |
| 2548 | |||
| 2549 | state._fsp--; | ||
| 2550 | if (state.failed) return current; | ||
| 2551 | if ( state.backtracking==0 ) { | ||
| 2552 | |||
| 2553 | current = this_ConjunctiveExpression_0; | ||
| 2554 | afterParserOrEnumRuleCall(); | ||
| 2555 | |||
| 2556 | } | ||
| 2557 | // InternalSolverLanguage.g:932:3: ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? | ||
| 2558 | int alt11=3; | ||
| 2559 | int LA11_0 = input.LA(1); | ||
| 2560 | |||
| 2561 | if ( (LA11_0==26) ) { | ||
| 2562 | alt11=1; | ||
| 2563 | } | ||
| 2564 | else if ( (LA11_0==27) ) { | ||
| 2565 | alt11=2; | ||
| 2566 | } | ||
| 2567 | switch (alt11) { | ||
| 2568 | case 1 : | ||
| 2569 | // InternalSolverLanguage.g:933:4: ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ||
| 2570 | { | ||
| 2571 | // InternalSolverLanguage.g:933:4: ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ||
| 2572 | // InternalSolverLanguage.g:934:5: () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ | ||
| 2573 | { | ||
| 2574 | // InternalSolverLanguage.g:934:5: () | ||
| 2575 | // InternalSolverLanguage.g:935:6: | ||
| 2576 | { | ||
| 2577 | if ( state.backtracking==0 ) { | ||
| 2578 | |||
| 2579 | current = forceCreateModelElementAndAdd( | ||
| 2580 | grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0(), | ||
| 2581 | current); | ||
| 2582 | |||
| 2583 | } | ||
| 2584 | |||
| 2585 | } | ||
| 2586 | |||
| 2587 | // InternalSolverLanguage.g:941:5: (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ | ||
| 2588 | int cnt9=0; | ||
| 2589 | loop9: | ||
| 2590 | do { | ||
| 2591 | int alt9=2; | ||
| 2592 | int LA9_0 = input.LA(1); | ||
| 2593 | |||
| 2594 | if ( (LA9_0==26) ) { | ||
| 2595 | alt9=1; | ||
| 2596 | } | ||
| 2597 | |||
| 2598 | |||
| 2599 | switch (alt9) { | ||
| 2600 | case 1 : | ||
| 2601 | // InternalSolverLanguage.g:942:6: otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) | ||
| 2602 | { | ||
| 2603 | otherlv_2=(Token)match(input,26,FOLLOW_6); if (state.failed) return current; | ||
| 2604 | if ( state.backtracking==0 ) { | ||
| 2605 | |||
| 2606 | newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); | ||
| 2607 | |||
| 2608 | } | ||
| 2609 | // InternalSolverLanguage.g:946:6: ( (lv_children_3_0= ruleConjunctiveExpression ) ) | ||
| 2610 | // InternalSolverLanguage.g:947:7: (lv_children_3_0= ruleConjunctiveExpression ) | ||
| 2611 | { | ||
| 2612 | // InternalSolverLanguage.g:947:7: (lv_children_3_0= ruleConjunctiveExpression ) | ||
| 2613 | // InternalSolverLanguage.g:948:8: lv_children_3_0= ruleConjunctiveExpression | ||
| 2614 | { | ||
| 2615 | if ( state.backtracking==0 ) { | ||
| 2616 | |||
| 2617 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); | ||
| 2618 | |||
| 2619 | } | ||
| 2620 | pushFollow(FOLLOW_18); | ||
| 2621 | lv_children_3_0=ruleConjunctiveExpression(); | ||
| 2622 | |||
| 2623 | state._fsp--; | ||
| 2624 | if (state.failed) return current; | ||
| 2625 | if ( state.backtracking==0 ) { | ||
| 2626 | |||
| 2627 | if (current==null) { | ||
| 2628 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 2629 | } | ||
| 2630 | add( | ||
| 2631 | current, | ||
| 2632 | "children", | ||
| 2633 | lv_children_3_0, | ||
| 2634 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 2635 | afterParserOrEnumRuleCall(); | ||
| 2636 | |||
| 2637 | } | ||
| 2638 | |||
| 2639 | } | ||
| 2640 | |||
| 2641 | |||
| 2642 | } | ||
| 2643 | |||
| 2644 | |||
| 2645 | } | ||
| 2646 | break; | ||
| 2647 | |||
| 2648 | default : | ||
| 2649 | if ( cnt9 >= 1 ) break loop9; | ||
| 2650 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 2651 | EarlyExitException eee = | ||
| 2652 | new EarlyExitException(9, input); | ||
| 2653 | throw eee; | ||
| 2654 | } | ||
| 2655 | cnt9++; | ||
| 2656 | } while (true); | ||
| 2657 | |||
| 2658 | |||
| 2659 | } | ||
| 2660 | |||
| 2661 | |||
| 2662 | } | ||
| 2663 | break; | ||
| 2664 | case 2 : | ||
| 2665 | // InternalSolverLanguage.g:968:4: ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) | ||
| 2666 | { | ||
| 2667 | // InternalSolverLanguage.g:968:4: ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) | ||
| 2668 | // InternalSolverLanguage.g:969:5: () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* | ||
| 2669 | { | ||
| 2670 | // InternalSolverLanguage.g:969:5: () | ||
| 2671 | // InternalSolverLanguage.g:970:6: | ||
| 2672 | { | ||
| 2673 | if ( state.backtracking==0 ) { | ||
| 2674 | |||
| 2675 | current = forceCreateModelElementAndSet( | ||
| 2676 | grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), | ||
| 2677 | current); | ||
| 2678 | |||
| 2679 | } | ||
| 2680 | |||
| 2681 | } | ||
| 2682 | |||
| 2683 | otherlv_5=(Token)match(input,27,FOLLOW_6); if (state.failed) return current; | ||
| 2684 | if ( state.backtracking==0 ) { | ||
| 2685 | |||
| 2686 | newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); | ||
| 2687 | |||
| 2688 | } | ||
| 2689 | // InternalSolverLanguage.g:980:5: ( (lv_body_6_0= ruleConjunctiveExpression ) ) | ||
| 2690 | // InternalSolverLanguage.g:981:6: (lv_body_6_0= ruleConjunctiveExpression ) | ||
| 2691 | { | ||
| 2692 | // InternalSolverLanguage.g:981:6: (lv_body_6_0= ruleConjunctiveExpression ) | ||
| 2693 | // InternalSolverLanguage.g:982:7: lv_body_6_0= ruleConjunctiveExpression | ||
| 2694 | { | ||
| 2695 | if ( state.backtracking==0 ) { | ||
| 2696 | |||
| 2697 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); | ||
| 2698 | |||
| 2699 | } | ||
| 2700 | pushFollow(FOLLOW_18); | ||
| 2701 | lv_body_6_0=ruleConjunctiveExpression(); | ||
| 2702 | |||
| 2703 | state._fsp--; | ||
| 2704 | if (state.failed) return current; | ||
| 2705 | if ( state.backtracking==0 ) { | ||
| 2706 | |||
| 2707 | if (current==null) { | ||
| 2708 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 2709 | } | ||
| 2710 | set( | ||
| 2711 | current, | ||
| 2712 | "body", | ||
| 2713 | lv_body_6_0, | ||
| 2714 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 2715 | afterParserOrEnumRuleCall(); | ||
| 2716 | |||
| 2717 | } | ||
| 2718 | |||
| 2719 | } | ||
| 2720 | |||
| 2721 | |||
| 2722 | } | ||
| 2723 | |||
| 2724 | // InternalSolverLanguage.g:999:5: () | ||
| 2725 | // InternalSolverLanguage.g:1000:6: | ||
| 2726 | { | ||
| 2727 | if ( state.backtracking==0 ) { | ||
| 2728 | |||
| 2729 | current = forceCreateModelElementAndAdd( | ||
| 2730 | grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3(), | ||
| 2731 | current); | ||
| 2732 | |||
| 2733 | } | ||
| 2734 | |||
| 2735 | } | ||
| 2736 | |||
| 2737 | // InternalSolverLanguage.g:1006:5: (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* | ||
| 2738 | loop10: | ||
| 2739 | do { | ||
| 2740 | int alt10=2; | ||
| 2741 | int LA10_0 = input.LA(1); | ||
| 2742 | |||
| 2743 | if ( (LA10_0==26) ) { | ||
| 2744 | alt10=1; | ||
| 2745 | } | ||
| 2746 | |||
| 2747 | |||
| 2748 | switch (alt10) { | ||
| 2749 | case 1 : | ||
| 2750 | // InternalSolverLanguage.g:1007:6: otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) | ||
| 2751 | { | ||
| 2752 | otherlv_8=(Token)match(input,26,FOLLOW_6); if (state.failed) return current; | ||
| 2753 | if ( state.backtracking==0 ) { | ||
| 2754 | |||
| 2755 | newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); | ||
| 2756 | |||
| 2757 | } | ||
| 2758 | // InternalSolverLanguage.g:1011:6: ( (lv_cases_9_0= ruleCase ) ) | ||
| 2759 | // InternalSolverLanguage.g:1012:7: (lv_cases_9_0= ruleCase ) | ||
| 2760 | { | ||
| 2761 | // InternalSolverLanguage.g:1012:7: (lv_cases_9_0= ruleCase ) | ||
| 2762 | // InternalSolverLanguage.g:1013:8: lv_cases_9_0= ruleCase | ||
| 2763 | { | ||
| 2764 | if ( state.backtracking==0 ) { | ||
| 2765 | |||
| 2766 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); | ||
| 2767 | |||
| 2768 | } | ||
| 2769 | pushFollow(FOLLOW_18); | ||
| 2770 | lv_cases_9_0=ruleCase(); | ||
| 2771 | |||
| 2772 | state._fsp--; | ||
| 2773 | if (state.failed) return current; | ||
| 2774 | if ( state.backtracking==0 ) { | ||
| 2775 | |||
| 2776 | if (current==null) { | ||
| 2777 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 2778 | } | ||
| 2779 | add( | ||
| 2780 | current, | ||
| 2781 | "cases", | ||
| 2782 | lv_cases_9_0, | ||
| 2783 | "org.eclipse.viatra.solver.language.SolverLanguage.Case"); | ||
| 2784 | afterParserOrEnumRuleCall(); | ||
| 2785 | |||
| 2786 | } | ||
| 2787 | |||
| 2788 | } | ||
| 2789 | |||
| 2790 | |||
| 2791 | } | ||
| 2792 | |||
| 2793 | |||
| 2794 | } | ||
| 2795 | break; | ||
| 2796 | |||
| 2797 | default : | ||
| 2798 | break loop10; | ||
| 2799 | } | ||
| 2800 | } while (true); | ||
| 1905 | 2801 | ||
| 1906 | current = forceCreateModelElement( | 2802 | |
| 1907 | grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1(), | 2803 | } |
| 1908 | current); | 2804 | |
| 1909 | 2805 | ||
| 2806 | } | ||
| 2807 | break; | ||
| 1910 | 2808 | ||
| 1911 | } | 2809 | } |
| 1912 | 2810 | ||
| @@ -1916,9 +2814,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1916 | 2814 | ||
| 1917 | } | 2815 | } |
| 1918 | 2816 | ||
| 2817 | if ( state.backtracking==0 ) { | ||
| 1919 | 2818 | ||
| 1920 | leaveRule(); | 2819 | leaveRule(); |
| 1921 | 2820 | ||
| 2821 | } | ||
| 1922 | } | 2822 | } |
| 1923 | 2823 | ||
| 1924 | catch (RecognitionException re) { | 2824 | catch (RecognitionException re) { |
| @@ -1929,32 +2829,157 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1929 | } | 2829 | } |
| 1930 | return current; | 2830 | return current; |
| 1931 | } | 2831 | } |
| 1932 | // $ANTLR end "ruleEqualsSymbol" | 2832 | // $ANTLR end "ruleDisjunctiveExpression" |
| 1933 | 2833 | ||
| 1934 | 2834 | ||
| 1935 | // $ANTLR start "entryRuleDataSymbol" | 2835 | // $ANTLR start "entryRuleCase" |
| 1936 | // InternalSolverLanguage.g:672:1: entryRuleDataSymbol returns [EObject current=null] : iv_ruleDataSymbol= ruleDataSymbol EOF ; | 2836 | // InternalSolverLanguage.g:1037:1: entryRuleCase returns [EObject current=null] : iv_ruleCase= ruleCase EOF ; |
| 1937 | public final EObject entryRuleDataSymbol() throws RecognitionException { | 2837 | public final EObject entryRuleCase() throws RecognitionException { |
| 1938 | EObject current = null; | 2838 | EObject current = null; |
| 1939 | 2839 | ||
| 1940 | EObject iv_ruleDataSymbol = null; | 2840 | EObject iv_ruleCase = null; |
| 1941 | 2841 | ||
| 1942 | 2842 | ||
| 1943 | try { | 2843 | try { |
| 1944 | // InternalSolverLanguage.g:672:51: (iv_ruleDataSymbol= ruleDataSymbol EOF ) | 2844 | // InternalSolverLanguage.g:1037:45: (iv_ruleCase= ruleCase EOF ) |
| 1945 | // InternalSolverLanguage.g:673:2: iv_ruleDataSymbol= ruleDataSymbol EOF | 2845 | // InternalSolverLanguage.g:1038:2: iv_ruleCase= ruleCase EOF |
| 1946 | { | 2846 | { |
| 1947 | newCompositeNode(grammarAccess.getDataSymbolRule()); | 2847 | if ( state.backtracking==0 ) { |
| 2848 | newCompositeNode(grammarAccess.getCaseRule()); | ||
| 2849 | } | ||
| 1948 | pushFollow(FOLLOW_1); | 2850 | pushFollow(FOLLOW_1); |
| 1949 | iv_ruleDataSymbol=ruleDataSymbol(); | 2851 | iv_ruleCase=ruleCase(); |
| 2852 | |||
| 2853 | state._fsp--; | ||
| 2854 | if (state.failed) return current; | ||
| 2855 | if ( state.backtracking==0 ) { | ||
| 2856 | current =iv_ruleCase; | ||
| 2857 | } | ||
| 2858 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 2859 | |||
| 2860 | } | ||
| 2861 | |||
| 2862 | } | ||
| 2863 | |||
| 2864 | catch (RecognitionException re) { | ||
| 2865 | recover(input,re); | ||
| 2866 | appendSkippedTokens(); | ||
| 2867 | } | ||
| 2868 | finally { | ||
| 2869 | } | ||
| 2870 | return current; | ||
| 2871 | } | ||
| 2872 | // $ANTLR end "entryRuleCase" | ||
| 2873 | |||
| 2874 | |||
| 2875 | // $ANTLR start "ruleCase" | ||
| 2876 | // InternalSolverLanguage.g:1044:1: ruleCase returns [EObject current=null] : ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= '->' ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) ; | ||
| 2877 | public final EObject ruleCase() throws RecognitionException { | ||
| 2878 | EObject current = null; | ||
| 2879 | |||
| 2880 | Token otherlv_1=null; | ||
| 2881 | EObject lv_condition_0_0 = null; | ||
| 2882 | |||
| 2883 | EObject lv_body_2_0 = null; | ||
| 2884 | |||
| 2885 | |||
| 2886 | |||
| 2887 | enterRule(); | ||
| 2888 | |||
| 2889 | try { | ||
| 2890 | // InternalSolverLanguage.g:1050:2: ( ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= '->' ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) ) | ||
| 2891 | // InternalSolverLanguage.g:1051:2: ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= '->' ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) | ||
| 2892 | { | ||
| 2893 | // InternalSolverLanguage.g:1051:2: ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= '->' ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) | ||
| 2894 | // InternalSolverLanguage.g:1052:3: ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= '->' ( (lv_body_2_0= ruleConjunctiveExpression ) ) | ||
| 2895 | { | ||
| 2896 | // InternalSolverLanguage.g:1052:3: ( (lv_condition_0_0= ruleConjunctiveExpression ) ) | ||
| 2897 | // InternalSolverLanguage.g:1053:4: (lv_condition_0_0= ruleConjunctiveExpression ) | ||
| 2898 | { | ||
| 2899 | // InternalSolverLanguage.g:1053:4: (lv_condition_0_0= ruleConjunctiveExpression ) | ||
| 2900 | // InternalSolverLanguage.g:1054:5: lv_condition_0_0= ruleConjunctiveExpression | ||
| 2901 | { | ||
| 2902 | if ( state.backtracking==0 ) { | ||
| 2903 | |||
| 2904 | newCompositeNode(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); | ||
| 2905 | |||
| 2906 | } | ||
| 2907 | pushFollow(FOLLOW_19); | ||
| 2908 | lv_condition_0_0=ruleConjunctiveExpression(); | ||
| 1950 | 2909 | ||
| 1951 | state._fsp--; | 2910 | state._fsp--; |
| 2911 | if (state.failed) return current; | ||
| 2912 | if ( state.backtracking==0 ) { | ||
| 2913 | |||
| 2914 | if (current==null) { | ||
| 2915 | current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
| 2916 | } | ||
| 2917 | set( | ||
| 2918 | current, | ||
| 2919 | "condition", | ||
| 2920 | lv_condition_0_0, | ||
| 2921 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 2922 | afterParserOrEnumRuleCall(); | ||
| 2923 | |||
| 2924 | } | ||
| 2925 | |||
| 2926 | } | ||
| 2927 | |||
| 2928 | |||
| 2929 | } | ||
| 1952 | 2930 | ||
| 1953 | current =iv_ruleDataSymbol; | 2931 | otherlv_1=(Token)match(input,27,FOLLOW_6); if (state.failed) return current; |
| 1954 | match(input,EOF,FOLLOW_2); | 2932 | if ( state.backtracking==0 ) { |
| 1955 | 2933 | ||
| 2934 | newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); | ||
| 2935 | |||
| 1956 | } | 2936 | } |
| 2937 | // InternalSolverLanguage.g:1075:3: ( (lv_body_2_0= ruleConjunctiveExpression ) ) | ||
| 2938 | // InternalSolverLanguage.g:1076:4: (lv_body_2_0= ruleConjunctiveExpression ) | ||
| 2939 | { | ||
| 2940 | // InternalSolverLanguage.g:1076:4: (lv_body_2_0= ruleConjunctiveExpression ) | ||
| 2941 | // InternalSolverLanguage.g:1077:5: lv_body_2_0= ruleConjunctiveExpression | ||
| 2942 | { | ||
| 2943 | if ( state.backtracking==0 ) { | ||
| 2944 | |||
| 2945 | newCompositeNode(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); | ||
| 2946 | |||
| 2947 | } | ||
| 2948 | pushFollow(FOLLOW_2); | ||
| 2949 | lv_body_2_0=ruleConjunctiveExpression(); | ||
| 2950 | |||
| 2951 | state._fsp--; | ||
| 2952 | if (state.failed) return current; | ||
| 2953 | if ( state.backtracking==0 ) { | ||
| 1957 | 2954 | ||
| 2955 | if (current==null) { | ||
| 2956 | current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
| 2957 | } | ||
| 2958 | set( | ||
| 2959 | current, | ||
| 2960 | "body", | ||
| 2961 | lv_body_2_0, | ||
| 2962 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 2963 | afterParserOrEnumRuleCall(); | ||
| 2964 | |||
| 2965 | } | ||
| 2966 | |||
| 2967 | } | ||
| 2968 | |||
| 2969 | |||
| 2970 | } | ||
| 2971 | |||
| 2972 | |||
| 2973 | } | ||
| 2974 | |||
| 2975 | |||
| 2976 | } | ||
| 2977 | |||
| 2978 | if ( state.backtracking==0 ) { | ||
| 2979 | |||
| 2980 | leaveRule(); | ||
| 2981 | |||
| 2982 | } | ||
| 1958 | } | 2983 | } |
| 1959 | 2984 | ||
| 1960 | catch (RecognitionException re) { | 2985 | catch (RecognitionException re) { |
| @@ -1965,130 +2990,181 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1965 | } | 2990 | } |
| 1966 | return current; | 2991 | return current; |
| 1967 | } | 2992 | } |
| 1968 | // $ANTLR end "entryRuleDataSymbol" | 2993 | // $ANTLR end "ruleCase" |
| 1969 | 2994 | ||
| 1970 | 2995 | ||
| 1971 | // $ANTLR start "ruleDataSymbol" | 2996 | // $ANTLR start "entryRuleConjunctiveExpression" |
| 1972 | // InternalSolverLanguage.g:679:1: ruleDataSymbol returns [EObject current=null] : (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) ; | 2997 | // InternalSolverLanguage.g:1098:1: entryRuleConjunctiveExpression returns [EObject current=null] : iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF ; |
| 1973 | public final EObject ruleDataSymbol() throws RecognitionException { | 2998 | public final EObject entryRuleConjunctiveExpression() throws RecognitionException { |
| 1974 | EObject current = null; | 2999 | EObject current = null; |
| 1975 | 3000 | ||
| 1976 | EObject this_BooleanSymbol_0 = null; | 3001 | EObject iv_ruleConjunctiveExpression = null; |
| 1977 | 3002 | ||
| 1978 | EObject this_IntegerSymbol_1 = null; | ||
| 1979 | 3003 | ||
| 1980 | EObject this_RealSymbol_2 = null; | 3004 | try { |
| 3005 | // InternalSolverLanguage.g:1098:62: (iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF ) | ||
| 3006 | // InternalSolverLanguage.g:1099:2: iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF | ||
| 3007 | { | ||
| 3008 | if ( state.backtracking==0 ) { | ||
| 3009 | newCompositeNode(grammarAccess.getConjunctiveExpressionRule()); | ||
| 3010 | } | ||
| 3011 | pushFollow(FOLLOW_1); | ||
| 3012 | iv_ruleConjunctiveExpression=ruleConjunctiveExpression(); | ||
| 1981 | 3013 | ||
| 1982 | EObject this_StringSymbol_3 = null; | 3014 | state._fsp--; |
| 3015 | if (state.failed) return current; | ||
| 3016 | if ( state.backtracking==0 ) { | ||
| 3017 | current =iv_ruleConjunctiveExpression; | ||
| 3018 | } | ||
| 3019 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 3020 | |||
| 3021 | } | ||
| 3022 | |||
| 3023 | } | ||
| 3024 | |||
| 3025 | catch (RecognitionException re) { | ||
| 3026 | recover(input,re); | ||
| 3027 | appendSkippedTokens(); | ||
| 3028 | } | ||
| 3029 | finally { | ||
| 3030 | } | ||
| 3031 | return current; | ||
| 3032 | } | ||
| 3033 | // $ANTLR end "entryRuleConjunctiveExpression" | ||
| 3034 | |||
| 3035 | |||
| 3036 | // $ANTLR start "ruleConjunctiveExpression" | ||
| 3037 | // InternalSolverLanguage.g:1105:1: ruleConjunctiveExpression returns [EObject current=null] : (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) ; | ||
| 3038 | public final EObject ruleConjunctiveExpression() throws RecognitionException { | ||
| 3039 | EObject current = null; | ||
| 3040 | |||
| 3041 | Token otherlv_2=null; | ||
| 3042 | EObject this_ComparisonExpression_0 = null; | ||
| 3043 | |||
| 3044 | EObject lv_children_3_0 = null; | ||
| 1983 | 3045 | ||
| 1984 | 3046 | ||
| 1985 | 3047 | ||
| 1986 | enterRule(); | 3048 | enterRule(); |
| 1987 | 3049 | ||
| 1988 | try { | 3050 | try { |
| 1989 | // InternalSolverLanguage.g:685:2: ( (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) ) | 3051 | // InternalSolverLanguage.g:1111:2: ( (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) ) |
| 1990 | // InternalSolverLanguage.g:686:2: (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) | 3052 | // InternalSolverLanguage.g:1112:2: (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) |
| 1991 | { | 3053 | { |
| 1992 | // InternalSolverLanguage.g:686:2: (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) | 3054 | // InternalSolverLanguage.g:1112:2: (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) |
| 1993 | int alt13=4; | 3055 | // InternalSolverLanguage.g:1113:3: this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? |
| 1994 | switch ( input.LA(1) ) { | 3056 | { |
| 1995 | case 23: | 3057 | if ( state.backtracking==0 ) { |
| 1996 | { | ||
| 1997 | alt13=1; | ||
| 1998 | } | ||
| 1999 | break; | ||
| 2000 | case 24: | ||
| 2001 | { | ||
| 2002 | alt13=2; | ||
| 2003 | } | ||
| 2004 | break; | ||
| 2005 | case 25: | ||
| 2006 | { | ||
| 2007 | alt13=3; | ||
| 2008 | } | ||
| 2009 | break; | ||
| 2010 | case 26: | ||
| 2011 | { | ||
| 2012 | alt13=4; | ||
| 2013 | } | ||
| 2014 | break; | ||
| 2015 | default: | ||
| 2016 | NoViableAltException nvae = | ||
| 2017 | new NoViableAltException("", 13, 0, input); | ||
| 2018 | 3058 | ||
| 2019 | throw nvae; | 3059 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); |
| 3060 | |||
| 2020 | } | 3061 | } |
| 3062 | pushFollow(FOLLOW_20); | ||
| 3063 | this_ComparisonExpression_0=ruleComparisonExpression(); | ||
| 3064 | |||
| 3065 | state._fsp--; | ||
| 3066 | if (state.failed) return current; | ||
| 3067 | if ( state.backtracking==0 ) { | ||
| 3068 | |||
| 3069 | current = this_ComparisonExpression_0; | ||
| 3070 | afterParserOrEnumRuleCall(); | ||
| 3071 | |||
| 3072 | } | ||
| 3073 | // InternalSolverLanguage.g:1121:3: ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? | ||
| 3074 | int alt13=2; | ||
| 3075 | int LA13_0 = input.LA(1); | ||
| 2021 | 3076 | ||
| 3077 | if ( (LA13_0==28) ) { | ||
| 3078 | alt13=1; | ||
| 3079 | } | ||
| 2022 | switch (alt13) { | 3080 | switch (alt13) { |
| 2023 | case 1 : | 3081 | case 1 : |
| 2024 | // InternalSolverLanguage.g:687:3: this_BooleanSymbol_0= ruleBooleanSymbol | 3082 | // InternalSolverLanguage.g:1122:4: () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ |
| 2025 | { | 3083 | { |
| 3084 | // InternalSolverLanguage.g:1122:4: () | ||
| 3085 | // InternalSolverLanguage.g:1123:5: | ||
| 3086 | { | ||
| 3087 | if ( state.backtracking==0 ) { | ||
| 2026 | 3088 | ||
| 2027 | newCompositeNode(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); | 3089 | current = forceCreateModelElementAndAdd( |
| 2028 | 3090 | grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0(), | |
| 2029 | pushFollow(FOLLOW_2); | 3091 | current); |
| 2030 | this_BooleanSymbol_0=ruleBooleanSymbol(); | 3092 | |
| 2031 | 3093 | } | |
| 2032 | state._fsp--; | ||
| 2033 | |||
| 2034 | |||
| 2035 | current = this_BooleanSymbol_0; | ||
| 2036 | afterParserOrEnumRuleCall(); | ||
| 2037 | |||
| 2038 | 3094 | ||
| 2039 | } | 3095 | } |
| 2040 | break; | ||
| 2041 | case 2 : | ||
| 2042 | // InternalSolverLanguage.g:696:3: this_IntegerSymbol_1= ruleIntegerSymbol | ||
| 2043 | { | ||
| 2044 | 3096 | ||
| 2045 | newCompositeNode(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); | 3097 | // InternalSolverLanguage.g:1129:4: (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ |
| 2046 | 3098 | int cnt12=0; | |
| 2047 | pushFollow(FOLLOW_2); | 3099 | loop12: |
| 2048 | this_IntegerSymbol_1=ruleIntegerSymbol(); | 3100 | do { |
| 3101 | int alt12=2; | ||
| 3102 | int LA12_0 = input.LA(1); | ||
| 2049 | 3103 | ||
| 2050 | state._fsp--; | 3104 | if ( (LA12_0==28) ) { |
| 3105 | alt12=1; | ||
| 3106 | } | ||
| 2051 | 3107 | ||
| 2052 | 3108 | ||
| 2053 | current = this_IntegerSymbol_1; | 3109 | switch (alt12) { |
| 2054 | afterParserOrEnumRuleCall(); | 3110 | case 1 : |
| 2055 | 3111 | // InternalSolverLanguage.g:1130:5: otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) | |
| 3112 | { | ||
| 3113 | otherlv_2=(Token)match(input,28,FOLLOW_6); if (state.failed) return current; | ||
| 3114 | if ( state.backtracking==0 ) { | ||
| 2056 | 3115 | ||
| 2057 | } | 3116 | newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); |
| 2058 | break; | 3117 | |
| 2059 | case 3 : | 3118 | } |
| 2060 | // InternalSolverLanguage.g:705:3: this_RealSymbol_2= ruleRealSymbol | 3119 | // InternalSolverLanguage.g:1134:5: ( (lv_children_3_0= ruleComparisonExpression ) ) |
| 2061 | { | 3120 | // InternalSolverLanguage.g:1135:6: (lv_children_3_0= ruleComparisonExpression ) |
| 3121 | { | ||
| 3122 | // InternalSolverLanguage.g:1135:6: (lv_children_3_0= ruleComparisonExpression ) | ||
| 3123 | // InternalSolverLanguage.g:1136:7: lv_children_3_0= ruleComparisonExpression | ||
| 3124 | { | ||
| 3125 | if ( state.backtracking==0 ) { | ||
| 2062 | 3126 | ||
| 2063 | newCompositeNode(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); | 3127 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); |
| 2064 | 3128 | ||
| 2065 | pushFollow(FOLLOW_2); | 3129 | } |
| 2066 | this_RealSymbol_2=ruleRealSymbol(); | 3130 | pushFollow(FOLLOW_20); |
| 3131 | lv_children_3_0=ruleComparisonExpression(); | ||
| 2067 | 3132 | ||
| 2068 | state._fsp--; | 3133 | state._fsp--; |
| 3134 | if (state.failed) return current; | ||
| 3135 | if ( state.backtracking==0 ) { | ||
| 3136 | |||
| 3137 | if (current==null) { | ||
| 3138 | current = createModelElementForParent(grammarAccess.getConjunctiveExpressionRule()); | ||
| 3139 | } | ||
| 3140 | add( | ||
| 3141 | current, | ||
| 3142 | "children", | ||
| 3143 | lv_children_3_0, | ||
| 3144 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
| 3145 | afterParserOrEnumRuleCall(); | ||
| 3146 | |||
| 3147 | } | ||
| 2069 | 3148 | ||
| 3149 | } | ||
| 2070 | 3150 | ||
| 2071 | current = this_RealSymbol_2; | ||
| 2072 | afterParserOrEnumRuleCall(); | ||
| 2073 | |||
| 2074 | 3151 | ||
| 2075 | } | 3152 | } |
| 2076 | break; | ||
| 2077 | case 4 : | ||
| 2078 | // InternalSolverLanguage.g:714:3: this_StringSymbol_3= ruleStringSymbol | ||
| 2079 | { | ||
| 2080 | 3153 | ||
| 2081 | newCompositeNode(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); | ||
| 2082 | |||
| 2083 | pushFollow(FOLLOW_2); | ||
| 2084 | this_StringSymbol_3=ruleStringSymbol(); | ||
| 2085 | 3154 | ||
| 2086 | state._fsp--; | 3155 | } |
| 3156 | break; | ||
| 2087 | 3157 | ||
| 3158 | default : | ||
| 3159 | if ( cnt12 >= 1 ) break loop12; | ||
| 3160 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 3161 | EarlyExitException eee = | ||
| 3162 | new EarlyExitException(12, input); | ||
| 3163 | throw eee; | ||
| 3164 | } | ||
| 3165 | cnt12++; | ||
| 3166 | } while (true); | ||
| 2088 | 3167 | ||
| 2089 | current = this_StringSymbol_3; | ||
| 2090 | afterParserOrEnumRuleCall(); | ||
| 2091 | |||
| 2092 | 3168 | ||
| 2093 | } | 3169 | } |
| 2094 | break; | 3170 | break; |
| @@ -2099,8 +3175,13 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2099 | } | 3175 | } |
| 2100 | 3176 | ||
| 2101 | 3177 | ||
| 2102 | leaveRule(); | 3178 | } |
| 3179 | |||
| 3180 | if ( state.backtracking==0 ) { | ||
| 3181 | |||
| 3182 | leaveRule(); | ||
| 2103 | 3183 | ||
| 3184 | } | ||
| 2104 | } | 3185 | } |
| 2105 | 3186 | ||
| 2106 | catch (RecognitionException re) { | 3187 | catch (RecognitionException re) { |
| @@ -2111,29 +3192,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2111 | } | 3192 | } |
| 2112 | return current; | 3193 | return current; |
| 2113 | } | 3194 | } |
| 2114 | // $ANTLR end "ruleDataSymbol" | 3195 | // $ANTLR end "ruleConjunctiveExpression" |
| 2115 | 3196 | ||
| 2116 | 3197 | ||
| 2117 | // $ANTLR start "entryRuleBooleanSymbol" | 3198 | // $ANTLR start "entryRuleComparisonExpression" |
| 2118 | // InternalSolverLanguage.g:726:1: entryRuleBooleanSymbol returns [EObject current=null] : iv_ruleBooleanSymbol= ruleBooleanSymbol EOF ; | 3199 | // InternalSolverLanguage.g:1159:1: entryRuleComparisonExpression returns [EObject current=null] : iv_ruleComparisonExpression= ruleComparisonExpression EOF ; |
| 2119 | public final EObject entryRuleBooleanSymbol() throws RecognitionException { | 3200 | public final EObject entryRuleComparisonExpression() throws RecognitionException { |
| 2120 | EObject current = null; | 3201 | EObject current = null; |
| 2121 | 3202 | ||
| 2122 | EObject iv_ruleBooleanSymbol = null; | 3203 | EObject iv_ruleComparisonExpression = null; |
| 2123 | 3204 | ||
| 2124 | 3205 | ||
| 2125 | try { | 3206 | try { |
| 2126 | // InternalSolverLanguage.g:726:54: (iv_ruleBooleanSymbol= ruleBooleanSymbol EOF ) | 3207 | // InternalSolverLanguage.g:1159:61: (iv_ruleComparisonExpression= ruleComparisonExpression EOF ) |
| 2127 | // InternalSolverLanguage.g:727:2: iv_ruleBooleanSymbol= ruleBooleanSymbol EOF | 3208 | // InternalSolverLanguage.g:1160:2: iv_ruleComparisonExpression= ruleComparisonExpression EOF |
| 2128 | { | 3209 | { |
| 2129 | newCompositeNode(grammarAccess.getBooleanSymbolRule()); | 3210 | if ( state.backtracking==0 ) { |
| 3211 | newCompositeNode(grammarAccess.getComparisonExpressionRule()); | ||
| 3212 | } | ||
| 2130 | pushFollow(FOLLOW_1); | 3213 | pushFollow(FOLLOW_1); |
| 2131 | iv_ruleBooleanSymbol=ruleBooleanSymbol(); | 3214 | iv_ruleComparisonExpression=ruleComparisonExpression(); |
| 2132 | 3215 | ||
| 2133 | state._fsp--; | 3216 | state._fsp--; |
| 2134 | 3217 | if (state.failed) return current; | |
| 2135 | current =iv_ruleBooleanSymbol; | 3218 | if ( state.backtracking==0 ) { |
| 2136 | match(input,EOF,FOLLOW_2); | 3219 | current =iv_ruleComparisonExpression; |
| 3220 | } | ||
| 3221 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 2137 | 3222 | ||
| 2138 | } | 3223 | } |
| 2139 | 3224 | ||
| @@ -2147,41 +3232,144 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2147 | } | 3232 | } |
| 2148 | return current; | 3233 | return current; |
| 2149 | } | 3234 | } |
| 2150 | // $ANTLR end "entryRuleBooleanSymbol" | 3235 | // $ANTLR end "entryRuleComparisonExpression" |
| 2151 | 3236 | ||
| 2152 | 3237 | ||
| 2153 | // $ANTLR start "ruleBooleanSymbol" | 3238 | // $ANTLR start "ruleComparisonExpression" |
| 2154 | // InternalSolverLanguage.g:733:1: ruleBooleanSymbol returns [EObject current=null] : (otherlv_0= 'bool' () ) ; | 3239 | // InternalSolverLanguage.g:1166:1: ruleComparisonExpression returns [EObject current=null] : (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ; |
| 2155 | public final EObject ruleBooleanSymbol() throws RecognitionException { | 3240 | public final EObject ruleComparisonExpression() throws RecognitionException { |
| 2156 | EObject current = null; | 3241 | EObject current = null; |
| 2157 | 3242 | ||
| 2158 | Token otherlv_0=null; | 3243 | EObject this_AdditiveExpression_0 = null; |
| 3244 | |||
| 3245 | Enumerator lv_op_2_0 = null; | ||
| 3246 | |||
| 3247 | EObject lv_right_3_0 = null; | ||
| 3248 | |||
| 2159 | 3249 | ||
| 2160 | 3250 | ||
| 2161 | enterRule(); | 3251 | enterRule(); |
| 2162 | 3252 | ||
| 2163 | try { | 3253 | try { |
| 2164 | // InternalSolverLanguage.g:739:2: ( (otherlv_0= 'bool' () ) ) | 3254 | // InternalSolverLanguage.g:1172:2: ( (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ) |
| 2165 | // InternalSolverLanguage.g:740:2: (otherlv_0= 'bool' () ) | 3255 | // InternalSolverLanguage.g:1173:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) |
| 2166 | { | 3256 | { |
| 2167 | // InternalSolverLanguage.g:740:2: (otherlv_0= 'bool' () ) | 3257 | // InternalSolverLanguage.g:1173:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) |
| 2168 | // InternalSolverLanguage.g:741:3: otherlv_0= 'bool' () | 3258 | // InternalSolverLanguage.g:1174:3: this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? |
| 2169 | { | 3259 | { |
| 2170 | otherlv_0=(Token)match(input,23,FOLLOW_2); | 3260 | if ( state.backtracking==0 ) { |
| 2171 | 3261 | ||
| 2172 | newLeafNode(otherlv_0, grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); | 3262 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); |
| 2173 | 3263 | ||
| 2174 | // InternalSolverLanguage.g:745:3: () | 3264 | } |
| 2175 | // InternalSolverLanguage.g:746:4: | 3265 | pushFollow(FOLLOW_21); |
| 2176 | { | 3266 | this_AdditiveExpression_0=ruleAdditiveExpression(); |
| 3267 | |||
| 3268 | state._fsp--; | ||
| 3269 | if (state.failed) return current; | ||
| 3270 | if ( state.backtracking==0 ) { | ||
| 2177 | 3271 | ||
| 2178 | current = forceCreateModelElement( | 3272 | current = this_AdditiveExpression_0; |
| 2179 | grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1(), | 3273 | afterParserOrEnumRuleCall(); |
| 2180 | current); | 3274 | |
| 2181 | 3275 | } | |
| 3276 | // InternalSolverLanguage.g:1182:3: ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? | ||
| 3277 | int alt14=2; | ||
| 3278 | int LA14_0 = input.LA(1); | ||
| 2182 | 3279 | ||
| 3280 | if ( ((LA14_0>=47 && LA14_0<=49)||(LA14_0>=52 && LA14_0<=55)) ) { | ||
| 3281 | alt14=1; | ||
| 2183 | } | 3282 | } |
| 3283 | switch (alt14) { | ||
| 3284 | case 1 : | ||
| 3285 | // InternalSolverLanguage.g:1183:4: () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) | ||
| 3286 | { | ||
| 3287 | // InternalSolverLanguage.g:1183:4: () | ||
| 3288 | // InternalSolverLanguage.g:1184:5: | ||
| 3289 | { | ||
| 3290 | if ( state.backtracking==0 ) { | ||
| 3291 | |||
| 3292 | current = forceCreateModelElementAndSet( | ||
| 3293 | grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(), | ||
| 3294 | current); | ||
| 3295 | |||
| 3296 | } | ||
| 3297 | |||
| 3298 | } | ||
| 2184 | 3299 | ||
| 3300 | // InternalSolverLanguage.g:1190:4: ( (lv_op_2_0= ruleComparisonOperator ) ) | ||
| 3301 | // InternalSolverLanguage.g:1191:5: (lv_op_2_0= ruleComparisonOperator ) | ||
| 3302 | { | ||
| 3303 | // InternalSolverLanguage.g:1191:5: (lv_op_2_0= ruleComparisonOperator ) | ||
| 3304 | // InternalSolverLanguage.g:1192:6: lv_op_2_0= ruleComparisonOperator | ||
| 3305 | { | ||
| 3306 | if ( state.backtracking==0 ) { | ||
| 3307 | |||
| 3308 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); | ||
| 3309 | |||
| 3310 | } | ||
| 3311 | pushFollow(FOLLOW_6); | ||
| 3312 | lv_op_2_0=ruleComparisonOperator(); | ||
| 3313 | |||
| 3314 | state._fsp--; | ||
| 3315 | if (state.failed) return current; | ||
| 3316 | if ( state.backtracking==0 ) { | ||
| 3317 | |||
| 3318 | if (current==null) { | ||
| 3319 | current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
| 3320 | } | ||
| 3321 | set( | ||
| 3322 | current, | ||
| 3323 | "op", | ||
| 3324 | lv_op_2_0, | ||
| 3325 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator"); | ||
| 3326 | afterParserOrEnumRuleCall(); | ||
| 3327 | |||
| 3328 | } | ||
| 3329 | |||
| 3330 | } | ||
| 3331 | |||
| 3332 | |||
| 3333 | } | ||
| 3334 | |||
| 3335 | // InternalSolverLanguage.g:1209:4: ( (lv_right_3_0= ruleAdditiveExpression ) ) | ||
| 3336 | // InternalSolverLanguage.g:1210:5: (lv_right_3_0= ruleAdditiveExpression ) | ||
| 3337 | { | ||
| 3338 | // InternalSolverLanguage.g:1210:5: (lv_right_3_0= ruleAdditiveExpression ) | ||
| 3339 | // InternalSolverLanguage.g:1211:6: lv_right_3_0= ruleAdditiveExpression | ||
| 3340 | { | ||
| 3341 | if ( state.backtracking==0 ) { | ||
| 3342 | |||
| 3343 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); | ||
| 3344 | |||
| 3345 | } | ||
| 3346 | pushFollow(FOLLOW_2); | ||
| 3347 | lv_right_3_0=ruleAdditiveExpression(); | ||
| 3348 | |||
| 3349 | state._fsp--; | ||
| 3350 | if (state.failed) return current; | ||
| 3351 | if ( state.backtracking==0 ) { | ||
| 3352 | |||
| 3353 | if (current==null) { | ||
| 3354 | current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
| 3355 | } | ||
| 3356 | set( | ||
| 3357 | current, | ||
| 3358 | "right", | ||
| 3359 | lv_right_3_0, | ||
| 3360 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
| 3361 | afterParserOrEnumRuleCall(); | ||
| 3362 | |||
| 3363 | } | ||
| 3364 | |||
| 3365 | } | ||
| 3366 | |||
| 3367 | |||
| 3368 | } | ||
| 3369 | |||
| 3370 | |||
| 3371 | } | ||
| 3372 | break; | ||
| 2185 | 3373 | ||
| 2186 | } | 3374 | } |
| 2187 | 3375 | ||
| @@ -2189,8 +3377,13 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2189 | } | 3377 | } |
| 2190 | 3378 | ||
| 2191 | 3379 | ||
| 2192 | leaveRule(); | 3380 | } |
| 3381 | |||
| 3382 | if ( state.backtracking==0 ) { | ||
| 2193 | 3383 | ||
| 3384 | leaveRule(); | ||
| 3385 | |||
| 3386 | } | ||
| 2194 | } | 3387 | } |
| 2195 | 3388 | ||
| 2196 | catch (RecognitionException re) { | 3389 | catch (RecognitionException re) { |
| @@ -2201,29 +3394,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2201 | } | 3394 | } |
| 2202 | return current; | 3395 | return current; |
| 2203 | } | 3396 | } |
| 2204 | // $ANTLR end "ruleBooleanSymbol" | 3397 | // $ANTLR end "ruleComparisonExpression" |
| 2205 | 3398 | ||
| 2206 | 3399 | ||
| 2207 | // $ANTLR start "entryRuleIntegerSymbol" | 3400 | // $ANTLR start "entryRuleAdditiveExpression" |
| 2208 | // InternalSolverLanguage.g:756:1: entryRuleIntegerSymbol returns [EObject current=null] : iv_ruleIntegerSymbol= ruleIntegerSymbol EOF ; | 3401 | // InternalSolverLanguage.g:1233:1: entryRuleAdditiveExpression returns [EObject current=null] : iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ; |
| 2209 | public final EObject entryRuleIntegerSymbol() throws RecognitionException { | 3402 | public final EObject entryRuleAdditiveExpression() throws RecognitionException { |
| 2210 | EObject current = null; | 3403 | EObject current = null; |
| 2211 | 3404 | ||
| 2212 | EObject iv_ruleIntegerSymbol = null; | 3405 | EObject iv_ruleAdditiveExpression = null; |
| 2213 | 3406 | ||
| 2214 | 3407 | ||
| 2215 | try { | 3408 | try { |
| 2216 | // InternalSolverLanguage.g:756:54: (iv_ruleIntegerSymbol= ruleIntegerSymbol EOF ) | 3409 | // InternalSolverLanguage.g:1233:59: (iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ) |
| 2217 | // InternalSolverLanguage.g:757:2: iv_ruleIntegerSymbol= ruleIntegerSymbol EOF | 3410 | // InternalSolverLanguage.g:1234:2: iv_ruleAdditiveExpression= ruleAdditiveExpression EOF |
| 2218 | { | 3411 | { |
| 2219 | newCompositeNode(grammarAccess.getIntegerSymbolRule()); | 3412 | if ( state.backtracking==0 ) { |
| 3413 | newCompositeNode(grammarAccess.getAdditiveExpressionRule()); | ||
| 3414 | } | ||
| 2220 | pushFollow(FOLLOW_1); | 3415 | pushFollow(FOLLOW_1); |
| 2221 | iv_ruleIntegerSymbol=ruleIntegerSymbol(); | 3416 | iv_ruleAdditiveExpression=ruleAdditiveExpression(); |
| 2222 | 3417 | ||
| 2223 | state._fsp--; | 3418 | state._fsp--; |
| 2224 | 3419 | if (state.failed) return current; | |
| 2225 | current =iv_ruleIntegerSymbol; | 3420 | if ( state.backtracking==0 ) { |
| 2226 | match(input,EOF,FOLLOW_2); | 3421 | current =iv_ruleAdditiveExpression; |
| 3422 | } | ||
| 3423 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 2227 | 3424 | ||
| 2228 | } | 3425 | } |
| 2229 | 3426 | ||
| @@ -2237,40 +3434,153 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2237 | } | 3434 | } |
| 2238 | return current; | 3435 | return current; |
| 2239 | } | 3436 | } |
| 2240 | // $ANTLR end "entryRuleIntegerSymbol" | 3437 | // $ANTLR end "entryRuleAdditiveExpression" |
| 2241 | 3438 | ||
| 2242 | 3439 | ||
| 2243 | // $ANTLR start "ruleIntegerSymbol" | 3440 | // $ANTLR start "ruleAdditiveExpression" |
| 2244 | // InternalSolverLanguage.g:763:1: ruleIntegerSymbol returns [EObject current=null] : (otherlv_0= 'int' () ) ; | 3441 | // InternalSolverLanguage.g:1240:1: ruleAdditiveExpression returns [EObject current=null] : (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ; |
| 2245 | public final EObject ruleIntegerSymbol() throws RecognitionException { | 3442 | public final EObject ruleAdditiveExpression() throws RecognitionException { |
| 2246 | EObject current = null; | 3443 | EObject current = null; |
| 2247 | 3444 | ||
| 2248 | Token otherlv_0=null; | 3445 | EObject this_MultiplicativeExpression_0 = null; |
| 3446 | |||
| 3447 | Enumerator lv_op_2_0 = null; | ||
| 3448 | |||
| 3449 | EObject lv_right_3_0 = null; | ||
| 3450 | |||
| 2249 | 3451 | ||
| 2250 | 3452 | ||
| 2251 | enterRule(); | 3453 | enterRule(); |
| 2252 | 3454 | ||
| 2253 | try { | 3455 | try { |
| 2254 | // InternalSolverLanguage.g:769:2: ( (otherlv_0= 'int' () ) ) | 3456 | // InternalSolverLanguage.g:1246:2: ( (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ) |
| 2255 | // InternalSolverLanguage.g:770:2: (otherlv_0= 'int' () ) | 3457 | // InternalSolverLanguage.g:1247:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) |
| 2256 | { | 3458 | { |
| 2257 | // InternalSolverLanguage.g:770:2: (otherlv_0= 'int' () ) | 3459 | // InternalSolverLanguage.g:1247:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) |
| 2258 | // InternalSolverLanguage.g:771:3: otherlv_0= 'int' () | 3460 | // InternalSolverLanguage.g:1248:3: this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* |
| 2259 | { | 3461 | { |
| 2260 | otherlv_0=(Token)match(input,24,FOLLOW_2); | 3462 | if ( state.backtracking==0 ) { |
| 2261 | 3463 | ||
| 2262 | newLeafNode(otherlv_0, grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); | 3464 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); |
| 2263 | 3465 | ||
| 2264 | // InternalSolverLanguage.g:775:3: () | 3466 | } |
| 2265 | // InternalSolverLanguage.g:776:4: | 3467 | pushFollow(FOLLOW_22); |
| 2266 | { | 3468 | this_MultiplicativeExpression_0=ruleMultiplicativeExpression(); |
| 2267 | 3469 | ||
| 2268 | current = forceCreateModelElement( | 3470 | state._fsp--; |
| 2269 | grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1(), | 3471 | if (state.failed) return current; |
| 2270 | current); | 3472 | if ( state.backtracking==0 ) { |
| 2271 | |||
| 2272 | 3473 | ||
| 3474 | current = this_MultiplicativeExpression_0; | ||
| 3475 | afterParserOrEnumRuleCall(); | ||
| 3476 | |||
| 2273 | } | 3477 | } |
| 3478 | // InternalSolverLanguage.g:1256:3: ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* | ||
| 3479 | loop15: | ||
| 3480 | do { | ||
| 3481 | int alt15=2; | ||
| 3482 | int LA15_0 = input.LA(1); | ||
| 3483 | |||
| 3484 | if ( ((LA15_0>=56 && LA15_0<=57)) ) { | ||
| 3485 | alt15=1; | ||
| 3486 | } | ||
| 3487 | |||
| 3488 | |||
| 3489 | switch (alt15) { | ||
| 3490 | case 1 : | ||
| 3491 | // InternalSolverLanguage.g:1257:4: () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) | ||
| 3492 | { | ||
| 3493 | // InternalSolverLanguage.g:1257:4: () | ||
| 3494 | // InternalSolverLanguage.g:1258:5: | ||
| 3495 | { | ||
| 3496 | if ( state.backtracking==0 ) { | ||
| 3497 | |||
| 3498 | current = forceCreateModelElementAndSet( | ||
| 3499 | grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 3500 | current); | ||
| 3501 | |||
| 3502 | } | ||
| 3503 | |||
| 3504 | } | ||
| 3505 | |||
| 3506 | // InternalSolverLanguage.g:1264:4: ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) | ||
| 3507 | // InternalSolverLanguage.g:1265:5: (lv_op_2_0= ruleAdditiveBinaryOperator ) | ||
| 3508 | { | ||
| 3509 | // InternalSolverLanguage.g:1265:5: (lv_op_2_0= ruleAdditiveBinaryOperator ) | ||
| 3510 | // InternalSolverLanguage.g:1266:6: lv_op_2_0= ruleAdditiveBinaryOperator | ||
| 3511 | { | ||
| 3512 | if ( state.backtracking==0 ) { | ||
| 3513 | |||
| 3514 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); | ||
| 3515 | |||
| 3516 | } | ||
| 3517 | pushFollow(FOLLOW_6); | ||
| 3518 | lv_op_2_0=ruleAdditiveBinaryOperator(); | ||
| 3519 | |||
| 3520 | state._fsp--; | ||
| 3521 | if (state.failed) return current; | ||
| 3522 | if ( state.backtracking==0 ) { | ||
| 3523 | |||
| 3524 | if (current==null) { | ||
| 3525 | current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
| 3526 | } | ||
| 3527 | set( | ||
| 3528 | current, | ||
| 3529 | "op", | ||
| 3530 | lv_op_2_0, | ||
| 3531 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator"); | ||
| 3532 | afterParserOrEnumRuleCall(); | ||
| 3533 | |||
| 3534 | } | ||
| 3535 | |||
| 3536 | } | ||
| 3537 | |||
| 3538 | |||
| 3539 | } | ||
| 3540 | |||
| 3541 | // InternalSolverLanguage.g:1283:4: ( (lv_right_3_0= ruleMultiplicativeExpression ) ) | ||
| 3542 | // InternalSolverLanguage.g:1284:5: (lv_right_3_0= ruleMultiplicativeExpression ) | ||
| 3543 | { | ||
| 3544 | // InternalSolverLanguage.g:1284:5: (lv_right_3_0= ruleMultiplicativeExpression ) | ||
| 3545 | // InternalSolverLanguage.g:1285:6: lv_right_3_0= ruleMultiplicativeExpression | ||
| 3546 | { | ||
| 3547 | if ( state.backtracking==0 ) { | ||
| 3548 | |||
| 3549 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); | ||
| 3550 | |||
| 3551 | } | ||
| 3552 | pushFollow(FOLLOW_22); | ||
| 3553 | lv_right_3_0=ruleMultiplicativeExpression(); | ||
| 3554 | |||
| 3555 | state._fsp--; | ||
| 3556 | if (state.failed) return current; | ||
| 3557 | if ( state.backtracking==0 ) { | ||
| 3558 | |||
| 3559 | if (current==null) { | ||
| 3560 | current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
| 3561 | } | ||
| 3562 | set( | ||
| 3563 | current, | ||
| 3564 | "right", | ||
| 3565 | lv_right_3_0, | ||
| 3566 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression"); | ||
| 3567 | afterParserOrEnumRuleCall(); | ||
| 3568 | |||
| 3569 | } | ||
| 3570 | |||
| 3571 | } | ||
| 3572 | |||
| 3573 | |||
| 3574 | } | ||
| 3575 | |||
| 3576 | |||
| 3577 | } | ||
| 3578 | break; | ||
| 3579 | |||
| 3580 | default : | ||
| 3581 | break loop15; | ||
| 3582 | } | ||
| 3583 | } while (true); | ||
| 2274 | 3584 | ||
| 2275 | 3585 | ||
| 2276 | } | 3586 | } |
| @@ -2278,9 +3588,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2278 | 3588 | ||
| 2279 | } | 3589 | } |
| 2280 | 3590 | ||
| 3591 | if ( state.backtracking==0 ) { | ||
| 2281 | 3592 | ||
| 2282 | leaveRule(); | 3593 | leaveRule(); |
| 2283 | 3594 | ||
| 3595 | } | ||
| 2284 | } | 3596 | } |
| 2285 | 3597 | ||
| 2286 | catch (RecognitionException re) { | 3598 | catch (RecognitionException re) { |
| @@ -2291,29 +3603,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2291 | } | 3603 | } |
| 2292 | return current; | 3604 | return current; |
| 2293 | } | 3605 | } |
| 2294 | // $ANTLR end "ruleIntegerSymbol" | 3606 | // $ANTLR end "ruleAdditiveExpression" |
| 2295 | 3607 | ||
| 2296 | 3608 | ||
| 2297 | // $ANTLR start "entryRuleRealSymbol" | 3609 | // $ANTLR start "entryRuleMultiplicativeExpression" |
| 2298 | // InternalSolverLanguage.g:786:1: entryRuleRealSymbol returns [EObject current=null] : iv_ruleRealSymbol= ruleRealSymbol EOF ; | 3610 | // InternalSolverLanguage.g:1307:1: entryRuleMultiplicativeExpression returns [EObject current=null] : iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ; |
| 2299 | public final EObject entryRuleRealSymbol() throws RecognitionException { | 3611 | public final EObject entryRuleMultiplicativeExpression() throws RecognitionException { |
| 2300 | EObject current = null; | 3612 | EObject current = null; |
| 2301 | 3613 | ||
| 2302 | EObject iv_ruleRealSymbol = null; | 3614 | EObject iv_ruleMultiplicativeExpression = null; |
| 2303 | 3615 | ||
| 2304 | 3616 | ||
| 2305 | try { | 3617 | try { |
| 2306 | // InternalSolverLanguage.g:786:51: (iv_ruleRealSymbol= ruleRealSymbol EOF ) | 3618 | // InternalSolverLanguage.g:1307:65: (iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ) |
| 2307 | // InternalSolverLanguage.g:787:2: iv_ruleRealSymbol= ruleRealSymbol EOF | 3619 | // InternalSolverLanguage.g:1308:2: iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF |
| 2308 | { | 3620 | { |
| 2309 | newCompositeNode(grammarAccess.getRealSymbolRule()); | 3621 | if ( state.backtracking==0 ) { |
| 3622 | newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); | ||
| 3623 | } | ||
| 2310 | pushFollow(FOLLOW_1); | 3624 | pushFollow(FOLLOW_1); |
| 2311 | iv_ruleRealSymbol=ruleRealSymbol(); | 3625 | iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression(); |
| 2312 | 3626 | ||
| 2313 | state._fsp--; | 3627 | state._fsp--; |
| 2314 | 3628 | if (state.failed) return current; | |
| 2315 | current =iv_ruleRealSymbol; | 3629 | if ( state.backtracking==0 ) { |
| 2316 | match(input,EOF,FOLLOW_2); | 3630 | current =iv_ruleMultiplicativeExpression; |
| 3631 | } | ||
| 3632 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 2317 | 3633 | ||
| 2318 | } | 3634 | } |
| 2319 | 3635 | ||
| @@ -2327,40 +3643,153 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2327 | } | 3643 | } |
| 2328 | return current; | 3644 | return current; |
| 2329 | } | 3645 | } |
| 2330 | // $ANTLR end "entryRuleRealSymbol" | 3646 | // $ANTLR end "entryRuleMultiplicativeExpression" |
| 2331 | 3647 | ||
| 2332 | 3648 | ||
| 2333 | // $ANTLR start "ruleRealSymbol" | 3649 | // $ANTLR start "ruleMultiplicativeExpression" |
| 2334 | // InternalSolverLanguage.g:793:1: ruleRealSymbol returns [EObject current=null] : (otherlv_0= 'real' () ) ; | 3650 | // InternalSolverLanguage.g:1314:1: ruleMultiplicativeExpression returns [EObject current=null] : (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) ; |
| 2335 | public final EObject ruleRealSymbol() throws RecognitionException { | 3651 | public final EObject ruleMultiplicativeExpression() throws RecognitionException { |
| 2336 | EObject current = null; | 3652 | EObject current = null; |
| 2337 | 3653 | ||
| 2338 | Token otherlv_0=null; | 3654 | EObject this_ExponentialExpression_0 = null; |
| 3655 | |||
| 3656 | Enumerator lv_op_2_0 = null; | ||
| 3657 | |||
| 3658 | EObject lv_right_3_0 = null; | ||
| 3659 | |||
| 2339 | 3660 | ||
| 2340 | 3661 | ||
| 2341 | enterRule(); | 3662 | enterRule(); |
| 2342 | 3663 | ||
| 2343 | try { | 3664 | try { |
| 2344 | // InternalSolverLanguage.g:799:2: ( (otherlv_0= 'real' () ) ) | 3665 | // InternalSolverLanguage.g:1320:2: ( (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) ) |
| 2345 | // InternalSolverLanguage.g:800:2: (otherlv_0= 'real' () ) | 3666 | // InternalSolverLanguage.g:1321:2: (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) |
| 2346 | { | 3667 | { |
| 2347 | // InternalSolverLanguage.g:800:2: (otherlv_0= 'real' () ) | 3668 | // InternalSolverLanguage.g:1321:2: (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) |
| 2348 | // InternalSolverLanguage.g:801:3: otherlv_0= 'real' () | 3669 | // InternalSolverLanguage.g:1322:3: this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* |
| 2349 | { | 3670 | { |
| 2350 | otherlv_0=(Token)match(input,25,FOLLOW_2); | 3671 | if ( state.backtracking==0 ) { |
| 2351 | 3672 | ||
| 2352 | newLeafNode(otherlv_0, grammarAccess.getRealSymbolAccess().getRealKeyword_0()); | 3673 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); |
| 2353 | 3674 | ||
| 2354 | // InternalSolverLanguage.g:805:3: () | 3675 | } |
| 2355 | // InternalSolverLanguage.g:806:4: | 3676 | pushFollow(FOLLOW_23); |
| 2356 | { | 3677 | this_ExponentialExpression_0=ruleExponentialExpression(); |
| 2357 | 3678 | ||
| 2358 | current = forceCreateModelElement( | 3679 | state._fsp--; |
| 2359 | grammarAccess.getRealSymbolAccess().getRealSymbolAction_1(), | 3680 | if (state.failed) return current; |
| 2360 | current); | 3681 | if ( state.backtracking==0 ) { |
| 2361 | |||
| 2362 | 3682 | ||
| 3683 | current = this_ExponentialExpression_0; | ||
| 3684 | afterParserOrEnumRuleCall(); | ||
| 3685 | |||
| 2363 | } | 3686 | } |
| 3687 | // InternalSolverLanguage.g:1330:3: ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* | ||
| 3688 | loop16: | ||
| 3689 | do { | ||
| 3690 | int alt16=2; | ||
| 3691 | int LA16_0 = input.LA(1); | ||
| 3692 | |||
| 3693 | if ( (LA16_0==35||LA16_0==58) ) { | ||
| 3694 | alt16=1; | ||
| 3695 | } | ||
| 3696 | |||
| 3697 | |||
| 3698 | switch (alt16) { | ||
| 3699 | case 1 : | ||
| 3700 | // InternalSolverLanguage.g:1331:4: () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) | ||
| 3701 | { | ||
| 3702 | // InternalSolverLanguage.g:1331:4: () | ||
| 3703 | // InternalSolverLanguage.g:1332:5: | ||
| 3704 | { | ||
| 3705 | if ( state.backtracking==0 ) { | ||
| 3706 | |||
| 3707 | current = forceCreateModelElementAndSet( | ||
| 3708 | grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 3709 | current); | ||
| 3710 | |||
| 3711 | } | ||
| 3712 | |||
| 3713 | } | ||
| 3714 | |||
| 3715 | // InternalSolverLanguage.g:1338:4: ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) | ||
| 3716 | // InternalSolverLanguage.g:1339:5: (lv_op_2_0= ruleMultiplicativeBinaryOperator ) | ||
| 3717 | { | ||
| 3718 | // InternalSolverLanguage.g:1339:5: (lv_op_2_0= ruleMultiplicativeBinaryOperator ) | ||
| 3719 | // InternalSolverLanguage.g:1340:6: lv_op_2_0= ruleMultiplicativeBinaryOperator | ||
| 3720 | { | ||
| 3721 | if ( state.backtracking==0 ) { | ||
| 3722 | |||
| 3723 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); | ||
| 3724 | |||
| 3725 | } | ||
| 3726 | pushFollow(FOLLOW_6); | ||
| 3727 | lv_op_2_0=ruleMultiplicativeBinaryOperator(); | ||
| 3728 | |||
| 3729 | state._fsp--; | ||
| 3730 | if (state.failed) return current; | ||
| 3731 | if ( state.backtracking==0 ) { | ||
| 3732 | |||
| 3733 | if (current==null) { | ||
| 3734 | current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
| 3735 | } | ||
| 3736 | set( | ||
| 3737 | current, | ||
| 3738 | "op", | ||
| 3739 | lv_op_2_0, | ||
| 3740 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator"); | ||
| 3741 | afterParserOrEnumRuleCall(); | ||
| 3742 | |||
| 3743 | } | ||
| 3744 | |||
| 3745 | } | ||
| 3746 | |||
| 3747 | |||
| 3748 | } | ||
| 3749 | |||
| 3750 | // InternalSolverLanguage.g:1357:4: ( (lv_right_3_0= ruleExponentialExpression ) ) | ||
| 3751 | // InternalSolverLanguage.g:1358:5: (lv_right_3_0= ruleExponentialExpression ) | ||
| 3752 | { | ||
| 3753 | // InternalSolverLanguage.g:1358:5: (lv_right_3_0= ruleExponentialExpression ) | ||
| 3754 | // InternalSolverLanguage.g:1359:6: lv_right_3_0= ruleExponentialExpression | ||
| 3755 | { | ||
| 3756 | if ( state.backtracking==0 ) { | ||
| 3757 | |||
| 3758 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
| 3759 | |||
| 3760 | } | ||
| 3761 | pushFollow(FOLLOW_23); | ||
| 3762 | lv_right_3_0=ruleExponentialExpression(); | ||
| 3763 | |||
| 3764 | state._fsp--; | ||
| 3765 | if (state.failed) return current; | ||
| 3766 | if ( state.backtracking==0 ) { | ||
| 3767 | |||
| 3768 | if (current==null) { | ||
| 3769 | current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
| 3770 | } | ||
| 3771 | set( | ||
| 3772 | current, | ||
| 3773 | "right", | ||
| 3774 | lv_right_3_0, | ||
| 3775 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
| 3776 | afterParserOrEnumRuleCall(); | ||
| 3777 | |||
| 3778 | } | ||
| 3779 | |||
| 3780 | } | ||
| 3781 | |||
| 3782 | |||
| 3783 | } | ||
| 3784 | |||
| 3785 | |||
| 3786 | } | ||
| 3787 | break; | ||
| 3788 | |||
| 3789 | default : | ||
| 3790 | break loop16; | ||
| 3791 | } | ||
| 3792 | } while (true); | ||
| 2364 | 3793 | ||
| 2365 | 3794 | ||
| 2366 | } | 3795 | } |
| @@ -2368,9 +3797,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2368 | 3797 | ||
| 2369 | } | 3798 | } |
| 2370 | 3799 | ||
| 3800 | if ( state.backtracking==0 ) { | ||
| 2371 | 3801 | ||
| 2372 | leaveRule(); | 3802 | leaveRule(); |
| 2373 | 3803 | ||
| 3804 | } | ||
| 2374 | } | 3805 | } |
| 2375 | 3806 | ||
| 2376 | catch (RecognitionException re) { | 3807 | catch (RecognitionException re) { |
| @@ -2381,29 +3812,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2381 | } | 3812 | } |
| 2382 | return current; | 3813 | return current; |
| 2383 | } | 3814 | } |
| 2384 | // $ANTLR end "ruleRealSymbol" | 3815 | // $ANTLR end "ruleMultiplicativeExpression" |
| 2385 | 3816 | ||
| 2386 | 3817 | ||
| 2387 | // $ANTLR start "entryRuleStringSymbol" | 3818 | // $ANTLR start "entryRuleExponentialExpression" |
| 2388 | // InternalSolverLanguage.g:816:1: entryRuleStringSymbol returns [EObject current=null] : iv_ruleStringSymbol= ruleStringSymbol EOF ; | 3819 | // InternalSolverLanguage.g:1381:1: entryRuleExponentialExpression returns [EObject current=null] : iv_ruleExponentialExpression= ruleExponentialExpression EOF ; |
| 2389 | public final EObject entryRuleStringSymbol() throws RecognitionException { | 3820 | public final EObject entryRuleExponentialExpression() throws RecognitionException { |
| 2390 | EObject current = null; | 3821 | EObject current = null; |
| 2391 | 3822 | ||
| 2392 | EObject iv_ruleStringSymbol = null; | 3823 | EObject iv_ruleExponentialExpression = null; |
| 2393 | 3824 | ||
| 2394 | 3825 | ||
| 2395 | try { | 3826 | try { |
| 2396 | // InternalSolverLanguage.g:816:53: (iv_ruleStringSymbol= ruleStringSymbol EOF ) | 3827 | // InternalSolverLanguage.g:1381:62: (iv_ruleExponentialExpression= ruleExponentialExpression EOF ) |
| 2397 | // InternalSolverLanguage.g:817:2: iv_ruleStringSymbol= ruleStringSymbol EOF | 3828 | // InternalSolverLanguage.g:1382:2: iv_ruleExponentialExpression= ruleExponentialExpression EOF |
| 2398 | { | 3829 | { |
| 2399 | newCompositeNode(grammarAccess.getStringSymbolRule()); | 3830 | if ( state.backtracking==0 ) { |
| 3831 | newCompositeNode(grammarAccess.getExponentialExpressionRule()); | ||
| 3832 | } | ||
| 2400 | pushFollow(FOLLOW_1); | 3833 | pushFollow(FOLLOW_1); |
| 2401 | iv_ruleStringSymbol=ruleStringSymbol(); | 3834 | iv_ruleExponentialExpression=ruleExponentialExpression(); |
| 2402 | 3835 | ||
| 2403 | state._fsp--; | 3836 | state._fsp--; |
| 2404 | 3837 | if (state.failed) return current; | |
| 2405 | current =iv_ruleStringSymbol; | 3838 | if ( state.backtracking==0 ) { |
| 2406 | match(input,EOF,FOLLOW_2); | 3839 | current =iv_ruleExponentialExpression; |
| 3840 | } | ||
| 3841 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 2407 | 3842 | ||
| 2408 | } | 3843 | } |
| 2409 | 3844 | ||
| @@ -2417,38 +3852,144 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2417 | } | 3852 | } |
| 2418 | return current; | 3853 | return current; |
| 2419 | } | 3854 | } |
| 2420 | // $ANTLR end "entryRuleStringSymbol" | 3855 | // $ANTLR end "entryRuleExponentialExpression" |
| 2421 | 3856 | ||
| 2422 | 3857 | ||
| 2423 | // $ANTLR start "ruleStringSymbol" | 3858 | // $ANTLR start "ruleExponentialExpression" |
| 2424 | // InternalSolverLanguage.g:823:1: ruleStringSymbol returns [EObject current=null] : (otherlv_0= 'string' () ) ; | 3859 | // InternalSolverLanguage.g:1388:1: ruleExponentialExpression returns [EObject current=null] : (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) ; |
| 2425 | public final EObject ruleStringSymbol() throws RecognitionException { | 3860 | public final EObject ruleExponentialExpression() throws RecognitionException { |
| 2426 | EObject current = null; | 3861 | EObject current = null; |
| 2427 | 3862 | ||
| 2428 | Token otherlv_0=null; | 3863 | EObject this_UnaryExpression_0 = null; |
| 3864 | |||
| 3865 | Enumerator lv_op_2_0 = null; | ||
| 3866 | |||
| 3867 | EObject lv_right_3_0 = null; | ||
| 3868 | |||
| 2429 | 3869 | ||
| 2430 | 3870 | ||
| 2431 | enterRule(); | 3871 | enterRule(); |
| 2432 | 3872 | ||
| 2433 | try { | 3873 | try { |
| 2434 | // InternalSolverLanguage.g:829:2: ( (otherlv_0= 'string' () ) ) | 3874 | // InternalSolverLanguage.g:1394:2: ( (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) ) |
| 2435 | // InternalSolverLanguage.g:830:2: (otherlv_0= 'string' () ) | 3875 | // InternalSolverLanguage.g:1395:2: (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) |
| 2436 | { | 3876 | { |
| 2437 | // InternalSolverLanguage.g:830:2: (otherlv_0= 'string' () ) | 3877 | // InternalSolverLanguage.g:1395:2: (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) |
| 2438 | // InternalSolverLanguage.g:831:3: otherlv_0= 'string' () | 3878 | // InternalSolverLanguage.g:1396:3: this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? |
| 2439 | { | 3879 | { |
| 2440 | otherlv_0=(Token)match(input,26,FOLLOW_2); | 3880 | if ( state.backtracking==0 ) { |
| 2441 | 3881 | ||
| 2442 | newLeafNode(otherlv_0, grammarAccess.getStringSymbolAccess().getStringKeyword_0()); | 3882 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); |
| 2443 | 3883 | ||
| 2444 | // InternalSolverLanguage.g:835:3: () | 3884 | } |
| 2445 | // InternalSolverLanguage.g:836:4: | 3885 | pushFollow(FOLLOW_24); |
| 2446 | { | 3886 | this_UnaryExpression_0=ruleUnaryExpression(); |
| 3887 | |||
| 3888 | state._fsp--; | ||
| 3889 | if (state.failed) return current; | ||
| 3890 | if ( state.backtracking==0 ) { | ||
| 3891 | |||
| 3892 | current = this_UnaryExpression_0; | ||
| 3893 | afterParserOrEnumRuleCall(); | ||
| 3894 | |||
| 3895 | } | ||
| 3896 | // InternalSolverLanguage.g:1404:3: ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? | ||
| 3897 | int alt17=2; | ||
| 3898 | int LA17_0 = input.LA(1); | ||
| 3899 | |||
| 3900 | if ( (LA17_0==59) ) { | ||
| 3901 | alt17=1; | ||
| 3902 | } | ||
| 3903 | switch (alt17) { | ||
| 3904 | case 1 : | ||
| 3905 | // InternalSolverLanguage.g:1405:4: () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) | ||
| 3906 | { | ||
| 3907 | // InternalSolverLanguage.g:1405:4: () | ||
| 3908 | // InternalSolverLanguage.g:1406:5: | ||
| 3909 | { | ||
| 3910 | if ( state.backtracking==0 ) { | ||
| 3911 | |||
| 3912 | current = forceCreateModelElementAndSet( | ||
| 3913 | grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 3914 | current); | ||
| 3915 | |||
| 3916 | } | ||
| 3917 | |||
| 3918 | } | ||
| 3919 | |||
| 3920 | // InternalSolverLanguage.g:1412:4: ( (lv_op_2_0= ruleExponentialOp ) ) | ||
| 3921 | // InternalSolverLanguage.g:1413:5: (lv_op_2_0= ruleExponentialOp ) | ||
| 3922 | { | ||
| 3923 | // InternalSolverLanguage.g:1413:5: (lv_op_2_0= ruleExponentialOp ) | ||
| 3924 | // InternalSolverLanguage.g:1414:6: lv_op_2_0= ruleExponentialOp | ||
| 3925 | { | ||
| 3926 | if ( state.backtracking==0 ) { | ||
| 3927 | |||
| 3928 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); | ||
| 3929 | |||
| 3930 | } | ||
| 3931 | pushFollow(FOLLOW_6); | ||
| 3932 | lv_op_2_0=ruleExponentialOp(); | ||
| 3933 | |||
| 3934 | state._fsp--; | ||
| 3935 | if (state.failed) return current; | ||
| 3936 | if ( state.backtracking==0 ) { | ||
| 3937 | |||
| 3938 | if (current==null) { | ||
| 3939 | current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
| 3940 | } | ||
| 3941 | set( | ||
| 3942 | current, | ||
| 3943 | "op", | ||
| 3944 | lv_op_2_0, | ||
| 3945 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp"); | ||
| 3946 | afterParserOrEnumRuleCall(); | ||
| 3947 | |||
| 3948 | } | ||
| 3949 | |||
| 3950 | } | ||
| 3951 | |||
| 3952 | |||
| 3953 | } | ||
| 3954 | |||
| 3955 | // InternalSolverLanguage.g:1431:4: ( (lv_right_3_0= ruleExponentialExpression ) ) | ||
| 3956 | // InternalSolverLanguage.g:1432:5: (lv_right_3_0= ruleExponentialExpression ) | ||
| 3957 | { | ||
| 3958 | // InternalSolverLanguage.g:1432:5: (lv_right_3_0= ruleExponentialExpression ) | ||
| 3959 | // InternalSolverLanguage.g:1433:6: lv_right_3_0= ruleExponentialExpression | ||
| 3960 | { | ||
| 3961 | if ( state.backtracking==0 ) { | ||
| 3962 | |||
| 3963 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
| 3964 | |||
| 3965 | } | ||
| 3966 | pushFollow(FOLLOW_2); | ||
| 3967 | lv_right_3_0=ruleExponentialExpression(); | ||
| 3968 | |||
| 3969 | state._fsp--; | ||
| 3970 | if (state.failed) return current; | ||
| 3971 | if ( state.backtracking==0 ) { | ||
| 3972 | |||
| 3973 | if (current==null) { | ||
| 3974 | current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
| 3975 | } | ||
| 3976 | set( | ||
| 3977 | current, | ||
| 3978 | "right", | ||
| 3979 | lv_right_3_0, | ||
| 3980 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
| 3981 | afterParserOrEnumRuleCall(); | ||
| 3982 | |||
| 3983 | } | ||
| 3984 | |||
| 3985 | } | ||
| 3986 | |||
| 3987 | |||
| 3988 | } | ||
| 2447 | 3989 | ||
| 2448 | current = forceCreateModelElement( | 3990 | |
| 2449 | grammarAccess.getStringSymbolAccess().getStringSymbolAction_1(), | 3991 | } |
| 2450 | current); | 3992 | break; |
| 2451 | |||
| 2452 | 3993 | ||
| 2453 | } | 3994 | } |
| 2454 | 3995 | ||
| @@ -2458,9 +3999,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2458 | 3999 | ||
| 2459 | } | 4000 | } |
| 2460 | 4001 | ||
| 4002 | if ( state.backtracking==0 ) { | ||
| 2461 | 4003 | ||
| 2462 | leaveRule(); | 4004 | leaveRule(); |
| 2463 | 4005 | ||
| 4006 | } | ||
| 2464 | } | 4007 | } |
| 2465 | 4008 | ||
| 2466 | catch (RecognitionException re) { | 4009 | catch (RecognitionException re) { |
| @@ -2471,29 +4014,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2471 | } | 4014 | } |
| 2472 | return current; | 4015 | return current; |
| 2473 | } | 4016 | } |
| 2474 | // $ANTLR end "ruleStringSymbol" | 4017 | // $ANTLR end "ruleExponentialExpression" |
| 2475 | 4018 | ||
| 2476 | 4019 | ||
| 2477 | // $ANTLR start "entryRuleComplexObject" | 4020 | // $ANTLR start "entryRuleUnaryExpression" |
| 2478 | // InternalSolverLanguage.g:846:1: entryRuleComplexObject returns [EObject current=null] : iv_ruleComplexObject= ruleComplexObject EOF ; | 4021 | // InternalSolverLanguage.g:1455:1: entryRuleUnaryExpression returns [EObject current=null] : iv_ruleUnaryExpression= ruleUnaryExpression EOF ; |
| 2479 | public final EObject entryRuleComplexObject() throws RecognitionException { | 4022 | public final EObject entryRuleUnaryExpression() throws RecognitionException { |
| 2480 | EObject current = null; | 4023 | EObject current = null; |
| 2481 | 4024 | ||
| 2482 | EObject iv_ruleComplexObject = null; | 4025 | EObject iv_ruleUnaryExpression = null; |
| 2483 | 4026 | ||
| 2484 | 4027 | ||
| 2485 | try { | 4028 | try { |
| 2486 | // InternalSolverLanguage.g:846:54: (iv_ruleComplexObject= ruleComplexObject EOF ) | 4029 | // InternalSolverLanguage.g:1455:56: (iv_ruleUnaryExpression= ruleUnaryExpression EOF ) |
| 2487 | // InternalSolverLanguage.g:847:2: iv_ruleComplexObject= ruleComplexObject EOF | 4030 | // InternalSolverLanguage.g:1456:2: iv_ruleUnaryExpression= ruleUnaryExpression EOF |
| 2488 | { | 4031 | { |
| 2489 | newCompositeNode(grammarAccess.getComplexObjectRule()); | 4032 | if ( state.backtracking==0 ) { |
| 4033 | newCompositeNode(grammarAccess.getUnaryExpressionRule()); | ||
| 4034 | } | ||
| 2490 | pushFollow(FOLLOW_1); | 4035 | pushFollow(FOLLOW_1); |
| 2491 | iv_ruleComplexObject=ruleComplexObject(); | 4036 | iv_ruleUnaryExpression=ruleUnaryExpression(); |
| 2492 | 4037 | ||
| 2493 | state._fsp--; | 4038 | state._fsp--; |
| 2494 | 4039 | if (state.failed) return current; | |
| 2495 | current =iv_ruleComplexObject; | 4040 | if ( state.backtracking==0 ) { |
| 2496 | match(input,EOF,FOLLOW_2); | 4041 | current =iv_ruleUnaryExpression; |
| 4042 | } | ||
| 4043 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 2497 | 4044 | ||
| 2498 | } | 4045 | } |
| 2499 | 4046 | ||
| @@ -2507,111 +4054,160 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2507 | } | 4054 | } |
| 2508 | return current; | 4055 | return current; |
| 2509 | } | 4056 | } |
| 2510 | // $ANTLR end "entryRuleComplexObject" | 4057 | // $ANTLR end "entryRuleUnaryExpression" |
| 2511 | 4058 | ||
| 2512 | 4059 | ||
| 2513 | // $ANTLR start "ruleComplexObject" | 4060 | // $ANTLR start "ruleUnaryExpression" |
| 2514 | // InternalSolverLanguage.g:853:1: ruleComplexObject returns [EObject current=null] : (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) ; | 4061 | // InternalSolverLanguage.g:1462:1: ruleUnaryExpression returns [EObject current=null] : (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) ; |
| 2515 | public final EObject ruleComplexObject() throws RecognitionException { | 4062 | public final EObject ruleUnaryExpression() throws RecognitionException { |
| 2516 | EObject current = null; | 4063 | EObject current = null; |
| 2517 | 4064 | ||
| 2518 | EObject this_Object_0 = null; | 4065 | EObject this_AggregationExpression_0 = null; |
| 2519 | 4066 | ||
| 2520 | EObject this_AllInstances_1 = null; | 4067 | Enumerator lv_op_2_0 = null; |
| 2521 | 4068 | ||
| 2522 | EObject this_AllObjects_2 = null; | 4069 | EObject lv_body_3_0 = null; |
| 2523 | 4070 | ||
| 2524 | 4071 | ||
| 2525 | 4072 | ||
| 2526 | enterRule(); | 4073 | enterRule(); |
| 2527 | 4074 | ||
| 2528 | try { | 4075 | try { |
| 2529 | // InternalSolverLanguage.g:859:2: ( (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) ) | 4076 | // InternalSolverLanguage.g:1468:2: ( (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) ) |
| 2530 | // InternalSolverLanguage.g:860:2: (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) | 4077 | // InternalSolverLanguage.g:1469:2: (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) |
| 2531 | { | 4078 | { |
| 2532 | // InternalSolverLanguage.g:860:2: (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) | 4079 | // InternalSolverLanguage.g:1469:2: (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) |
| 2533 | int alt14=3; | 4080 | int alt18=2; |
| 2534 | switch ( input.LA(1) ) { | 4081 | int LA18_0 = input.LA(1); |
| 2535 | case RULE_INT: | 4082 | |
| 2536 | case RULE_ID: | 4083 | if ( ((LA18_0>=RULE_STRING && LA18_0<=RULE_QUOTED_ID)||LA18_0==19||LA18_0==29||LA18_0==33||LA18_0==36||(LA18_0>=39 && LA18_0<=40)||(LA18_0>=64 && LA18_0<=72)) ) { |
| 2537 | case RULE_STRING: | 4084 | alt18=1; |
| 2538 | case 11: | 4085 | } |
| 2539 | case 13: | 4086 | else if ( ((LA18_0>=56 && LA18_0<=57)||(LA18_0>=60 && LA18_0<=63)) ) { |
| 2540 | case 14: | 4087 | alt18=2; |
| 2541 | case 27: | 4088 | } |
| 2542 | { | 4089 | else { |
| 2543 | alt14=1; | 4090 | if (state.backtracking>0) {state.failed=true; return current;} |
| 2544 | } | ||
| 2545 | break; | ||
| 2546 | case 20: | ||
| 2547 | { | ||
| 2548 | alt14=2; | ||
| 2549 | } | ||
| 2550 | break; | ||
| 2551 | case 31: | ||
| 2552 | { | ||
| 2553 | alt14=3; | ||
| 2554 | } | ||
| 2555 | break; | ||
| 2556 | default: | ||
| 2557 | NoViableAltException nvae = | 4091 | NoViableAltException nvae = |
| 2558 | new NoViableAltException("", 14, 0, input); | 4092 | new NoViableAltException("", 18, 0, input); |
| 2559 | 4093 | ||
| 2560 | throw nvae; | 4094 | throw nvae; |
| 2561 | } | 4095 | } |
| 2562 | 4096 | switch (alt18) { | |
| 2563 | switch (alt14) { | ||
| 2564 | case 1 : | 4097 | case 1 : |
| 2565 | // InternalSolverLanguage.g:861:3: this_Object_0= ruleObject | 4098 | // InternalSolverLanguage.g:1470:3: this_AggregationExpression_0= ruleAggregationExpression |
| 2566 | { | 4099 | { |
| 4100 | if ( state.backtracking==0 ) { | ||
| 2567 | 4101 | ||
| 2568 | newCompositeNode(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); | 4102 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); |
| 2569 | 4103 | ||
| 4104 | } | ||
| 2570 | pushFollow(FOLLOW_2); | 4105 | pushFollow(FOLLOW_2); |
| 2571 | this_Object_0=ruleObject(); | 4106 | this_AggregationExpression_0=ruleAggregationExpression(); |
| 2572 | 4107 | ||
| 2573 | state._fsp--; | 4108 | state._fsp--; |
| 4109 | if (state.failed) return current; | ||
| 4110 | if ( state.backtracking==0 ) { | ||
| 2574 | 4111 | ||
| 2575 | 4112 | current = this_AggregationExpression_0; | |
| 2576 | current = this_Object_0; | 4113 | afterParserOrEnumRuleCall(); |
| 2577 | afterParserOrEnumRuleCall(); | 4114 | |
| 2578 | 4115 | } | |
| 2579 | 4116 | ||
| 2580 | } | 4117 | } |
| 2581 | break; | 4118 | break; |
| 2582 | case 2 : | 4119 | case 2 : |
| 2583 | // InternalSolverLanguage.g:870:3: this_AllInstances_1= ruleAllInstances | 4120 | // InternalSolverLanguage.g:1479:3: ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) |
| 4121 | { | ||
| 4122 | // InternalSolverLanguage.g:1479:3: ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) | ||
| 4123 | // InternalSolverLanguage.g:1480:4: () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) | ||
| 2584 | { | 4124 | { |
| 4125 | // InternalSolverLanguage.g:1480:4: () | ||
| 4126 | // InternalSolverLanguage.g:1481:5: | ||
| 4127 | { | ||
| 4128 | if ( state.backtracking==0 ) { | ||
| 2585 | 4129 | ||
| 2586 | newCompositeNode(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); | 4130 | current = forceCreateModelElement( |
| 2587 | 4131 | grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0(), | |
| 2588 | pushFollow(FOLLOW_2); | 4132 | current); |
| 2589 | this_AllInstances_1=ruleAllInstances(); | 4133 | |
| 4134 | } | ||
| 4135 | |||
| 4136 | } | ||
| 4137 | |||
| 4138 | // InternalSolverLanguage.g:1487:4: ( (lv_op_2_0= ruleUnaryOp ) ) | ||
| 4139 | // InternalSolverLanguage.g:1488:5: (lv_op_2_0= ruleUnaryOp ) | ||
| 4140 | { | ||
| 4141 | // InternalSolverLanguage.g:1488:5: (lv_op_2_0= ruleUnaryOp ) | ||
| 4142 | // InternalSolverLanguage.g:1489:6: lv_op_2_0= ruleUnaryOp | ||
| 4143 | { | ||
| 4144 | if ( state.backtracking==0 ) { | ||
| 4145 | |||
| 4146 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); | ||
| 4147 | |||
| 4148 | } | ||
| 4149 | pushFollow(FOLLOW_25); | ||
| 4150 | lv_op_2_0=ruleUnaryOp(); | ||
| 2590 | 4151 | ||
| 2591 | state._fsp--; | 4152 | state._fsp--; |
| 4153 | if (state.failed) return current; | ||
| 4154 | if ( state.backtracking==0 ) { | ||
| 4155 | |||
| 4156 | if (current==null) { | ||
| 4157 | current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | ||
| 4158 | } | ||
| 4159 | set( | ||
| 4160 | current, | ||
| 4161 | "op", | ||
| 4162 | lv_op_2_0, | ||
| 4163 | "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOp"); | ||
| 4164 | afterParserOrEnumRuleCall(); | ||
| 4165 | |||
| 4166 | } | ||
| 2592 | 4167 | ||
| 4168 | } | ||
| 2593 | 4169 | ||
| 2594 | current = this_AllInstances_1; | ||
| 2595 | afterParserOrEnumRuleCall(); | ||
| 2596 | |||
| 2597 | 4170 | ||
| 2598 | } | 4171 | } |
| 2599 | break; | 4172 | |
| 2600 | case 3 : | 4173 | // InternalSolverLanguage.g:1506:4: ( (lv_body_3_0= ruleAggregationExpression ) ) |
| 2601 | // InternalSolverLanguage.g:879:3: this_AllObjects_2= ruleAllObjects | 4174 | // InternalSolverLanguage.g:1507:5: (lv_body_3_0= ruleAggregationExpression ) |
| 2602 | { | 4175 | { |
| 4176 | // InternalSolverLanguage.g:1507:5: (lv_body_3_0= ruleAggregationExpression ) | ||
| 4177 | // InternalSolverLanguage.g:1508:6: lv_body_3_0= ruleAggregationExpression | ||
| 4178 | { | ||
| 4179 | if ( state.backtracking==0 ) { | ||
| 2603 | 4180 | ||
| 2604 | newCompositeNode(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); | 4181 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); |
| 2605 | 4182 | ||
| 4183 | } | ||
| 2606 | pushFollow(FOLLOW_2); | 4184 | pushFollow(FOLLOW_2); |
| 2607 | this_AllObjects_2=ruleAllObjects(); | 4185 | lv_body_3_0=ruleAggregationExpression(); |
| 2608 | 4186 | ||
| 2609 | state._fsp--; | 4187 | state._fsp--; |
| 4188 | if (state.failed) return current; | ||
| 4189 | if ( state.backtracking==0 ) { | ||
| 4190 | |||
| 4191 | if (current==null) { | ||
| 4192 | current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | ||
| 4193 | } | ||
| 4194 | set( | ||
| 4195 | current, | ||
| 4196 | "body", | ||
| 4197 | lv_body_3_0, | ||
| 4198 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationExpression"); | ||
| 4199 | afterParserOrEnumRuleCall(); | ||
| 4200 | |||
| 4201 | } | ||
| 2610 | 4202 | ||
| 4203 | } | ||
| 4204 | |||
| 4205 | |||
| 4206 | } | ||
| 4207 | |||
| 4208 | |||
| 4209 | } | ||
| 2611 | 4210 | ||
| 2612 | current = this_AllObjects_2; | ||
| 2613 | afterParserOrEnumRuleCall(); | ||
| 2614 | |||
| 2615 | 4211 | ||
| 2616 | } | 4212 | } |
| 2617 | break; | 4213 | break; |
| @@ -2621,9 +4217,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2621 | 4217 | ||
| 2622 | } | 4218 | } |
| 2623 | 4219 | ||
| 4220 | if ( state.backtracking==0 ) { | ||
| 2624 | 4221 | ||
| 2625 | leaveRule(); | 4222 | leaveRule(); |
| 2626 | 4223 | ||
| 4224 | } | ||
| 2627 | } | 4225 | } |
| 2628 | 4226 | ||
| 2629 | catch (RecognitionException re) { | 4227 | catch (RecognitionException re) { |
| @@ -2634,29 +4232,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2634 | } | 4232 | } |
| 2635 | return current; | 4233 | return current; |
| 2636 | } | 4234 | } |
| 2637 | // $ANTLR end "ruleComplexObject" | 4235 | // $ANTLR end "ruleUnaryExpression" |
| 2638 | 4236 | ||
| 2639 | 4237 | ||
| 2640 | // $ANTLR start "entryRuleObject" | 4238 | // $ANTLR start "entryRuleAggregationExpression" |
| 2641 | // InternalSolverLanguage.g:891:1: entryRuleObject returns [EObject current=null] : iv_ruleObject= ruleObject EOF ; | 4239 | // InternalSolverLanguage.g:1530:1: entryRuleAggregationExpression returns [EObject current=null] : iv_ruleAggregationExpression= ruleAggregationExpression EOF ; |
| 2642 | public final EObject entryRuleObject() throws RecognitionException { | 4240 | public final EObject entryRuleAggregationExpression() throws RecognitionException { |
| 2643 | EObject current = null; | 4241 | EObject current = null; |
| 2644 | 4242 | ||
| 2645 | EObject iv_ruleObject = null; | 4243 | EObject iv_ruleAggregationExpression = null; |
| 2646 | 4244 | ||
| 2647 | 4245 | ||
| 2648 | try { | 4246 | try { |
| 2649 | // InternalSolverLanguage.g:891:47: (iv_ruleObject= ruleObject EOF ) | 4247 | // InternalSolverLanguage.g:1530:62: (iv_ruleAggregationExpression= ruleAggregationExpression EOF ) |
| 2650 | // InternalSolverLanguage.g:892:2: iv_ruleObject= ruleObject EOF | 4248 | // InternalSolverLanguage.g:1531:2: iv_ruleAggregationExpression= ruleAggregationExpression EOF |
| 2651 | { | 4249 | { |
| 2652 | newCompositeNode(grammarAccess.getObjectRule()); | 4250 | if ( state.backtracking==0 ) { |
| 4251 | newCompositeNode(grammarAccess.getAggregationExpressionRule()); | ||
| 4252 | } | ||
| 2653 | pushFollow(FOLLOW_1); | 4253 | pushFollow(FOLLOW_1); |
| 2654 | iv_ruleObject=ruleObject(); | 4254 | iv_ruleAggregationExpression=ruleAggregationExpression(); |
| 2655 | 4255 | ||
| 2656 | state._fsp--; | 4256 | state._fsp--; |
| 2657 | 4257 | if (state.failed) return current; | |
| 2658 | current =iv_ruleObject; | 4258 | if ( state.backtracking==0 ) { |
| 2659 | match(input,EOF,FOLLOW_2); | 4259 | current =iv_ruleAggregationExpression; |
| 4260 | } | ||
| 4261 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 2660 | 4262 | ||
| 2661 | } | 4263 | } |
| 2662 | 4264 | ||
| @@ -2670,109 +4272,134 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2670 | } | 4272 | } |
| 2671 | return current; | 4273 | return current; |
| 2672 | } | 4274 | } |
| 2673 | // $ANTLR end "entryRuleObject" | 4275 | // $ANTLR end "entryRuleAggregationExpression" |
| 2674 | 4276 | ||
| 2675 | 4277 | ||
| 2676 | // $ANTLR start "ruleObject" | 4278 | // $ANTLR start "ruleAggregationExpression" |
| 2677 | // InternalSolverLanguage.g:898:1: ruleObject returns [EObject current=null] : (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) ; | 4279 | // InternalSolverLanguage.g:1537:1: ruleAggregationExpression returns [EObject current=null] : (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) ; |
| 2678 | public final EObject ruleObject() throws RecognitionException { | 4280 | public final EObject ruleAggregationExpression() throws RecognitionException { |
| 2679 | EObject current = null; | 4281 | EObject current = null; |
| 2680 | 4282 | ||
| 2681 | EObject this_NamedObject_0 = null; | 4283 | EObject this_AtomicExpression_0 = null; |
| 2682 | 4284 | ||
| 2683 | EObject this_UnnamedObject_1 = null; | 4285 | EObject this_Count_1 = null; |
| 2684 | 4286 | ||
| 2685 | EObject this_DataObject_2 = null; | 4287 | EObject this_Aggregation_2 = null; |
| 2686 | 4288 | ||
| 2687 | 4289 | ||
| 2688 | 4290 | ||
| 2689 | enterRule(); | 4291 | enterRule(); |
| 2690 | 4292 | ||
| 2691 | try { | 4293 | try { |
| 2692 | // InternalSolverLanguage.g:904:2: ( (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) ) | 4294 | // InternalSolverLanguage.g:1543:2: ( (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) ) |
| 2693 | // InternalSolverLanguage.g:905:2: (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) | 4295 | // InternalSolverLanguage.g:1544:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) |
| 2694 | { | 4296 | { |
| 2695 | // InternalSolverLanguage.g:905:2: (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) | 4297 | // InternalSolverLanguage.g:1544:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) |
| 2696 | int alt15=3; | 4298 | int alt19=3; |
| 2697 | switch ( input.LA(1) ) { | 4299 | switch ( input.LA(1) ) { |
| 2698 | case 27: | 4300 | case RULE_STRING: |
| 4301 | case RULE_ID: | ||
| 4302 | case RULE_INT: | ||
| 4303 | case RULE_QUOTED_ID: | ||
| 4304 | case 19: | ||
| 4305 | case 33: | ||
| 4306 | case 36: | ||
| 4307 | case 39: | ||
| 4308 | case 40: | ||
| 4309 | case 70: | ||
| 4310 | case 71: | ||
| 4311 | case 72: | ||
| 2699 | { | 4312 | { |
| 2700 | alt15=1; | 4313 | alt19=1; |
| 2701 | } | 4314 | } |
| 2702 | break; | 4315 | break; |
| 2703 | case RULE_ID: | 4316 | case 29: |
| 2704 | { | 4317 | { |
| 2705 | alt15=2; | 4318 | alt19=2; |
| 2706 | } | 4319 | } |
| 2707 | break; | 4320 | break; |
| 2708 | case RULE_INT: | 4321 | case 64: |
| 2709 | case RULE_STRING: | 4322 | case 65: |
| 2710 | case 11: | 4323 | case 66: |
| 2711 | case 13: | 4324 | case 67: |
| 2712 | case 14: | 4325 | case 68: |
| 4326 | case 69: | ||
| 2713 | { | 4327 | { |
| 2714 | alt15=3; | 4328 | alt19=3; |
| 2715 | } | 4329 | } |
| 2716 | break; | 4330 | break; |
| 2717 | default: | 4331 | default: |
| 4332 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 2718 | NoViableAltException nvae = | 4333 | NoViableAltException nvae = |
| 2719 | new NoViableAltException("", 15, 0, input); | 4334 | new NoViableAltException("", 19, 0, input); |
| 2720 | 4335 | ||
| 2721 | throw nvae; | 4336 | throw nvae; |
| 2722 | } | 4337 | } |
| 2723 | 4338 | ||
| 2724 | switch (alt15) { | 4339 | switch (alt19) { |
| 2725 | case 1 : | 4340 | case 1 : |
| 2726 | // InternalSolverLanguage.g:906:3: this_NamedObject_0= ruleNamedObject | 4341 | // InternalSolverLanguage.g:1545:3: this_AtomicExpression_0= ruleAtomicExpression |
| 2727 | { | 4342 | { |
| 4343 | if ( state.backtracking==0 ) { | ||
| 2728 | 4344 | ||
| 2729 | newCompositeNode(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); | 4345 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); |
| 2730 | 4346 | ||
| 4347 | } | ||
| 2731 | pushFollow(FOLLOW_2); | 4348 | pushFollow(FOLLOW_2); |
| 2732 | this_NamedObject_0=ruleNamedObject(); | 4349 | this_AtomicExpression_0=ruleAtomicExpression(); |
| 2733 | 4350 | ||
| 2734 | state._fsp--; | 4351 | state._fsp--; |
| 4352 | if (state.failed) return current; | ||
| 4353 | if ( state.backtracking==0 ) { | ||
| 2735 | 4354 | ||
| 2736 | 4355 | current = this_AtomicExpression_0; | |
| 2737 | current = this_NamedObject_0; | 4356 | afterParserOrEnumRuleCall(); |
| 2738 | afterParserOrEnumRuleCall(); | 4357 | |
| 2739 | 4358 | } | |
| 2740 | 4359 | ||
| 2741 | } | 4360 | } |
| 2742 | break; | 4361 | break; |
| 2743 | case 2 : | 4362 | case 2 : |
| 2744 | // InternalSolverLanguage.g:915:3: this_UnnamedObject_1= ruleUnnamedObject | 4363 | // InternalSolverLanguage.g:1554:3: this_Count_1= ruleCount |
| 2745 | { | 4364 | { |
| 4365 | if ( state.backtracking==0 ) { | ||
| 2746 | 4366 | ||
| 2747 | newCompositeNode(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); | 4367 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); |
| 2748 | 4368 | ||
| 4369 | } | ||
| 2749 | pushFollow(FOLLOW_2); | 4370 | pushFollow(FOLLOW_2); |
| 2750 | this_UnnamedObject_1=ruleUnnamedObject(); | 4371 | this_Count_1=ruleCount(); |
| 2751 | 4372 | ||
| 2752 | state._fsp--; | 4373 | state._fsp--; |
| 4374 | if (state.failed) return current; | ||
| 4375 | if ( state.backtracking==0 ) { | ||
| 2753 | 4376 | ||
| 2754 | 4377 | current = this_Count_1; | |
| 2755 | current = this_UnnamedObject_1; | 4378 | afterParserOrEnumRuleCall(); |
| 2756 | afterParserOrEnumRuleCall(); | 4379 | |
| 2757 | 4380 | } | |
| 2758 | 4381 | ||
| 2759 | } | 4382 | } |
| 2760 | break; | 4383 | break; |
| 2761 | case 3 : | 4384 | case 3 : |
| 2762 | // InternalSolverLanguage.g:924:3: this_DataObject_2= ruleDataObject | 4385 | // InternalSolverLanguage.g:1563:3: this_Aggregation_2= ruleAggregation |
| 2763 | { | 4386 | { |
| 4387 | if ( state.backtracking==0 ) { | ||
| 2764 | 4388 | ||
| 2765 | newCompositeNode(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); | 4389 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); |
| 2766 | 4390 | ||
| 4391 | } | ||
| 2767 | pushFollow(FOLLOW_2); | 4392 | pushFollow(FOLLOW_2); |
| 2768 | this_DataObject_2=ruleDataObject(); | 4393 | this_Aggregation_2=ruleAggregation(); |
| 2769 | 4394 | ||
| 2770 | state._fsp--; | 4395 | state._fsp--; |
| 4396 | if (state.failed) return current; | ||
| 4397 | if ( state.backtracking==0 ) { | ||
| 2771 | 4398 | ||
| 2772 | 4399 | current = this_Aggregation_2; | |
| 2773 | current = this_DataObject_2; | 4400 | afterParserOrEnumRuleCall(); |
| 2774 | afterParserOrEnumRuleCall(); | 4401 | |
| 2775 | 4402 | } | |
| 2776 | 4403 | ||
| 2777 | } | 4404 | } |
| 2778 | break; | 4405 | break; |
| @@ -2782,9 +4409,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2782 | 4409 | ||
| 2783 | } | 4410 | } |
| 2784 | 4411 | ||
| 4412 | if ( state.backtracking==0 ) { | ||
| 2785 | 4413 | ||
| 2786 | leaveRule(); | 4414 | leaveRule(); |
| 2787 | 4415 | ||
| 4416 | } | ||
| 2788 | } | 4417 | } |
| 2789 | 4418 | ||
| 2790 | catch (RecognitionException re) { | 4419 | catch (RecognitionException re) { |
| @@ -2795,29 +4424,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2795 | } | 4424 | } |
| 2796 | return current; | 4425 | return current; |
| 2797 | } | 4426 | } |
| 2798 | // $ANTLR end "ruleObject" | 4427 | // $ANTLR end "ruleAggregationExpression" |
| 2799 | 4428 | ||
| 2800 | 4429 | ||
| 2801 | // $ANTLR start "entryRuleNamedObject" | 4430 | // $ANTLR start "entryRuleCount" |
| 2802 | // InternalSolverLanguage.g:936:1: entryRuleNamedObject returns [EObject current=null] : iv_ruleNamedObject= ruleNamedObject EOF ; | 4431 | // InternalSolverLanguage.g:1575:1: entryRuleCount returns [EObject current=null] : iv_ruleCount= ruleCount EOF ; |
| 2803 | public final EObject entryRuleNamedObject() throws RecognitionException { | 4432 | public final EObject entryRuleCount() throws RecognitionException { |
| 2804 | EObject current = null; | 4433 | EObject current = null; |
| 2805 | 4434 | ||
| 2806 | EObject iv_ruleNamedObject = null; | 4435 | EObject iv_ruleCount = null; |
| 2807 | 4436 | ||
| 2808 | 4437 | ||
| 2809 | try { | 4438 | try { |
| 2810 | // InternalSolverLanguage.g:936:52: (iv_ruleNamedObject= ruleNamedObject EOF ) | 4439 | // InternalSolverLanguage.g:1575:46: (iv_ruleCount= ruleCount EOF ) |
| 2811 | // InternalSolverLanguage.g:937:2: iv_ruleNamedObject= ruleNamedObject EOF | 4440 | // InternalSolverLanguage.g:1576:2: iv_ruleCount= ruleCount EOF |
| 2812 | { | 4441 | { |
| 2813 | newCompositeNode(grammarAccess.getNamedObjectRule()); | 4442 | if ( state.backtracking==0 ) { |
| 4443 | newCompositeNode(grammarAccess.getCountRule()); | ||
| 4444 | } | ||
| 2814 | pushFollow(FOLLOW_1); | 4445 | pushFollow(FOLLOW_1); |
| 2815 | iv_ruleNamedObject=ruleNamedObject(); | 4446 | iv_ruleCount=ruleCount(); |
| 2816 | 4447 | ||
| 2817 | state._fsp--; | 4448 | state._fsp--; |
| 2818 | 4449 | if (state.failed) return current; | |
| 2819 | current =iv_ruleNamedObject; | 4450 | if ( state.backtracking==0 ) { |
| 2820 | match(input,EOF,FOLLOW_2); | 4451 | current =iv_ruleCount; |
| 4452 | } | ||
| 4453 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 2821 | 4454 | ||
| 2822 | } | 4455 | } |
| 2823 | 4456 | ||
| @@ -2831,71 +4464,94 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2831 | } | 4464 | } |
| 2832 | return current; | 4465 | return current; |
| 2833 | } | 4466 | } |
| 2834 | // $ANTLR end "entryRuleNamedObject" | 4467 | // $ANTLR end "entryRuleCount" |
| 2835 | 4468 | ||
| 2836 | 4469 | ||
| 2837 | // $ANTLR start "ruleNamedObject" | 4470 | // $ANTLR start "ruleCount" |
| 2838 | // InternalSolverLanguage.g:943:1: ruleNamedObject returns [EObject current=null] : (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) ; | 4471 | // InternalSolverLanguage.g:1582:1: ruleCount returns [EObject current=null] : (otherlv_0= 'count' otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '}' ) ; |
| 2839 | public final EObject ruleNamedObject() throws RecognitionException { | 4472 | public final EObject ruleCount() throws RecognitionException { |
| 2840 | EObject current = null; | 4473 | EObject current = null; |
| 2841 | 4474 | ||
| 2842 | Token otherlv_0=null; | 4475 | Token otherlv_0=null; |
| 2843 | Token lv_name_1_0=null; | 4476 | Token otherlv_1=null; |
| 2844 | Token otherlv_2=null; | 4477 | Token otherlv_3=null; |
| 4478 | EObject lv_body_2_0 = null; | ||
| 4479 | |||
| 2845 | 4480 | ||
| 2846 | 4481 | ||
| 2847 | enterRule(); | 4482 | enterRule(); |
| 2848 | 4483 | ||
| 2849 | try { | 4484 | try { |
| 2850 | // InternalSolverLanguage.g:949:2: ( (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) ) | 4485 | // InternalSolverLanguage.g:1588:2: ( (otherlv_0= 'count' otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '}' ) ) |
| 2851 | // InternalSolverLanguage.g:950:2: (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) | 4486 | // InternalSolverLanguage.g:1589:2: (otherlv_0= 'count' otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '}' ) |
| 2852 | { | 4487 | { |
| 2853 | // InternalSolverLanguage.g:950:2: (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) | 4488 | // InternalSolverLanguage.g:1589:2: (otherlv_0= 'count' otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '}' ) |
| 2854 | // InternalSolverLanguage.g:951:3: otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' | 4489 | // InternalSolverLanguage.g:1590:3: otherlv_0= 'count' otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '}' |
| 2855 | { | 4490 | { |
| 2856 | otherlv_0=(Token)match(input,27,FOLLOW_12); | 4491 | otherlv_0=(Token)match(input,29,FOLLOW_26); if (state.failed) return current; |
| 4492 | if ( state.backtracking==0 ) { | ||
| 4493 | |||
| 4494 | newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0()); | ||
| 4495 | |||
| 4496 | } | ||
| 4497 | otherlv_1=(Token)match(input,30,FOLLOW_6); if (state.failed) return current; | ||
| 4498 | if ( state.backtracking==0 ) { | ||
| 2857 | 4499 | ||
| 2858 | newLeafNode(otherlv_0, grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); | 4500 | newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); |
| 2859 | 4501 | ||
| 2860 | // InternalSolverLanguage.g:955:3: ( (lv_name_1_0= RULE_ID ) ) | 4502 | } |
| 2861 | // InternalSolverLanguage.g:956:4: (lv_name_1_0= RULE_ID ) | 4503 | // InternalSolverLanguage.g:1598:3: ( (lv_body_2_0= ruleExpression ) ) |
| 4504 | // InternalSolverLanguage.g:1599:4: (lv_body_2_0= ruleExpression ) | ||
| 2862 | { | 4505 | { |
| 2863 | // InternalSolverLanguage.g:956:4: (lv_name_1_0= RULE_ID ) | 4506 | // InternalSolverLanguage.g:1599:4: (lv_body_2_0= ruleExpression ) |
| 2864 | // InternalSolverLanguage.g:957:5: lv_name_1_0= RULE_ID | 4507 | // InternalSolverLanguage.g:1600:5: lv_body_2_0= ruleExpression |
| 2865 | { | 4508 | { |
| 2866 | lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_13); | 4509 | if ( state.backtracking==0 ) { |
| 2867 | 4510 | ||
| 2868 | newLeafNode(lv_name_1_0, grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); | 4511 | newCompositeNode(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); |
| 2869 | 4512 | ||
| 4513 | } | ||
| 4514 | pushFollow(FOLLOW_27); | ||
| 4515 | lv_body_2_0=ruleExpression(); | ||
| 2870 | 4516 | ||
| 2871 | if (current==null) { | 4517 | state._fsp--; |
| 2872 | current = createModelElement(grammarAccess.getNamedObjectRule()); | 4518 | if (state.failed) return current; |
| 2873 | } | 4519 | if ( state.backtracking==0 ) { |
| 2874 | setWithLastConsumed( | 4520 | |
| 2875 | current, | 4521 | if (current==null) { |
| 2876 | "name", | 4522 | current = createModelElementForParent(grammarAccess.getCountRule()); |
| 2877 | lv_name_1_0, | 4523 | } |
| 2878 | "org.eclipse.xtext.common.Terminals.ID"); | 4524 | set( |
| 2879 | 4525 | current, | |
| 4526 | "body", | ||
| 4527 | lv_body_2_0, | ||
| 4528 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 4529 | afterParserOrEnumRuleCall(); | ||
| 4530 | |||
| 4531 | } | ||
| 2880 | 4532 | ||
| 2881 | } | 4533 | } |
| 2882 | 4534 | ||
| 2883 | 4535 | ||
| 2884 | } | 4536 | } |
| 2885 | 4537 | ||
| 2886 | otherlv_2=(Token)match(input,27,FOLLOW_2); | 4538 | otherlv_3=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; |
| 4539 | if ( state.backtracking==0 ) { | ||
| 2887 | 4540 | ||
| 2888 | newLeafNode(otherlv_2, grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); | 4541 | newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); |
| 2889 | 4542 | ||
| 4543 | } | ||
| 2890 | 4544 | ||
| 2891 | } | 4545 | } |
| 2892 | 4546 | ||
| 2893 | 4547 | ||
| 2894 | } | 4548 | } |
| 2895 | 4549 | ||
| 4550 | if ( state.backtracking==0 ) { | ||
| 2896 | 4551 | ||
| 2897 | leaveRule(); | 4552 | leaveRule(); |
| 2898 | 4553 | ||
| 4554 | } | ||
| 2899 | } | 4555 | } |
| 2900 | 4556 | ||
| 2901 | catch (RecognitionException re) { | 4557 | catch (RecognitionException re) { |
| @@ -2906,29 +4562,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2906 | } | 4562 | } |
| 2907 | return current; | 4563 | return current; |
| 2908 | } | 4564 | } |
| 2909 | // $ANTLR end "ruleNamedObject" | 4565 | // $ANTLR end "ruleCount" |
| 2910 | 4566 | ||
| 2911 | 4567 | ||
| 2912 | // $ANTLR start "entryRuleUnnamedObject" | 4568 | // $ANTLR start "entryRuleAggregation" |
| 2913 | // InternalSolverLanguage.g:981:1: entryRuleUnnamedObject returns [EObject current=null] : iv_ruleUnnamedObject= ruleUnnamedObject EOF ; | 4569 | // InternalSolverLanguage.g:1625:1: entryRuleAggregation returns [EObject current=null] : iv_ruleAggregation= ruleAggregation EOF ; |
| 2914 | public final EObject entryRuleUnnamedObject() throws RecognitionException { | 4570 | public final EObject entryRuleAggregation() throws RecognitionException { |
| 2915 | EObject current = null; | 4571 | EObject current = null; |
| 2916 | 4572 | ||
| 2917 | EObject iv_ruleUnnamedObject = null; | 4573 | EObject iv_ruleAggregation = null; |
| 2918 | 4574 | ||
| 2919 | 4575 | ||
| 2920 | try { | 4576 | try { |
| 2921 | // InternalSolverLanguage.g:981:54: (iv_ruleUnnamedObject= ruleUnnamedObject EOF ) | 4577 | // InternalSolverLanguage.g:1625:52: (iv_ruleAggregation= ruleAggregation EOF ) |
| 2922 | // InternalSolverLanguage.g:982:2: iv_ruleUnnamedObject= ruleUnnamedObject EOF | 4578 | // InternalSolverLanguage.g:1626:2: iv_ruleAggregation= ruleAggregation EOF |
| 2923 | { | 4579 | { |
| 2924 | newCompositeNode(grammarAccess.getUnnamedObjectRule()); | 4580 | if ( state.backtracking==0 ) { |
| 4581 | newCompositeNode(grammarAccess.getAggregationRule()); | ||
| 4582 | } | ||
| 2925 | pushFollow(FOLLOW_1); | 4583 | pushFollow(FOLLOW_1); |
| 2926 | iv_ruleUnnamedObject=ruleUnnamedObject(); | 4584 | iv_ruleAggregation=ruleAggregation(); |
| 2927 | 4585 | ||
| 2928 | state._fsp--; | 4586 | state._fsp--; |
| 2929 | 4587 | if (state.failed) return current; | |
| 2930 | current =iv_ruleUnnamedObject; | 4588 | if ( state.backtracking==0 ) { |
| 2931 | match(input,EOF,FOLLOW_2); | 4589 | current =iv_ruleAggregation; |
| 4590 | } | ||
| 4591 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 2932 | 4592 | ||
| 2933 | } | 4593 | } |
| 2934 | 4594 | ||
| @@ -2942,55 +4602,168 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2942 | } | 4602 | } |
| 2943 | return current; | 4603 | return current; |
| 2944 | } | 4604 | } |
| 2945 | // $ANTLR end "entryRuleUnnamedObject" | 4605 | // $ANTLR end "entryRuleAggregation" |
| 2946 | 4606 | ||
| 2947 | 4607 | ||
| 2948 | // $ANTLR start "ruleUnnamedObject" | 4608 | // $ANTLR start "ruleAggregation" |
| 2949 | // InternalSolverLanguage.g:988:1: ruleUnnamedObject returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; | 4609 | // InternalSolverLanguage.g:1632:1: ruleAggregation returns [EObject current=null] : ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '|' ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= '}' ) ; |
| 2950 | public final EObject ruleUnnamedObject() throws RecognitionException { | 4610 | public final EObject ruleAggregation() throws RecognitionException { |
| 2951 | EObject current = null; | 4611 | EObject current = null; |
| 2952 | 4612 | ||
| 2953 | Token lv_name_0_0=null; | 4613 | Token otherlv_1=null; |
| 4614 | Token otherlv_3=null; | ||
| 4615 | Token otherlv_5=null; | ||
| 4616 | Enumerator lv_op_0_0 = null; | ||
| 4617 | |||
| 4618 | EObject lv_body_2_0 = null; | ||
| 4619 | |||
| 4620 | EObject lv_condition_4_0 = null; | ||
| 4621 | |||
| 2954 | 4622 | ||
| 2955 | 4623 | ||
| 2956 | enterRule(); | 4624 | enterRule(); |
| 2957 | 4625 | ||
| 2958 | try { | 4626 | try { |
| 2959 | // InternalSolverLanguage.g:994:2: ( ( (lv_name_0_0= RULE_ID ) ) ) | 4627 | // InternalSolverLanguage.g:1638:2: ( ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '|' ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= '}' ) ) |
| 2960 | // InternalSolverLanguage.g:995:2: ( (lv_name_0_0= RULE_ID ) ) | 4628 | // InternalSolverLanguage.g:1639:2: ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '|' ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= '}' ) |
| 4629 | { | ||
| 4630 | // InternalSolverLanguage.g:1639:2: ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '|' ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= '}' ) | ||
| 4631 | // InternalSolverLanguage.g:1640:3: ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '|' ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= '}' | ||
| 4632 | { | ||
| 4633 | // InternalSolverLanguage.g:1640:3: ( (lv_op_0_0= ruleAggregationOp ) ) | ||
| 4634 | // InternalSolverLanguage.g:1641:4: (lv_op_0_0= ruleAggregationOp ) | ||
| 4635 | { | ||
| 4636 | // InternalSolverLanguage.g:1641:4: (lv_op_0_0= ruleAggregationOp ) | ||
| 4637 | // InternalSolverLanguage.g:1642:5: lv_op_0_0= ruleAggregationOp | ||
| 2961 | { | 4638 | { |
| 2962 | // InternalSolverLanguage.g:995:2: ( (lv_name_0_0= RULE_ID ) ) | 4639 | if ( state.backtracking==0 ) { |
| 2963 | // InternalSolverLanguage.g:996:3: (lv_name_0_0= RULE_ID ) | 4640 | |
| 4641 | newCompositeNode(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); | ||
| 4642 | |||
| 4643 | } | ||
| 4644 | pushFollow(FOLLOW_26); | ||
| 4645 | lv_op_0_0=ruleAggregationOp(); | ||
| 4646 | |||
| 4647 | state._fsp--; | ||
| 4648 | if (state.failed) return current; | ||
| 4649 | if ( state.backtracking==0 ) { | ||
| 4650 | |||
| 4651 | if (current==null) { | ||
| 4652 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 4653 | } | ||
| 4654 | set( | ||
| 4655 | current, | ||
| 4656 | "op", | ||
| 4657 | lv_op_0_0, | ||
| 4658 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationOp"); | ||
| 4659 | afterParserOrEnumRuleCall(); | ||
| 4660 | |||
| 4661 | } | ||
| 4662 | |||
| 4663 | } | ||
| 4664 | |||
| 4665 | |||
| 4666 | } | ||
| 4667 | |||
| 4668 | otherlv_1=(Token)match(input,30,FOLLOW_6); if (state.failed) return current; | ||
| 4669 | if ( state.backtracking==0 ) { | ||
| 4670 | |||
| 4671 | newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); | ||
| 4672 | |||
| 4673 | } | ||
| 4674 | // InternalSolverLanguage.g:1663:3: ( (lv_body_2_0= ruleExpression ) ) | ||
| 4675 | // InternalSolverLanguage.g:1664:4: (lv_body_2_0= ruleExpression ) | ||
| 2964 | { | 4676 | { |
| 2965 | // InternalSolverLanguage.g:996:3: (lv_name_0_0= RULE_ID ) | 4677 | // InternalSolverLanguage.g:1664:4: (lv_body_2_0= ruleExpression ) |
| 2966 | // InternalSolverLanguage.g:997:4: lv_name_0_0= RULE_ID | 4678 | // InternalSolverLanguage.g:1665:5: lv_body_2_0= ruleExpression |
| 2967 | { | 4679 | { |
| 2968 | lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); | 4680 | if ( state.backtracking==0 ) { |
| 4681 | |||
| 4682 | newCompositeNode(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); | ||
| 4683 | |||
| 4684 | } | ||
| 4685 | pushFollow(FOLLOW_28); | ||
| 4686 | lv_body_2_0=ruleExpression(); | ||
| 4687 | |||
| 4688 | state._fsp--; | ||
| 4689 | if (state.failed) return current; | ||
| 4690 | if ( state.backtracking==0 ) { | ||
| 4691 | |||
| 4692 | if (current==null) { | ||
| 4693 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 4694 | } | ||
| 4695 | set( | ||
| 4696 | current, | ||
| 4697 | "body", | ||
| 4698 | lv_body_2_0, | ||
| 4699 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 4700 | afterParserOrEnumRuleCall(); | ||
| 4701 | |||
| 4702 | } | ||
| 2969 | 4703 | ||
| 2970 | newLeafNode(lv_name_0_0, grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); | 4704 | } |
| 2971 | |||
| 2972 | 4705 | ||
| 2973 | if (current==null) { | ||
| 2974 | current = createModelElement(grammarAccess.getUnnamedObjectRule()); | ||
| 2975 | } | ||
| 2976 | setWithLastConsumed( | ||
| 2977 | current, | ||
| 2978 | "name", | ||
| 2979 | lv_name_0_0, | ||
| 2980 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 2981 | |||
| 2982 | 4706 | ||
| 2983 | } | 4707 | } |
| 2984 | 4708 | ||
| 4709 | otherlv_3=(Token)match(input,32,FOLLOW_6); if (state.failed) return current; | ||
| 4710 | if ( state.backtracking==0 ) { | ||
| 2985 | 4711 | ||
| 4712 | newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); | ||
| 4713 | |||
| 2986 | } | 4714 | } |
| 4715 | // InternalSolverLanguage.g:1686:3: ( (lv_condition_4_0= ruleExpression ) ) | ||
| 4716 | // InternalSolverLanguage.g:1687:4: (lv_condition_4_0= ruleExpression ) | ||
| 4717 | { | ||
| 4718 | // InternalSolverLanguage.g:1687:4: (lv_condition_4_0= ruleExpression ) | ||
| 4719 | // InternalSolverLanguage.g:1688:5: lv_condition_4_0= ruleExpression | ||
| 4720 | { | ||
| 4721 | if ( state.backtracking==0 ) { | ||
| 2987 | 4722 | ||
| 4723 | newCompositeNode(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); | ||
| 4724 | |||
| 4725 | } | ||
| 4726 | pushFollow(FOLLOW_27); | ||
| 4727 | lv_condition_4_0=ruleExpression(); | ||
| 4728 | |||
| 4729 | state._fsp--; | ||
| 4730 | if (state.failed) return current; | ||
| 4731 | if ( state.backtracking==0 ) { | ||
| 4732 | |||
| 4733 | if (current==null) { | ||
| 4734 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 4735 | } | ||
| 4736 | set( | ||
| 4737 | current, | ||
| 4738 | "condition", | ||
| 4739 | lv_condition_4_0, | ||
| 4740 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 4741 | afterParserOrEnumRuleCall(); | ||
| 4742 | |||
| 4743 | } | ||
| 2988 | 4744 | ||
| 2989 | } | 4745 | } |
| 2990 | 4746 | ||
| 2991 | 4747 | ||
| 2992 | leaveRule(); | 4748 | } |
| 4749 | |||
| 4750 | otherlv_5=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; | ||
| 4751 | if ( state.backtracking==0 ) { | ||
| 4752 | |||
| 4753 | newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); | ||
| 4754 | |||
| 4755 | } | ||
| 2993 | 4756 | ||
| 4757 | } | ||
| 4758 | |||
| 4759 | |||
| 4760 | } | ||
| 4761 | |||
| 4762 | if ( state.backtracking==0 ) { | ||
| 4763 | |||
| 4764 | leaveRule(); | ||
| 4765 | |||
| 4766 | } | ||
| 2994 | } | 4767 | } |
| 2995 | 4768 | ||
| 2996 | catch (RecognitionException re) { | 4769 | catch (RecognitionException re) { |
| @@ -3001,29 +4774,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3001 | } | 4774 | } |
| 3002 | return current; | 4775 | return current; |
| 3003 | } | 4776 | } |
| 3004 | // $ANTLR end "ruleUnnamedObject" | 4777 | // $ANTLR end "ruleAggregation" |
| 3005 | 4778 | ||
| 3006 | 4779 | ||
| 3007 | // $ANTLR start "entryRuleDataObject" | 4780 | // $ANTLR start "entryRuleAtomicExpression" |
| 3008 | // InternalSolverLanguage.g:1016:1: entryRuleDataObject returns [EObject current=null] : iv_ruleDataObject= ruleDataObject EOF ; | 4781 | // InternalSolverLanguage.g:1713:1: entryRuleAtomicExpression returns [EObject current=null] : iv_ruleAtomicExpression= ruleAtomicExpression EOF ; |
| 3009 | public final EObject entryRuleDataObject() throws RecognitionException { | 4782 | public final EObject entryRuleAtomicExpression() throws RecognitionException { |
| 3010 | EObject current = null; | 4783 | EObject current = null; |
| 3011 | 4784 | ||
| 3012 | EObject iv_ruleDataObject = null; | 4785 | EObject iv_ruleAtomicExpression = null; |
| 3013 | 4786 | ||
| 3014 | 4787 | ||
| 3015 | try { | 4788 | try { |
| 3016 | // InternalSolverLanguage.g:1016:51: (iv_ruleDataObject= ruleDataObject EOF ) | 4789 | // InternalSolverLanguage.g:1713:57: (iv_ruleAtomicExpression= ruleAtomicExpression EOF ) |
| 3017 | // InternalSolverLanguage.g:1017:2: iv_ruleDataObject= ruleDataObject EOF | 4790 | // InternalSolverLanguage.g:1714:2: iv_ruleAtomicExpression= ruleAtomicExpression EOF |
| 3018 | { | 4791 | { |
| 3019 | newCompositeNode(grammarAccess.getDataObjectRule()); | 4792 | if ( state.backtracking==0 ) { |
| 4793 | newCompositeNode(grammarAccess.getAtomicExpressionRule()); | ||
| 4794 | } | ||
| 3020 | pushFollow(FOLLOW_1); | 4795 | pushFollow(FOLLOW_1); |
| 3021 | iv_ruleDataObject=ruleDataObject(); | 4796 | iv_ruleAtomicExpression=ruleAtomicExpression(); |
| 3022 | 4797 | ||
| 3023 | state._fsp--; | 4798 | state._fsp--; |
| 3024 | 4799 | if (state.failed) return current; | |
| 3025 | current =iv_ruleDataObject; | 4800 | if ( state.backtracking==0 ) { |
| 3026 | match(input,EOF,FOLLOW_2); | 4801 | current =iv_ruleAtomicExpression; |
| 4802 | } | ||
| 4803 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 3027 | 4804 | ||
| 3028 | } | 4805 | } |
| 3029 | 4806 | ||
| @@ -3037,167 +4814,248 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3037 | } | 4814 | } |
| 3038 | return current; | 4815 | return current; |
| 3039 | } | 4816 | } |
| 3040 | // $ANTLR end "entryRuleDataObject" | 4817 | // $ANTLR end "entryRuleAtomicExpression" |
| 3041 | 4818 | ||
| 3042 | 4819 | ||
| 3043 | // $ANTLR start "ruleDataObject" | 4820 | // $ANTLR start "ruleAtomicExpression" |
| 3044 | // InternalSolverLanguage.g:1023:1: ruleDataObject returns [EObject current=null] : (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) ; | 4821 | // InternalSolverLanguage.g:1720:1: ruleAtomicExpression returns [EObject current=null] : ( (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | this_Interval_3= ruleInterval | this_Literal_4= ruleLiteral | (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) ) ; |
| 3045 | public final EObject ruleDataObject() throws RecognitionException { | 4822 | public final EObject ruleAtomicExpression() throws RecognitionException { |
| 3046 | EObject current = null; | 4823 | EObject current = null; |
| 3047 | 4824 | ||
| 3048 | EObject this_BooleanObject_0 = null; | 4825 | Token otherlv_5=null; |
| 4826 | Token otherlv_7=null; | ||
| 4827 | EObject this_Reference_0 = null; | ||
| 4828 | |||
| 4829 | EObject lv_argumentList_2_0 = null; | ||
| 3049 | 4830 | ||
| 3050 | EObject this_IntObject_1 = null; | 4831 | EObject this_Interval_3 = null; |
| 3051 | 4832 | ||
| 3052 | EObject this_RealObject_2 = null; | 4833 | EObject this_Literal_4 = null; |
| 3053 | 4834 | ||
| 3054 | EObject this_StringObject_3 = null; | 4835 | EObject this_Expression_6 = null; |
| 3055 | 4836 | ||
| 3056 | 4837 | ||
| 3057 | 4838 | ||
| 3058 | enterRule(); | 4839 | enterRule(); |
| 3059 | 4840 | ||
| 3060 | try { | 4841 | try { |
| 3061 | // InternalSolverLanguage.g:1029:2: ( (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) ) | 4842 | // InternalSolverLanguage.g:1726:2: ( ( (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | this_Interval_3= ruleInterval | this_Literal_4= ruleLiteral | (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) ) ) |
| 3062 | // InternalSolverLanguage.g:1030:2: (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) | 4843 | // InternalSolverLanguage.g:1727:2: ( (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | this_Interval_3= ruleInterval | this_Literal_4= ruleLiteral | (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) ) |
| 3063 | { | 4844 | { |
| 3064 | // InternalSolverLanguage.g:1030:2: (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) | 4845 | // InternalSolverLanguage.g:1727:2: ( (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | this_Interval_3= ruleInterval | this_Literal_4= ruleLiteral | (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) ) |
| 3065 | int alt16=4; | 4846 | int alt21=4; |
| 3066 | switch ( input.LA(1) ) { | 4847 | switch ( input.LA(1) ) { |
| 3067 | case 13: | 4848 | case RULE_ID: |
| 3068 | case 14: | 4849 | case RULE_QUOTED_ID: |
| 3069 | { | 4850 | { |
| 3070 | alt16=1; | 4851 | alt21=1; |
| 3071 | } | 4852 | } |
| 3072 | break; | 4853 | break; |
| 3073 | case 11: | 4854 | case 36: |
| 3074 | { | 4855 | { |
| 3075 | int LA16_2 = input.LA(2); | 4856 | alt21=2; |
| 3076 | |||
| 3077 | if ( (LA16_2==RULE_INT) ) { | ||
| 3078 | int LA16_3 = input.LA(3); | ||
| 3079 | |||
| 3080 | if ( (LA16_3==12) ) { | ||
| 3081 | alt16=3; | ||
| 3082 | } | ||
| 3083 | else if ( (LA16_3==EOF||(LA16_3>=18 && LA16_3<=19)) ) { | ||
| 3084 | alt16=2; | ||
| 3085 | } | ||
| 3086 | else { | ||
| 3087 | NoViableAltException nvae = | ||
| 3088 | new NoViableAltException("", 16, 3, input); | ||
| 3089 | |||
| 3090 | throw nvae; | ||
| 3091 | } | ||
| 3092 | } | ||
| 3093 | else { | ||
| 3094 | NoViableAltException nvae = | ||
| 3095 | new NoViableAltException("", 16, 2, input); | ||
| 3096 | |||
| 3097 | throw nvae; | ||
| 3098 | } | ||
| 3099 | } | 4857 | } |
| 3100 | break; | 4858 | break; |
| 4859 | case RULE_STRING: | ||
| 3101 | case RULE_INT: | 4860 | case RULE_INT: |
| 4861 | case 19: | ||
| 4862 | case 39: | ||
| 4863 | case 40: | ||
| 4864 | case 70: | ||
| 4865 | case 71: | ||
| 4866 | case 72: | ||
| 3102 | { | 4867 | { |
| 3103 | int LA16_3 = input.LA(2); | 4868 | alt21=3; |
| 3104 | |||
| 3105 | if ( (LA16_3==12) ) { | ||
| 3106 | alt16=3; | ||
| 3107 | } | ||
| 3108 | else if ( (LA16_3==EOF||(LA16_3>=18 && LA16_3<=19)) ) { | ||
| 3109 | alt16=2; | ||
| 3110 | } | ||
| 3111 | else { | ||
| 3112 | NoViableAltException nvae = | ||
| 3113 | new NoViableAltException("", 16, 3, input); | ||
| 3114 | |||
| 3115 | throw nvae; | ||
| 3116 | } | ||
| 3117 | } | 4869 | } |
| 3118 | break; | 4870 | break; |
| 3119 | case RULE_STRING: | 4871 | case 33: |
| 3120 | { | 4872 | { |
| 3121 | alt16=4; | 4873 | alt21=4; |
| 3122 | } | 4874 | } |
| 3123 | break; | 4875 | break; |
| 3124 | default: | 4876 | default: |
| 4877 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 3125 | NoViableAltException nvae = | 4878 | NoViableAltException nvae = |
| 3126 | new NoViableAltException("", 16, 0, input); | 4879 | new NoViableAltException("", 21, 0, input); |
| 3127 | 4880 | ||
| 3128 | throw nvae; | 4881 | throw nvae; |
| 3129 | } | 4882 | } |
| 3130 | 4883 | ||
| 3131 | switch (alt16) { | 4884 | switch (alt21) { |
| 3132 | case 1 : | 4885 | case 1 : |
| 3133 | // InternalSolverLanguage.g:1031:3: this_BooleanObject_0= ruleBooleanObject | 4886 | // InternalSolverLanguage.g:1728:3: (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) |
| 4887 | { | ||
| 4888 | // InternalSolverLanguage.g:1728:3: (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | ||
| 4889 | // InternalSolverLanguage.g:1729:4: this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? | ||
| 3134 | { | 4890 | { |
| 4891 | if ( state.backtracking==0 ) { | ||
| 3135 | 4892 | ||
| 3136 | newCompositeNode(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); | 4893 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0()); |
| 3137 | 4894 | ||
| 3138 | pushFollow(FOLLOW_2); | 4895 | } |
| 3139 | this_BooleanObject_0=ruleBooleanObject(); | 4896 | pushFollow(FOLLOW_29); |
| 4897 | this_Reference_0=ruleReference(); | ||
| 3140 | 4898 | ||
| 3141 | state._fsp--; | 4899 | state._fsp--; |
| 4900 | if (state.failed) return current; | ||
| 4901 | if ( state.backtracking==0 ) { | ||
| 4902 | |||
| 4903 | current = this_Reference_0; | ||
| 4904 | afterParserOrEnumRuleCall(); | ||
| 4905 | |||
| 4906 | } | ||
| 4907 | // InternalSolverLanguage.g:1737:4: ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? | ||
| 4908 | int alt20=2; | ||
| 4909 | int LA20_0 = input.LA(1); | ||
| 4910 | |||
| 4911 | if ( (LA20_0==33) ) { | ||
| 4912 | alt20=1; | ||
| 4913 | } | ||
| 4914 | switch (alt20) { | ||
| 4915 | case 1 : | ||
| 4916 | // InternalSolverLanguage.g:1738:5: () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) | ||
| 4917 | { | ||
| 4918 | // InternalSolverLanguage.g:1738:5: () | ||
| 4919 | // InternalSolverLanguage.g:1739:6: | ||
| 4920 | { | ||
| 4921 | if ( state.backtracking==0 ) { | ||
| 4922 | |||
| 4923 | current = forceCreateModelElementAndSet( | ||
| 4924 | grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0(), | ||
| 4925 | current); | ||
| 4926 | |||
| 4927 | } | ||
| 4928 | |||
| 4929 | } | ||
| 4930 | |||
| 4931 | // InternalSolverLanguage.g:1745:5: ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) | ||
| 4932 | // InternalSolverLanguage.g:1746:6: ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) | ||
| 4933 | { | ||
| 4934 | // InternalSolverLanguage.g:1747:6: (lv_argumentList_2_0= ruleArgumentList ) | ||
| 4935 | // InternalSolverLanguage.g:1748:7: lv_argumentList_2_0= ruleArgumentList | ||
| 4936 | { | ||
| 4937 | if ( state.backtracking==0 ) { | ||
| 4938 | |||
| 4939 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0()); | ||
| 4940 | |||
| 4941 | } | ||
| 4942 | pushFollow(FOLLOW_2); | ||
| 4943 | lv_argumentList_2_0=ruleArgumentList(); | ||
| 4944 | |||
| 4945 | state._fsp--; | ||
| 4946 | if (state.failed) return current; | ||
| 4947 | if ( state.backtracking==0 ) { | ||
| 4948 | |||
| 4949 | if (current==null) { | ||
| 4950 | current = createModelElementForParent(grammarAccess.getAtomicExpressionRule()); | ||
| 4951 | } | ||
| 4952 | set( | ||
| 4953 | current, | ||
| 4954 | "argumentList", | ||
| 4955 | lv_argumentList_2_0, | ||
| 4956 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
| 4957 | afterParserOrEnumRuleCall(); | ||
| 4958 | |||
| 4959 | } | ||
| 4960 | |||
| 4961 | } | ||
| 4962 | |||
| 4963 | |||
| 4964 | } | ||
| 4965 | |||
| 4966 | |||
| 4967 | } | ||
| 4968 | break; | ||
| 3142 | 4969 | ||
| 4970 | } | ||
| 4971 | |||
| 4972 | |||
| 4973 | } | ||
| 3143 | 4974 | ||
| 3144 | current = this_BooleanObject_0; | ||
| 3145 | afterParserOrEnumRuleCall(); | ||
| 3146 | |||
| 3147 | 4975 | ||
| 3148 | } | 4976 | } |
| 3149 | break; | 4977 | break; |
| 3150 | case 2 : | 4978 | case 2 : |
| 3151 | // InternalSolverLanguage.g:1040:3: this_IntObject_1= ruleIntObject | 4979 | // InternalSolverLanguage.g:1768:3: this_Interval_3= ruleInterval |
| 3152 | { | 4980 | { |
| 4981 | if ( state.backtracking==0 ) { | ||
| 3153 | 4982 | ||
| 3154 | newCompositeNode(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); | 4983 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1()); |
| 3155 | 4984 | ||
| 4985 | } | ||
| 3156 | pushFollow(FOLLOW_2); | 4986 | pushFollow(FOLLOW_2); |
| 3157 | this_IntObject_1=ruleIntObject(); | 4987 | this_Interval_3=ruleInterval(); |
| 3158 | 4988 | ||
| 3159 | state._fsp--; | 4989 | state._fsp--; |
| 4990 | if (state.failed) return current; | ||
| 4991 | if ( state.backtracking==0 ) { | ||
| 3160 | 4992 | ||
| 3161 | 4993 | current = this_Interval_3; | |
| 3162 | current = this_IntObject_1; | 4994 | afterParserOrEnumRuleCall(); |
| 3163 | afterParserOrEnumRuleCall(); | 4995 | |
| 3164 | 4996 | } | |
| 3165 | 4997 | ||
| 3166 | } | 4998 | } |
| 3167 | break; | 4999 | break; |
| 3168 | case 3 : | 5000 | case 3 : |
| 3169 | // InternalSolverLanguage.g:1049:3: this_RealObject_2= ruleRealObject | 5001 | // InternalSolverLanguage.g:1777:3: this_Literal_4= ruleLiteral |
| 3170 | { | 5002 | { |
| 5003 | if ( state.backtracking==0 ) { | ||
| 3171 | 5004 | ||
| 3172 | newCompositeNode(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); | 5005 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2()); |
| 3173 | 5006 | ||
| 5007 | } | ||
| 3174 | pushFollow(FOLLOW_2); | 5008 | pushFollow(FOLLOW_2); |
| 3175 | this_RealObject_2=ruleRealObject(); | 5009 | this_Literal_4=ruleLiteral(); |
| 3176 | 5010 | ||
| 3177 | state._fsp--; | 5011 | state._fsp--; |
| 5012 | if (state.failed) return current; | ||
| 5013 | if ( state.backtracking==0 ) { | ||
| 3178 | 5014 | ||
| 3179 | 5015 | current = this_Literal_4; | |
| 3180 | current = this_RealObject_2; | 5016 | afterParserOrEnumRuleCall(); |
| 3181 | afterParserOrEnumRuleCall(); | 5017 | |
| 3182 | 5018 | } | |
| 3183 | 5019 | ||
| 3184 | } | 5020 | } |
| 3185 | break; | 5021 | break; |
| 3186 | case 4 : | 5022 | case 4 : |
| 3187 | // InternalSolverLanguage.g:1058:3: this_StringObject_3= ruleStringObject | 5023 | // InternalSolverLanguage.g:1786:3: (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) |
| 3188 | { | 5024 | { |
| 5025 | // InternalSolverLanguage.g:1786:3: (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) | ||
| 5026 | // InternalSolverLanguage.g:1787:4: otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' | ||
| 5027 | { | ||
| 5028 | otherlv_5=(Token)match(input,33,FOLLOW_6); if (state.failed) return current; | ||
| 5029 | if ( state.backtracking==0 ) { | ||
| 3189 | 5030 | ||
| 3190 | newCompositeNode(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); | 5031 | newLeafNode(otherlv_5, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0()); |
| 3191 | 5032 | ||
| 3192 | pushFollow(FOLLOW_2); | 5033 | } |
| 3193 | this_StringObject_3=ruleStringObject(); | 5034 | if ( state.backtracking==0 ) { |
| 5035 | |||
| 5036 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1()); | ||
| 5037 | |||
| 5038 | } | ||
| 5039 | pushFollow(FOLLOW_30); | ||
| 5040 | this_Expression_6=ruleExpression(); | ||
| 3194 | 5041 | ||
| 3195 | state._fsp--; | 5042 | state._fsp--; |
| 5043 | if (state.failed) return current; | ||
| 5044 | if ( state.backtracking==0 ) { | ||
| 3196 | 5045 | ||
| 5046 | current = this_Expression_6; | ||
| 5047 | afterParserOrEnumRuleCall(); | ||
| 5048 | |||
| 5049 | } | ||
| 5050 | otherlv_7=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; | ||
| 5051 | if ( state.backtracking==0 ) { | ||
| 5052 | |||
| 5053 | newLeafNode(otherlv_7, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2()); | ||
| 5054 | |||
| 5055 | } | ||
| 5056 | |||
| 5057 | } | ||
| 3197 | 5058 | ||
| 3198 | current = this_StringObject_3; | ||
| 3199 | afterParserOrEnumRuleCall(); | ||
| 3200 | |||
| 3201 | 5059 | ||
| 3202 | } | 5060 | } |
| 3203 | break; | 5061 | break; |
| @@ -3207,9 +5065,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3207 | 5065 | ||
| 3208 | } | 5066 | } |
| 3209 | 5067 | ||
| 5068 | if ( state.backtracking==0 ) { | ||
| 3210 | 5069 | ||
| 3211 | leaveRule(); | 5070 | leaveRule(); |
| 3212 | 5071 | ||
| 5072 | } | ||
| 3213 | } | 5073 | } |
| 3214 | 5074 | ||
| 3215 | catch (RecognitionException re) { | 5075 | catch (RecognitionException re) { |
| @@ -3220,29 +5080,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3220 | } | 5080 | } |
| 3221 | return current; | 5081 | return current; |
| 3222 | } | 5082 | } |
| 3223 | // $ANTLR end "ruleDataObject" | 5083 | // $ANTLR end "ruleAtomicExpression" |
| 3224 | 5084 | ||
| 3225 | 5085 | ||
| 3226 | // $ANTLR start "entryRuleBooleanObject" | 5086 | // $ANTLR start "entryRuleCall" |
| 3227 | // InternalSolverLanguage.g:1070:1: entryRuleBooleanObject returns [EObject current=null] : iv_ruleBooleanObject= ruleBooleanObject EOF ; | 5087 | // InternalSolverLanguage.g:1808:1: entryRuleCall returns [EObject current=null] : iv_ruleCall= ruleCall EOF ; |
| 3228 | public final EObject entryRuleBooleanObject() throws RecognitionException { | 5088 | public final EObject entryRuleCall() throws RecognitionException { |
| 3229 | EObject current = null; | 5089 | EObject current = null; |
| 3230 | 5090 | ||
| 3231 | EObject iv_ruleBooleanObject = null; | 5091 | EObject iv_ruleCall = null; |
| 3232 | 5092 | ||
| 3233 | 5093 | ||
| 3234 | try { | 5094 | try { |
| 3235 | // InternalSolverLanguage.g:1070:54: (iv_ruleBooleanObject= ruleBooleanObject EOF ) | 5095 | // InternalSolverLanguage.g:1808:45: (iv_ruleCall= ruleCall EOF ) |
| 3236 | // InternalSolverLanguage.g:1071:2: iv_ruleBooleanObject= ruleBooleanObject EOF | 5096 | // InternalSolverLanguage.g:1809:2: iv_ruleCall= ruleCall EOF |
| 3237 | { | 5097 | { |
| 3238 | newCompositeNode(grammarAccess.getBooleanObjectRule()); | 5098 | if ( state.backtracking==0 ) { |
| 5099 | newCompositeNode(grammarAccess.getCallRule()); | ||
| 5100 | } | ||
| 3239 | pushFollow(FOLLOW_1); | 5101 | pushFollow(FOLLOW_1); |
| 3240 | iv_ruleBooleanObject=ruleBooleanObject(); | 5102 | iv_ruleCall=ruleCall(); |
| 3241 | 5103 | ||
| 3242 | state._fsp--; | 5104 | state._fsp--; |
| 3243 | 5105 | if (state.failed) return current; | |
| 3244 | current =iv_ruleBooleanObject; | 5106 | if ( state.backtracking==0 ) { |
| 3245 | match(input,EOF,FOLLOW_2); | 5107 | current =iv_ruleCall; |
| 5108 | } | ||
| 5109 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 3246 | 5110 | ||
| 3247 | } | 5111 | } |
| 3248 | 5112 | ||
| @@ -3256,49 +5120,184 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3256 | } | 5120 | } |
| 3257 | return current; | 5121 | return current; |
| 3258 | } | 5122 | } |
| 3259 | // $ANTLR end "entryRuleBooleanObject" | 5123 | // $ANTLR end "entryRuleCall" |
| 3260 | 5124 | ||
| 3261 | 5125 | ||
| 3262 | // $ANTLR start "ruleBooleanObject" | 5126 | // $ANTLR start "ruleCall" |
| 3263 | // InternalSolverLanguage.g:1077:1: ruleBooleanObject returns [EObject current=null] : ( (lv_value_0_0= ruleBooleanValue ) ) ; | 5127 | // InternalSolverLanguage.g:1815:1: ruleCall returns [EObject current=null] : ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) ; |
| 3264 | public final EObject ruleBooleanObject() throws RecognitionException { | 5128 | public final EObject ruleCall() throws RecognitionException { |
| 3265 | EObject current = null; | 5129 | EObject current = null; |
| 3266 | 5130 | ||
| 3267 | EObject lv_value_0_0 = null; | 5131 | Token lv_transitiveClosure_1_0=null; |
| 5132 | Token lv_reflexiveTransitiveClosure_2_0=null; | ||
| 5133 | EObject lv_functor_0_0 = null; | ||
| 5134 | |||
| 5135 | EObject lv_argumentList_3_0 = null; | ||
| 3268 | 5136 | ||
| 3269 | 5137 | ||
| 3270 | 5138 | ||
| 3271 | enterRule(); | 5139 | enterRule(); |
| 3272 | 5140 | ||
| 3273 | try { | 5141 | try { |
| 3274 | // InternalSolverLanguage.g:1083:2: ( ( (lv_value_0_0= ruleBooleanValue ) ) ) | 5142 | // InternalSolverLanguage.g:1821:2: ( ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) ) |
| 3275 | // InternalSolverLanguage.g:1084:2: ( (lv_value_0_0= ruleBooleanValue ) ) | 5143 | // InternalSolverLanguage.g:1822:2: ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) |
| 3276 | { | 5144 | { |
| 3277 | // InternalSolverLanguage.g:1084:2: ( (lv_value_0_0= ruleBooleanValue ) ) | 5145 | // InternalSolverLanguage.g:1822:2: ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) |
| 3278 | // InternalSolverLanguage.g:1085:3: (lv_value_0_0= ruleBooleanValue ) | 5146 | // InternalSolverLanguage.g:1823:3: ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) |
| 3279 | { | 5147 | { |
| 3280 | // InternalSolverLanguage.g:1085:3: (lv_value_0_0= ruleBooleanValue ) | 5148 | // InternalSolverLanguage.g:1823:3: ( (lv_functor_0_0= ruleReference ) ) |
| 3281 | // InternalSolverLanguage.g:1086:4: lv_value_0_0= ruleBooleanValue | 5149 | // InternalSolverLanguage.g:1824:4: (lv_functor_0_0= ruleReference ) |
| 3282 | { | 5150 | { |
| 5151 | // InternalSolverLanguage.g:1824:4: (lv_functor_0_0= ruleReference ) | ||
| 5152 | // InternalSolverLanguage.g:1825:5: lv_functor_0_0= ruleReference | ||
| 5153 | { | ||
| 5154 | if ( state.backtracking==0 ) { | ||
| 5155 | |||
| 5156 | newCompositeNode(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); | ||
| 5157 | |||
| 5158 | } | ||
| 5159 | pushFollow(FOLLOW_31); | ||
| 5160 | lv_functor_0_0=ruleReference(); | ||
| 5161 | |||
| 5162 | state._fsp--; | ||
| 5163 | if (state.failed) return current; | ||
| 5164 | if ( state.backtracking==0 ) { | ||
| 5165 | |||
| 5166 | if (current==null) { | ||
| 5167 | current = createModelElementForParent(grammarAccess.getCallRule()); | ||
| 5168 | } | ||
| 5169 | set( | ||
| 5170 | current, | ||
| 5171 | "functor", | ||
| 5172 | lv_functor_0_0, | ||
| 5173 | "org.eclipse.viatra.solver.language.SolverLanguage.Reference"); | ||
| 5174 | afterParserOrEnumRuleCall(); | ||
| 5175 | |||
| 5176 | } | ||
| 5177 | |||
| 5178 | } | ||
| 5179 | |||
| 5180 | |||
| 5181 | } | ||
| 3283 | 5182 | ||
| 3284 | newCompositeNode(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); | 5183 | // InternalSolverLanguage.g:1842:3: ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? |
| 3285 | 5184 | int alt22=3; | |
| 5185 | int LA22_0 = input.LA(1); | ||
| 5186 | |||
| 5187 | if ( (LA22_0==RULE_STAR) ) { | ||
| 5188 | alt22=1; | ||
| 5189 | } | ||
| 5190 | else if ( (LA22_0==RULE_PLUS) ) { | ||
| 5191 | alt22=2; | ||
| 5192 | } | ||
| 5193 | switch (alt22) { | ||
| 5194 | case 1 : | ||
| 5195 | // InternalSolverLanguage.g:1843:4: ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ||
| 5196 | { | ||
| 5197 | // InternalSolverLanguage.g:1843:4: ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ||
| 5198 | // InternalSolverLanguage.g:1844:5: (lv_transitiveClosure_1_0= RULE_STAR ) | ||
| 5199 | { | ||
| 5200 | // InternalSolverLanguage.g:1844:5: (lv_transitiveClosure_1_0= RULE_STAR ) | ||
| 5201 | // InternalSolverLanguage.g:1845:6: lv_transitiveClosure_1_0= RULE_STAR | ||
| 5202 | { | ||
| 5203 | lv_transitiveClosure_1_0=(Token)match(input,RULE_STAR,FOLLOW_10); if (state.failed) return current; | ||
| 5204 | if ( state.backtracking==0 ) { | ||
| 5205 | |||
| 5206 | newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0()); | ||
| 5207 | |||
| 5208 | } | ||
| 5209 | if ( state.backtracking==0 ) { | ||
| 5210 | |||
| 5211 | if (current==null) { | ||
| 5212 | current = createModelElement(grammarAccess.getCallRule()); | ||
| 5213 | } | ||
| 5214 | setWithLastConsumed( | ||
| 5215 | current, | ||
| 5216 | "transitiveClosure", | ||
| 5217 | true, | ||
| 5218 | "org.eclipse.viatra.solver.language.SolverLanguage.STAR"); | ||
| 5219 | |||
| 5220 | } | ||
| 5221 | |||
| 5222 | } | ||
| 5223 | |||
| 5224 | |||
| 5225 | } | ||
| 5226 | |||
| 5227 | |||
| 5228 | } | ||
| 5229 | break; | ||
| 5230 | case 2 : | ||
| 5231 | // InternalSolverLanguage.g:1862:4: ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) | ||
| 5232 | { | ||
| 5233 | // InternalSolverLanguage.g:1862:4: ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) | ||
| 5234 | // InternalSolverLanguage.g:1863:5: (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) | ||
| 5235 | { | ||
| 5236 | // InternalSolverLanguage.g:1863:5: (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) | ||
| 5237 | // InternalSolverLanguage.g:1864:6: lv_reflexiveTransitiveClosure_2_0= RULE_PLUS | ||
| 5238 | { | ||
| 5239 | lv_reflexiveTransitiveClosure_2_0=(Token)match(input,RULE_PLUS,FOLLOW_10); if (state.failed) return current; | ||
| 5240 | if ( state.backtracking==0 ) { | ||
| 5241 | |||
| 5242 | newLeafNode(lv_reflexiveTransitiveClosure_2_0, grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0()); | ||
| 5243 | |||
| 5244 | } | ||
| 5245 | if ( state.backtracking==0 ) { | ||
| 5246 | |||
| 5247 | if (current==null) { | ||
| 5248 | current = createModelElement(grammarAccess.getCallRule()); | ||
| 5249 | } | ||
| 5250 | setWithLastConsumed( | ||
| 5251 | current, | ||
| 5252 | "reflexiveTransitiveClosure", | ||
| 5253 | true, | ||
| 5254 | "org.eclipse.viatra.solver.language.SolverLanguage.PLUS"); | ||
| 5255 | |||
| 5256 | } | ||
| 5257 | |||
| 5258 | } | ||
| 5259 | |||
| 5260 | |||
| 5261 | } | ||
| 5262 | |||
| 5263 | |||
| 5264 | } | ||
| 5265 | break; | ||
| 5266 | |||
| 5267 | } | ||
| 5268 | |||
| 5269 | // InternalSolverLanguage.g:1881:3: ( (lv_argumentList_3_0= ruleArgumentList ) ) | ||
| 5270 | // InternalSolverLanguage.g:1882:4: (lv_argumentList_3_0= ruleArgumentList ) | ||
| 5271 | { | ||
| 5272 | // InternalSolverLanguage.g:1882:4: (lv_argumentList_3_0= ruleArgumentList ) | ||
| 5273 | // InternalSolverLanguage.g:1883:5: lv_argumentList_3_0= ruleArgumentList | ||
| 5274 | { | ||
| 5275 | if ( state.backtracking==0 ) { | ||
| 5276 | |||
| 5277 | newCompositeNode(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); | ||
| 5278 | |||
| 5279 | } | ||
| 3286 | pushFollow(FOLLOW_2); | 5280 | pushFollow(FOLLOW_2); |
| 3287 | lv_value_0_0=ruleBooleanValue(); | 5281 | lv_argumentList_3_0=ruleArgumentList(); |
| 3288 | 5282 | ||
| 3289 | state._fsp--; | 5283 | state._fsp--; |
| 5284 | if (state.failed) return current; | ||
| 5285 | if ( state.backtracking==0 ) { | ||
| 5286 | |||
| 5287 | if (current==null) { | ||
| 5288 | current = createModelElementForParent(grammarAccess.getCallRule()); | ||
| 5289 | } | ||
| 5290 | set( | ||
| 5291 | current, | ||
| 5292 | "argumentList", | ||
| 5293 | lv_argumentList_3_0, | ||
| 5294 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
| 5295 | afterParserOrEnumRuleCall(); | ||
| 5296 | |||
| 5297 | } | ||
| 3290 | 5298 | ||
| 5299 | } | ||
| 3291 | 5300 | ||
| 3292 | if (current==null) { | ||
| 3293 | current = createModelElementForParent(grammarAccess.getBooleanObjectRule()); | ||
| 3294 | } | ||
| 3295 | set( | ||
| 3296 | current, | ||
| 3297 | "value", | ||
| 3298 | lv_value_0_0, | ||
| 3299 | "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue"); | ||
| 3300 | afterParserOrEnumRuleCall(); | ||
| 3301 | |||
| 3302 | 5301 | ||
| 3303 | } | 5302 | } |
| 3304 | 5303 | ||
| @@ -3308,9 +5307,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3308 | 5307 | ||
| 3309 | } | 5308 | } |
| 3310 | 5309 | ||
| 5310 | if ( state.backtracking==0 ) { | ||
| 3311 | 5311 | ||
| 3312 | leaveRule(); | 5312 | leaveRule(); |
| 3313 | 5313 | ||
| 5314 | } | ||
| 3314 | } | 5315 | } |
| 3315 | 5316 | ||
| 3316 | catch (RecognitionException re) { | 5317 | catch (RecognitionException re) { |
| @@ -3321,29 +5322,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3321 | } | 5322 | } |
| 3322 | return current; | 5323 | return current; |
| 3323 | } | 5324 | } |
| 3324 | // $ANTLR end "ruleBooleanObject" | 5325 | // $ANTLR end "ruleCall" |
| 3325 | 5326 | ||
| 3326 | 5327 | ||
| 3327 | // $ANTLR start "entryRuleIntObject" | 5328 | // $ANTLR start "entryRuleArgumentList" |
| 3328 | // InternalSolverLanguage.g:1106:1: entryRuleIntObject returns [EObject current=null] : iv_ruleIntObject= ruleIntObject EOF ; | 5329 | // InternalSolverLanguage.g:1904:1: entryRuleArgumentList returns [EObject current=null] : iv_ruleArgumentList= ruleArgumentList EOF ; |
| 3329 | public final EObject entryRuleIntObject() throws RecognitionException { | 5330 | public final EObject entryRuleArgumentList() throws RecognitionException { |
| 3330 | EObject current = null; | 5331 | EObject current = null; |
| 3331 | 5332 | ||
| 3332 | EObject iv_ruleIntObject = null; | 5333 | EObject iv_ruleArgumentList = null; |
| 3333 | 5334 | ||
| 3334 | 5335 | ||
| 3335 | try { | 5336 | try { |
| 3336 | // InternalSolverLanguage.g:1106:50: (iv_ruleIntObject= ruleIntObject EOF ) | 5337 | // InternalSolverLanguage.g:1904:53: (iv_ruleArgumentList= ruleArgumentList EOF ) |
| 3337 | // InternalSolverLanguage.g:1107:2: iv_ruleIntObject= ruleIntObject EOF | 5338 | // InternalSolverLanguage.g:1905:2: iv_ruleArgumentList= ruleArgumentList EOF |
| 3338 | { | 5339 | { |
| 3339 | newCompositeNode(grammarAccess.getIntObjectRule()); | 5340 | if ( state.backtracking==0 ) { |
| 5341 | newCompositeNode(grammarAccess.getArgumentListRule()); | ||
| 5342 | } | ||
| 3340 | pushFollow(FOLLOW_1); | 5343 | pushFollow(FOLLOW_1); |
| 3341 | iv_ruleIntObject=ruleIntObject(); | 5344 | iv_ruleArgumentList=ruleArgumentList(); |
| 3342 | 5345 | ||
| 3343 | state._fsp--; | 5346 | state._fsp--; |
| 3344 | 5347 | if (state.failed) return current; | |
| 3345 | current =iv_ruleIntObject; | 5348 | if ( state.backtracking==0 ) { |
| 3346 | match(input,EOF,FOLLOW_2); | 5349 | current =iv_ruleArgumentList; |
| 5350 | } | ||
| 5351 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 3347 | 5352 | ||
| 3348 | } | 5353 | } |
| 3349 | 5354 | ||
| @@ -3357,61 +5362,185 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3357 | } | 5362 | } |
| 3358 | return current; | 5363 | return current; |
| 3359 | } | 5364 | } |
| 3360 | // $ANTLR end "entryRuleIntObject" | 5365 | // $ANTLR end "entryRuleArgumentList" |
| 3361 | 5366 | ||
| 3362 | 5367 | ||
| 3363 | // $ANTLR start "ruleIntObject" | 5368 | // $ANTLR start "ruleArgumentList" |
| 3364 | // InternalSolverLanguage.g:1113:1: ruleIntObject returns [EObject current=null] : ( (lv_value_0_0= ruleINTLiteral ) ) ; | 5369 | // InternalSolverLanguage.g:1911:1: ruleArgumentList returns [EObject current=null] : ( () otherlv_1= '(' ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= ')' ) ; |
| 3365 | public final EObject ruleIntObject() throws RecognitionException { | 5370 | public final EObject ruleArgumentList() throws RecognitionException { |
| 3366 | EObject current = null; | 5371 | EObject current = null; |
| 3367 | 5372 | ||
| 3368 | AntlrDatatypeRuleToken lv_value_0_0 = null; | 5373 | Token otherlv_1=null; |
| 5374 | Token otherlv_3=null; | ||
| 5375 | Token otherlv_5=null; | ||
| 5376 | EObject lv_arguments_2_0 = null; | ||
| 5377 | |||
| 5378 | EObject lv_arguments_4_0 = null; | ||
| 3369 | 5379 | ||
| 3370 | 5380 | ||
| 3371 | 5381 | ||
| 3372 | enterRule(); | 5382 | enterRule(); |
| 3373 | 5383 | ||
| 3374 | try { | 5384 | try { |
| 3375 | // InternalSolverLanguage.g:1119:2: ( ( (lv_value_0_0= ruleINTLiteral ) ) ) | 5385 | // InternalSolverLanguage.g:1917:2: ( ( () otherlv_1= '(' ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= ')' ) ) |
| 3376 | // InternalSolverLanguage.g:1120:2: ( (lv_value_0_0= ruleINTLiteral ) ) | 5386 | // InternalSolverLanguage.g:1918:2: ( () otherlv_1= '(' ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= ')' ) |
| 3377 | { | 5387 | { |
| 3378 | // InternalSolverLanguage.g:1120:2: ( (lv_value_0_0= ruleINTLiteral ) ) | 5388 | // InternalSolverLanguage.g:1918:2: ( () otherlv_1= '(' ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= ')' ) |
| 3379 | // InternalSolverLanguage.g:1121:3: (lv_value_0_0= ruleINTLiteral ) | 5389 | // InternalSolverLanguage.g:1919:3: () otherlv_1= '(' ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= ')' |
| 3380 | { | 5390 | { |
| 3381 | // InternalSolverLanguage.g:1121:3: (lv_value_0_0= ruleINTLiteral ) | 5391 | // InternalSolverLanguage.g:1919:3: () |
| 3382 | // InternalSolverLanguage.g:1122:4: lv_value_0_0= ruleINTLiteral | 5392 | // InternalSolverLanguage.g:1920:4: |
| 3383 | { | 5393 | { |
| 5394 | if ( state.backtracking==0 ) { | ||
| 3384 | 5395 | ||
| 3385 | newCompositeNode(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); | 5396 | current = forceCreateModelElement( |
| 3386 | 5397 | grammarAccess.getArgumentListAccess().getArgumentListAction_0(), | |
| 3387 | pushFollow(FOLLOW_2); | 5398 | current); |
| 3388 | lv_value_0_0=ruleINTLiteral(); | 5399 | |
| 5400 | } | ||
| 3389 | 5401 | ||
| 3390 | state._fsp--; | 5402 | } |
| 5403 | |||
| 5404 | otherlv_1=(Token)match(input,33,FOLLOW_32); if (state.failed) return current; | ||
| 5405 | if ( state.backtracking==0 ) { | ||
| 5406 | |||
| 5407 | newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); | ||
| 5408 | |||
| 5409 | } | ||
| 5410 | // InternalSolverLanguage.g:1930:3: ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? | ||
| 5411 | int alt24=2; | ||
| 5412 | int LA24_0 = input.LA(1); | ||
| 5413 | |||
| 5414 | if ( ((LA24_0>=RULE_STRING && LA24_0<=RULE_QUOTED_ID)||LA24_0==19||LA24_0==29||LA24_0==33||(LA24_0>=35 && LA24_0<=36)||(LA24_0>=39 && LA24_0<=40)||(LA24_0>=56 && LA24_0<=57)||(LA24_0>=60 && LA24_0<=72)) ) { | ||
| 5415 | alt24=1; | ||
| 5416 | } | ||
| 5417 | switch (alt24) { | ||
| 5418 | case 1 : | ||
| 5419 | // InternalSolverLanguage.g:1931:4: ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* | ||
| 5420 | { | ||
| 5421 | // InternalSolverLanguage.g:1931:4: ( (lv_arguments_2_0= ruleArgument ) ) | ||
| 5422 | // InternalSolverLanguage.g:1932:5: (lv_arguments_2_0= ruleArgument ) | ||
| 5423 | { | ||
| 5424 | // InternalSolverLanguage.g:1932:5: (lv_arguments_2_0= ruleArgument ) | ||
| 5425 | // InternalSolverLanguage.g:1933:6: lv_arguments_2_0= ruleArgument | ||
| 5426 | { | ||
| 5427 | if ( state.backtracking==0 ) { | ||
| 5428 | |||
| 5429 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); | ||
| 5430 | |||
| 5431 | } | ||
| 5432 | pushFollow(FOLLOW_33); | ||
| 5433 | lv_arguments_2_0=ruleArgument(); | ||
| 5434 | |||
| 5435 | state._fsp--; | ||
| 5436 | if (state.failed) return current; | ||
| 5437 | if ( state.backtracking==0 ) { | ||
| 5438 | |||
| 5439 | if (current==null) { | ||
| 5440 | current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
| 5441 | } | ||
| 5442 | add( | ||
| 5443 | current, | ||
| 5444 | "arguments", | ||
| 5445 | lv_arguments_2_0, | ||
| 5446 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
| 5447 | afterParserOrEnumRuleCall(); | ||
| 5448 | |||
| 5449 | } | ||
| 5450 | |||
| 5451 | } | ||
| 5452 | |||
| 5453 | |||
| 5454 | } | ||
| 5455 | |||
| 5456 | // InternalSolverLanguage.g:1950:4: (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* | ||
| 5457 | loop23: | ||
| 5458 | do { | ||
| 5459 | int alt23=2; | ||
| 5460 | int LA23_0 = input.LA(1); | ||
| 5461 | |||
| 5462 | if ( (LA23_0==28) ) { | ||
| 5463 | alt23=1; | ||
| 5464 | } | ||
| 5465 | |||
| 5466 | |||
| 5467 | switch (alt23) { | ||
| 5468 | case 1 : | ||
| 5469 | // InternalSolverLanguage.g:1951:5: otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) | ||
| 5470 | { | ||
| 5471 | otherlv_3=(Token)match(input,28,FOLLOW_34); if (state.failed) return current; | ||
| 5472 | if ( state.backtracking==0 ) { | ||
| 5473 | |||
| 5474 | newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); | ||
| 5475 | |||
| 5476 | } | ||
| 5477 | // InternalSolverLanguage.g:1955:5: ( (lv_arguments_4_0= ruleArgument ) ) | ||
| 5478 | // InternalSolverLanguage.g:1956:6: (lv_arguments_4_0= ruleArgument ) | ||
| 5479 | { | ||
| 5480 | // InternalSolverLanguage.g:1956:6: (lv_arguments_4_0= ruleArgument ) | ||
| 5481 | // InternalSolverLanguage.g:1957:7: lv_arguments_4_0= ruleArgument | ||
| 5482 | { | ||
| 5483 | if ( state.backtracking==0 ) { | ||
| 5484 | |||
| 5485 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); | ||
| 5486 | |||
| 5487 | } | ||
| 5488 | pushFollow(FOLLOW_33); | ||
| 5489 | lv_arguments_4_0=ruleArgument(); | ||
| 5490 | |||
| 5491 | state._fsp--; | ||
| 5492 | if (state.failed) return current; | ||
| 5493 | if ( state.backtracking==0 ) { | ||
| 5494 | |||
| 5495 | if (current==null) { | ||
| 5496 | current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
| 5497 | } | ||
| 5498 | add( | ||
| 5499 | current, | ||
| 5500 | "arguments", | ||
| 5501 | lv_arguments_4_0, | ||
| 5502 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
| 5503 | afterParserOrEnumRuleCall(); | ||
| 5504 | |||
| 5505 | } | ||
| 5506 | |||
| 5507 | } | ||
| 5508 | |||
| 5509 | |||
| 5510 | } | ||
| 5511 | |||
| 5512 | |||
| 5513 | } | ||
| 5514 | break; | ||
| 5515 | |||
| 5516 | default : | ||
| 5517 | break loop23; | ||
| 5518 | } | ||
| 5519 | } while (true); | ||
| 3391 | 5520 | ||
| 3392 | 5521 | ||
| 3393 | if (current==null) { | 5522 | } |
| 3394 | current = createModelElementForParent(grammarAccess.getIntObjectRule()); | 5523 | break; |
| 3395 | } | ||
| 3396 | set( | ||
| 3397 | current, | ||
| 3398 | "value", | ||
| 3399 | lv_value_0_0, | ||
| 3400 | "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral"); | ||
| 3401 | afterParserOrEnumRuleCall(); | ||
| 3402 | |||
| 3403 | 5524 | ||
| 3404 | } | 5525 | } |
| 3405 | 5526 | ||
| 5527 | otherlv_5=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; | ||
| 5528 | if ( state.backtracking==0 ) { | ||
| 5529 | |||
| 5530 | newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); | ||
| 5531 | |||
| 5532 | } | ||
| 3406 | 5533 | ||
| 3407 | } | 5534 | } |
| 3408 | 5535 | ||
| 3409 | 5536 | ||
| 3410 | } | 5537 | } |
| 3411 | 5538 | ||
| 5539 | if ( state.backtracking==0 ) { | ||
| 3412 | 5540 | ||
| 3413 | leaveRule(); | 5541 | leaveRule(); |
| 3414 | 5542 | ||
| 5543 | } | ||
| 3415 | } | 5544 | } |
| 3416 | 5545 | ||
| 3417 | catch (RecognitionException re) { | 5546 | catch (RecognitionException re) { |
| @@ -3422,29 +5551,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3422 | } | 5551 | } |
| 3423 | return current; | 5552 | return current; |
| 3424 | } | 5553 | } |
| 3425 | // $ANTLR end "ruleIntObject" | 5554 | // $ANTLR end "ruleArgumentList" |
| 3426 | 5555 | ||
| 3427 | 5556 | ||
| 3428 | // $ANTLR start "entryRuleRealObject" | 5557 | // $ANTLR start "entryRuleArgument" |
| 3429 | // InternalSolverLanguage.g:1142:1: entryRuleRealObject returns [EObject current=null] : iv_ruleRealObject= ruleRealObject EOF ; | 5558 | // InternalSolverLanguage.g:1984:1: entryRuleArgument returns [EObject current=null] : iv_ruleArgument= ruleArgument EOF ; |
| 3430 | public final EObject entryRuleRealObject() throws RecognitionException { | 5559 | public final EObject entryRuleArgument() throws RecognitionException { |
| 3431 | EObject current = null; | 5560 | EObject current = null; |
| 3432 | 5561 | ||
| 3433 | EObject iv_ruleRealObject = null; | 5562 | EObject iv_ruleArgument = null; |
| 3434 | 5563 | ||
| 3435 | 5564 | ||
| 3436 | try { | 5565 | try { |
| 3437 | // InternalSolverLanguage.g:1142:51: (iv_ruleRealObject= ruleRealObject EOF ) | 5566 | // InternalSolverLanguage.g:1984:49: (iv_ruleArgument= ruleArgument EOF ) |
| 3438 | // InternalSolverLanguage.g:1143:2: iv_ruleRealObject= ruleRealObject EOF | 5567 | // InternalSolverLanguage.g:1985:2: iv_ruleArgument= ruleArgument EOF |
| 3439 | { | 5568 | { |
| 3440 | newCompositeNode(grammarAccess.getRealObjectRule()); | 5569 | if ( state.backtracking==0 ) { |
| 5570 | newCompositeNode(grammarAccess.getArgumentRule()); | ||
| 5571 | } | ||
| 3441 | pushFollow(FOLLOW_1); | 5572 | pushFollow(FOLLOW_1); |
| 3442 | iv_ruleRealObject=ruleRealObject(); | 5573 | iv_ruleArgument=ruleArgument(); |
| 3443 | 5574 | ||
| 3444 | state._fsp--; | 5575 | state._fsp--; |
| 3445 | 5576 | if (state.failed) return current; | |
| 3446 | current =iv_ruleRealObject; | 5577 | if ( state.backtracking==0 ) { |
| 3447 | match(input,EOF,FOLLOW_2); | 5578 | current =iv_ruleArgument; |
| 5579 | } | ||
| 5580 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 3448 | 5581 | ||
| 3449 | } | 5582 | } |
| 3450 | 5583 | ||
| @@ -3458,61 +5591,133 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3458 | } | 5591 | } |
| 3459 | return current; | 5592 | return current; |
| 3460 | } | 5593 | } |
| 3461 | // $ANTLR end "entryRuleRealObject" | 5594 | // $ANTLR end "entryRuleArgument" |
| 3462 | 5595 | ||
| 3463 | 5596 | ||
| 3464 | // $ANTLR start "ruleRealObject" | 5597 | // $ANTLR start "ruleArgument" |
| 3465 | // InternalSolverLanguage.g:1149:1: ruleRealObject returns [EObject current=null] : ( (lv_value_0_0= ruleREALLiteral ) ) ; | 5598 | // InternalSolverLanguage.g:1991:1: ruleArgument returns [EObject current=null] : (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) ; |
| 3466 | public final EObject ruleRealObject() throws RecognitionException { | 5599 | public final EObject ruleArgument() throws RecognitionException { |
| 3467 | EObject current = null; | 5600 | EObject current = null; |
| 3468 | 5601 | ||
| 3469 | AntlrDatatypeRuleToken lv_value_0_0 = null; | 5602 | EObject this_ExpressionArgument_0 = null; |
| 5603 | |||
| 5604 | EObject this_StarArgument_1 = null; | ||
| 5605 | |||
| 5606 | EObject this_TypedArgument_2 = null; | ||
| 5607 | |||
| 5608 | EObject this_TypedStarArgument_3 = null; | ||
| 3470 | 5609 | ||
| 3471 | 5610 | ||
| 3472 | 5611 | ||
| 3473 | enterRule(); | 5612 | enterRule(); |
| 3474 | 5613 | ||
| 3475 | try { | 5614 | try { |
| 3476 | // InternalSolverLanguage.g:1155:2: ( ( (lv_value_0_0= ruleREALLiteral ) ) ) | 5615 | // InternalSolverLanguage.g:1997:2: ( (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) ) |
| 3477 | // InternalSolverLanguage.g:1156:2: ( (lv_value_0_0= ruleREALLiteral ) ) | 5616 | // InternalSolverLanguage.g:1998:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) |
| 3478 | { | ||
| 3479 | // InternalSolverLanguage.g:1156:2: ( (lv_value_0_0= ruleREALLiteral ) ) | ||
| 3480 | // InternalSolverLanguage.g:1157:3: (lv_value_0_0= ruleREALLiteral ) | ||
| 3481 | { | ||
| 3482 | // InternalSolverLanguage.g:1157:3: (lv_value_0_0= ruleREALLiteral ) | ||
| 3483 | // InternalSolverLanguage.g:1158:4: lv_value_0_0= ruleREALLiteral | ||
| 3484 | { | 5617 | { |
| 5618 | // InternalSolverLanguage.g:1998:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) | ||
| 5619 | int alt25=4; | ||
| 5620 | alt25 = dfa25.predict(input); | ||
| 5621 | switch (alt25) { | ||
| 5622 | case 1 : | ||
| 5623 | // InternalSolverLanguage.g:1999:3: this_ExpressionArgument_0= ruleExpressionArgument | ||
| 5624 | { | ||
| 5625 | if ( state.backtracking==0 ) { | ||
| 3485 | 5626 | ||
| 3486 | newCompositeNode(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); | 5627 | newCompositeNode(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); |
| 3487 | 5628 | ||
| 3488 | pushFollow(FOLLOW_2); | 5629 | } |
| 3489 | lv_value_0_0=ruleREALLiteral(); | 5630 | pushFollow(FOLLOW_2); |
| 5631 | this_ExpressionArgument_0=ruleExpressionArgument(); | ||
| 3490 | 5632 | ||
| 3491 | state._fsp--; | 5633 | state._fsp--; |
| 5634 | if (state.failed) return current; | ||
| 5635 | if ( state.backtracking==0 ) { | ||
| 3492 | 5636 | ||
| 5637 | current = this_ExpressionArgument_0; | ||
| 5638 | afterParserOrEnumRuleCall(); | ||
| 5639 | |||
| 5640 | } | ||
| 3493 | 5641 | ||
| 3494 | if (current==null) { | 5642 | } |
| 3495 | current = createModelElementForParent(grammarAccess.getRealObjectRule()); | 5643 | break; |
| 3496 | } | 5644 | case 2 : |
| 3497 | set( | 5645 | // InternalSolverLanguage.g:2008:3: this_StarArgument_1= ruleStarArgument |
| 3498 | current, | 5646 | { |
| 3499 | "value", | 5647 | if ( state.backtracking==0 ) { |
| 3500 | lv_value_0_0, | ||
| 3501 | "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral"); | ||
| 3502 | afterParserOrEnumRuleCall(); | ||
| 3503 | |||
| 3504 | 5648 | ||
| 3505 | } | 5649 | newCompositeNode(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); |
| 5650 | |||
| 5651 | } | ||
| 5652 | pushFollow(FOLLOW_2); | ||
| 5653 | this_StarArgument_1=ruleStarArgument(); | ||
| 3506 | 5654 | ||
| 5655 | state._fsp--; | ||
| 5656 | if (state.failed) return current; | ||
| 5657 | if ( state.backtracking==0 ) { | ||
| 5658 | |||
| 5659 | current = this_StarArgument_1; | ||
| 5660 | afterParserOrEnumRuleCall(); | ||
| 5661 | |||
| 5662 | } | ||
| 5663 | |||
| 5664 | } | ||
| 5665 | break; | ||
| 5666 | case 3 : | ||
| 5667 | // InternalSolverLanguage.g:2017:3: this_TypedArgument_2= ruleTypedArgument | ||
| 5668 | { | ||
| 5669 | if ( state.backtracking==0 ) { | ||
| 5670 | |||
| 5671 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); | ||
| 5672 | |||
| 5673 | } | ||
| 5674 | pushFollow(FOLLOW_2); | ||
| 5675 | this_TypedArgument_2=ruleTypedArgument(); | ||
| 5676 | |||
| 5677 | state._fsp--; | ||
| 5678 | if (state.failed) return current; | ||
| 5679 | if ( state.backtracking==0 ) { | ||
| 5680 | |||
| 5681 | current = this_TypedArgument_2; | ||
| 5682 | afterParserOrEnumRuleCall(); | ||
| 5683 | |||
| 5684 | } | ||
| 5685 | |||
| 5686 | } | ||
| 5687 | break; | ||
| 5688 | case 4 : | ||
| 5689 | // InternalSolverLanguage.g:2026:3: this_TypedStarArgument_3= ruleTypedStarArgument | ||
| 5690 | { | ||
| 5691 | if ( state.backtracking==0 ) { | ||
| 5692 | |||
| 5693 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); | ||
| 5694 | |||
| 5695 | } | ||
| 5696 | pushFollow(FOLLOW_2); | ||
| 5697 | this_TypedStarArgument_3=ruleTypedStarArgument(); | ||
| 5698 | |||
| 5699 | state._fsp--; | ||
| 5700 | if (state.failed) return current; | ||
| 5701 | if ( state.backtracking==0 ) { | ||
| 5702 | |||
| 5703 | current = this_TypedStarArgument_3; | ||
| 5704 | afterParserOrEnumRuleCall(); | ||
| 5705 | |||
| 5706 | } | ||
| 5707 | |||
| 5708 | } | ||
| 5709 | break; | ||
| 3507 | 5710 | ||
| 3508 | } | 5711 | } |
| 3509 | 5712 | ||
| 3510 | 5713 | ||
| 3511 | } | 5714 | } |
| 3512 | 5715 | ||
| 5716 | if ( state.backtracking==0 ) { | ||
| 3513 | 5717 | ||
| 3514 | leaveRule(); | 5718 | leaveRule(); |
| 3515 | 5719 | ||
| 5720 | } | ||
| 3516 | } | 5721 | } |
| 3517 | 5722 | ||
| 3518 | catch (RecognitionException re) { | 5723 | catch (RecognitionException re) { |
| @@ -3523,29 +5728,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3523 | } | 5728 | } |
| 3524 | return current; | 5729 | return current; |
| 3525 | } | 5730 | } |
| 3526 | // $ANTLR end "ruleRealObject" | 5731 | // $ANTLR end "ruleArgument" |
| 3527 | 5732 | ||
| 3528 | 5733 | ||
| 3529 | // $ANTLR start "entryRuleStringObject" | 5734 | // $ANTLR start "entryRuleExpressionArgument" |
| 3530 | // InternalSolverLanguage.g:1178:1: entryRuleStringObject returns [EObject current=null] : iv_ruleStringObject= ruleStringObject EOF ; | 5735 | // InternalSolverLanguage.g:2038:1: entryRuleExpressionArgument returns [EObject current=null] : iv_ruleExpressionArgument= ruleExpressionArgument EOF ; |
| 3531 | public final EObject entryRuleStringObject() throws RecognitionException { | 5736 | public final EObject entryRuleExpressionArgument() throws RecognitionException { |
| 3532 | EObject current = null; | 5737 | EObject current = null; |
| 3533 | 5738 | ||
| 3534 | EObject iv_ruleStringObject = null; | 5739 | EObject iv_ruleExpressionArgument = null; |
| 3535 | 5740 | ||
| 3536 | 5741 | ||
| 3537 | try { | 5742 | try { |
| 3538 | // InternalSolverLanguage.g:1178:53: (iv_ruleStringObject= ruleStringObject EOF ) | 5743 | // InternalSolverLanguage.g:2038:59: (iv_ruleExpressionArgument= ruleExpressionArgument EOF ) |
| 3539 | // InternalSolverLanguage.g:1179:2: iv_ruleStringObject= ruleStringObject EOF | 5744 | // InternalSolverLanguage.g:2039:2: iv_ruleExpressionArgument= ruleExpressionArgument EOF |
| 3540 | { | 5745 | { |
| 3541 | newCompositeNode(grammarAccess.getStringObjectRule()); | 5746 | if ( state.backtracking==0 ) { |
| 5747 | newCompositeNode(grammarAccess.getExpressionArgumentRule()); | ||
| 5748 | } | ||
| 3542 | pushFollow(FOLLOW_1); | 5749 | pushFollow(FOLLOW_1); |
| 3543 | iv_ruleStringObject=ruleStringObject(); | 5750 | iv_ruleExpressionArgument=ruleExpressionArgument(); |
| 3544 | 5751 | ||
| 3545 | state._fsp--; | 5752 | state._fsp--; |
| 3546 | 5753 | if (state.failed) return current; | |
| 3547 | current =iv_ruleStringObject; | 5754 | if ( state.backtracking==0 ) { |
| 3548 | match(input,EOF,FOLLOW_2); | 5755 | current =iv_ruleExpressionArgument; |
| 5756 | } | ||
| 5757 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 3549 | 5758 | ||
| 3550 | } | 5759 | } |
| 3551 | 5760 | ||
| @@ -3559,43 +5768,53 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3559 | } | 5768 | } |
| 3560 | return current; | 5769 | return current; |
| 3561 | } | 5770 | } |
| 3562 | // $ANTLR end "entryRuleStringObject" | 5771 | // $ANTLR end "entryRuleExpressionArgument" |
| 3563 | 5772 | ||
| 3564 | 5773 | ||
| 3565 | // $ANTLR start "ruleStringObject" | 5774 | // $ANTLR start "ruleExpressionArgument" |
| 3566 | // InternalSolverLanguage.g:1185:1: ruleStringObject returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; | 5775 | // InternalSolverLanguage.g:2045:1: ruleExpressionArgument returns [EObject current=null] : ( (lv_body_0_0= ruleComparisonExpression ) ) ; |
| 3567 | public final EObject ruleStringObject() throws RecognitionException { | 5776 | public final EObject ruleExpressionArgument() throws RecognitionException { |
| 3568 | EObject current = null; | 5777 | EObject current = null; |
| 3569 | 5778 | ||
| 3570 | Token lv_value_0_0=null; | 5779 | EObject lv_body_0_0 = null; |
| 5780 | |||
| 3571 | 5781 | ||
| 3572 | 5782 | ||
| 3573 | enterRule(); | 5783 | enterRule(); |
| 3574 | 5784 | ||
| 3575 | try { | 5785 | try { |
| 3576 | // InternalSolverLanguage.g:1191:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) | 5786 | // InternalSolverLanguage.g:2051:2: ( ( (lv_body_0_0= ruleComparisonExpression ) ) ) |
| 3577 | // InternalSolverLanguage.g:1192:2: ( (lv_value_0_0= RULE_STRING ) ) | 5787 | // InternalSolverLanguage.g:2052:2: ( (lv_body_0_0= ruleComparisonExpression ) ) |
| 3578 | { | 5788 | { |
| 3579 | // InternalSolverLanguage.g:1192:2: ( (lv_value_0_0= RULE_STRING ) ) | 5789 | // InternalSolverLanguage.g:2052:2: ( (lv_body_0_0= ruleComparisonExpression ) ) |
| 3580 | // InternalSolverLanguage.g:1193:3: (lv_value_0_0= RULE_STRING ) | 5790 | // InternalSolverLanguage.g:2053:3: (lv_body_0_0= ruleComparisonExpression ) |
| 3581 | { | 5791 | { |
| 3582 | // InternalSolverLanguage.g:1193:3: (lv_value_0_0= RULE_STRING ) | 5792 | // InternalSolverLanguage.g:2053:3: (lv_body_0_0= ruleComparisonExpression ) |
| 3583 | // InternalSolverLanguage.g:1194:4: lv_value_0_0= RULE_STRING | 5793 | // InternalSolverLanguage.g:2054:4: lv_body_0_0= ruleComparisonExpression |
| 3584 | { | 5794 | { |
| 3585 | lv_value_0_0=(Token)match(input,RULE_STRING,FOLLOW_2); | 5795 | if ( state.backtracking==0 ) { |
| 5796 | |||
| 5797 | newCompositeNode(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); | ||
| 5798 | |||
| 5799 | } | ||
| 5800 | pushFollow(FOLLOW_2); | ||
| 5801 | lv_body_0_0=ruleComparisonExpression(); | ||
| 3586 | 5802 | ||
| 3587 | newLeafNode(lv_value_0_0, grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); | 5803 | state._fsp--; |
| 3588 | 5804 | if (state.failed) return current; | |
| 5805 | if ( state.backtracking==0 ) { | ||
| 3589 | 5806 | ||
| 3590 | if (current==null) { | 5807 | if (current==null) { |
| 3591 | current = createModelElement(grammarAccess.getStringObjectRule()); | 5808 | current = createModelElementForParent(grammarAccess.getExpressionArgumentRule()); |
| 3592 | } | 5809 | } |
| 3593 | setWithLastConsumed( | 5810 | set( |
| 3594 | current, | 5811 | current, |
| 3595 | "value", | 5812 | "body", |
| 3596 | lv_value_0_0, | 5813 | lv_body_0_0, |
| 3597 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | 5814 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); |
| 3598 | 5815 | afterParserOrEnumRuleCall(); | |
| 5816 | |||
| 5817 | } | ||
| 3599 | 5818 | ||
| 3600 | } | 5819 | } |
| 3601 | 5820 | ||
| @@ -3605,9 +5824,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3605 | 5824 | ||
| 3606 | } | 5825 | } |
| 3607 | 5826 | ||
| 5827 | if ( state.backtracking==0 ) { | ||
| 3608 | 5828 | ||
| 3609 | leaveRule(); | 5829 | leaveRule(); |
| 3610 | 5830 | ||
| 5831 | } | ||
| 3611 | } | 5832 | } |
| 3612 | 5833 | ||
| 3613 | catch (RecognitionException re) { | 5834 | catch (RecognitionException re) { |
| @@ -3618,29 +5839,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3618 | } | 5839 | } |
| 3619 | return current; | 5840 | return current; |
| 3620 | } | 5841 | } |
| 3621 | // $ANTLR end "ruleStringObject" | 5842 | // $ANTLR end "ruleExpressionArgument" |
| 3622 | 5843 | ||
| 3623 | 5844 | ||
| 3624 | // $ANTLR start "entryRulePredicate" | 5845 | // $ANTLR start "entryRuleStarArgument" |
| 3625 | // InternalSolverLanguage.g:1213:1: entryRulePredicate returns [EObject current=null] : iv_rulePredicate= rulePredicate EOF ; | 5846 | // InternalSolverLanguage.g:2074:1: entryRuleStarArgument returns [EObject current=null] : iv_ruleStarArgument= ruleStarArgument EOF ; |
| 3626 | public final EObject entryRulePredicate() throws RecognitionException { | 5847 | public final EObject entryRuleStarArgument() throws RecognitionException { |
| 3627 | EObject current = null; | 5848 | EObject current = null; |
| 3628 | 5849 | ||
| 3629 | EObject iv_rulePredicate = null; | 5850 | EObject iv_ruleStarArgument = null; |
| 3630 | 5851 | ||
| 3631 | 5852 | ||
| 3632 | try { | 5853 | try { |
| 3633 | // InternalSolverLanguage.g:1213:50: (iv_rulePredicate= rulePredicate EOF ) | 5854 | // InternalSolverLanguage.g:2074:53: (iv_ruleStarArgument= ruleStarArgument EOF ) |
| 3634 | // InternalSolverLanguage.g:1214:2: iv_rulePredicate= rulePredicate EOF | 5855 | // InternalSolverLanguage.g:2075:2: iv_ruleStarArgument= ruleStarArgument EOF |
| 3635 | { | 5856 | { |
| 3636 | newCompositeNode(grammarAccess.getPredicateRule()); | 5857 | if ( state.backtracking==0 ) { |
| 5858 | newCompositeNode(grammarAccess.getStarArgumentRule()); | ||
| 5859 | } | ||
| 3637 | pushFollow(FOLLOW_1); | 5860 | pushFollow(FOLLOW_1); |
| 3638 | iv_rulePredicate=rulePredicate(); | 5861 | iv_ruleStarArgument=ruleStarArgument(); |
| 3639 | 5862 | ||
| 3640 | state._fsp--; | 5863 | state._fsp--; |
| 3641 | 5864 | if (state.failed) return current; | |
| 3642 | current =iv_rulePredicate; | 5865 | if ( state.backtracking==0 ) { |
| 3643 | match(input,EOF,FOLLOW_2); | 5866 | current =iv_ruleStarArgument; |
| 5867 | } | ||
| 5868 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 3644 | 5869 | ||
| 3645 | } | 5870 | } |
| 3646 | 5871 | ||
| @@ -3654,388 +5879,431 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3654 | } | 5879 | } |
| 3655 | return current; | 5880 | return current; |
| 3656 | } | 5881 | } |
| 3657 | // $ANTLR end "entryRulePredicate" | 5882 | // $ANTLR end "entryRuleStarArgument" |
| 3658 | 5883 | ||
| 3659 | 5884 | ||
| 3660 | // $ANTLR start "rulePredicate" | 5885 | // $ANTLR start "ruleStarArgument" |
| 3661 | // InternalSolverLanguage.g:1220:1: rulePredicate returns [EObject current=null] : ( ( (lv_isError_0_0= 'error' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? otherlv_7= ':-' (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) otherlv_12= '.' ) ; | 5886 | // InternalSolverLanguage.g:2081:1: ruleStarArgument returns [EObject current=null] : ( () otherlv_1= '*' ) ; |
| 3662 | public final EObject rulePredicate() throws RecognitionException { | 5887 | public final EObject ruleStarArgument() throws RecognitionException { |
| 3663 | EObject current = null; | 5888 | EObject current = null; |
| 3664 | 5889 | ||
| 3665 | Token lv_isError_0_0=null; | 5890 | Token otherlv_1=null; |
| 3666 | Token otherlv_2=null; | ||
| 3667 | Token otherlv_4=null; | ||
| 3668 | Token otherlv_6=null; | ||
| 3669 | Token otherlv_7=null; | ||
| 3670 | Token otherlv_8=null; | ||
| 3671 | Token otherlv_10=null; | ||
| 3672 | Token otherlv_12=null; | ||
| 3673 | EObject lv_symbol_1_0 = null; | ||
| 3674 | 5891 | ||
| 3675 | EObject lv_parameters_3_0 = null; | ||
| 3676 | 5892 | ||
| 3677 | EObject lv_parameters_5_0 = null; | 5893 | enterRule(); |
| 3678 | 5894 | ||
| 3679 | EObject lv_bodies_9_0 = null; | 5895 | try { |
| 5896 | // InternalSolverLanguage.g:2087:2: ( ( () otherlv_1= '*' ) ) | ||
| 5897 | // InternalSolverLanguage.g:2088:2: ( () otherlv_1= '*' ) | ||
| 5898 | { | ||
| 5899 | // InternalSolverLanguage.g:2088:2: ( () otherlv_1= '*' ) | ||
| 5900 | // InternalSolverLanguage.g:2089:3: () otherlv_1= '*' | ||
| 5901 | { | ||
| 5902 | // InternalSolverLanguage.g:2089:3: () | ||
| 5903 | // InternalSolverLanguage.g:2090:4: | ||
| 5904 | { | ||
| 5905 | if ( state.backtracking==0 ) { | ||
| 3680 | 5906 | ||
| 3681 | EObject lv_bodies_11_0 = null; | 5907 | current = forceCreateModelElement( |
| 5908 | grammarAccess.getStarArgumentAccess().getStarArgumentAction_0(), | ||
| 5909 | current); | ||
| 5910 | |||
| 5911 | } | ||
| 3682 | 5912 | ||
| 5913 | } | ||
| 3683 | 5914 | ||
| 5915 | otherlv_1=(Token)match(input,35,FOLLOW_2); if (state.failed) return current; | ||
| 5916 | if ( state.backtracking==0 ) { | ||
| 5917 | |||
| 5918 | newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); | ||
| 5919 | |||
| 5920 | } | ||
| 5921 | |||
| 5922 | } | ||
| 5923 | |||
| 5924 | |||
| 5925 | } | ||
| 5926 | |||
| 5927 | if ( state.backtracking==0 ) { | ||
| 5928 | |||
| 5929 | leaveRule(); | ||
| 5930 | |||
| 5931 | } | ||
| 5932 | } | ||
| 5933 | |||
| 5934 | catch (RecognitionException re) { | ||
| 5935 | recover(input,re); | ||
| 5936 | appendSkippedTokens(); | ||
| 5937 | } | ||
| 5938 | finally { | ||
| 5939 | } | ||
| 5940 | return current; | ||
| 5941 | } | ||
| 5942 | // $ANTLR end "ruleStarArgument" | ||
| 5943 | |||
| 5944 | |||
| 5945 | // $ANTLR start "entryRuleTypedArgument" | ||
| 5946 | // InternalSolverLanguage.g:2104:1: entryRuleTypedArgument returns [EObject current=null] : iv_ruleTypedArgument= ruleTypedArgument EOF ; | ||
| 5947 | public final EObject entryRuleTypedArgument() throws RecognitionException { | ||
| 5948 | EObject current = null; | ||
| 5949 | |||
| 5950 | EObject iv_ruleTypedArgument = null; | ||
| 3684 | 5951 | ||
| 3685 | enterRule(); | ||
| 3686 | 5952 | ||
| 3687 | try { | 5953 | try { |
| 3688 | // InternalSolverLanguage.g:1226:2: ( ( ( (lv_isError_0_0= 'error' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? otherlv_7= ':-' (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) otherlv_12= '.' ) ) | 5954 | // InternalSolverLanguage.g:2104:54: (iv_ruleTypedArgument= ruleTypedArgument EOF ) |
| 3689 | // InternalSolverLanguage.g:1227:2: ( ( (lv_isError_0_0= 'error' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? otherlv_7= ':-' (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) otherlv_12= '.' ) | 5955 | // InternalSolverLanguage.g:2105:2: iv_ruleTypedArgument= ruleTypedArgument EOF |
| 3690 | { | 5956 | { |
| 3691 | // InternalSolverLanguage.g:1227:2: ( ( (lv_isError_0_0= 'error' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? otherlv_7= ':-' (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) otherlv_12= '.' ) | 5957 | if ( state.backtracking==0 ) { |
| 3692 | // InternalSolverLanguage.g:1228:3: ( (lv_isError_0_0= 'error' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? otherlv_7= ':-' (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) otherlv_12= '.' | 5958 | newCompositeNode(grammarAccess.getTypedArgumentRule()); |
| 3693 | { | 5959 | } |
| 3694 | // InternalSolverLanguage.g:1228:3: ( (lv_isError_0_0= 'error' ) )? | 5960 | pushFollow(FOLLOW_1); |
| 3695 | int alt17=2; | 5961 | iv_ruleTypedArgument=ruleTypedArgument(); |
| 3696 | int LA17_0 = input.LA(1); | ||
| 3697 | 5962 | ||
| 3698 | if ( (LA17_0==16) ) { | 5963 | state._fsp--; |
| 3699 | alt17=1; | 5964 | if (state.failed) return current; |
| 5965 | if ( state.backtracking==0 ) { | ||
| 5966 | current =iv_ruleTypedArgument; | ||
| 3700 | } | 5967 | } |
| 3701 | switch (alt17) { | 5968 | match(input,EOF,FOLLOW_2); if (state.failed) return current; |
| 3702 | case 1 : | ||
| 3703 | // InternalSolverLanguage.g:1229:4: (lv_isError_0_0= 'error' ) | ||
| 3704 | { | ||
| 3705 | // InternalSolverLanguage.g:1229:4: (lv_isError_0_0= 'error' ) | ||
| 3706 | // InternalSolverLanguage.g:1230:5: lv_isError_0_0= 'error' | ||
| 3707 | { | ||
| 3708 | lv_isError_0_0=(Token)match(input,16,FOLLOW_12); | ||
| 3709 | 5969 | ||
| 3710 | newLeafNode(lv_isError_0_0, grammarAccess.getPredicateAccess().getIsErrorErrorKeyword_0_0()); | 5970 | } |
| 3711 | |||
| 3712 | 5971 | ||
| 3713 | if (current==null) { | 5972 | } |
| 3714 | current = createModelElement(grammarAccess.getPredicateRule()); | ||
| 3715 | } | ||
| 3716 | setWithLastConsumed(current, "isError", true, "error"); | ||
| 3717 | |||
| 3718 | 5973 | ||
| 3719 | } | 5974 | catch (RecognitionException re) { |
| 5975 | recover(input,re); | ||
| 5976 | appendSkippedTokens(); | ||
| 5977 | } | ||
| 5978 | finally { | ||
| 5979 | } | ||
| 5980 | return current; | ||
| 5981 | } | ||
| 5982 | // $ANTLR end "entryRuleTypedArgument" | ||
| 3720 | 5983 | ||
| 3721 | 5984 | ||
| 3722 | } | 5985 | // $ANTLR start "ruleTypedArgument" |
| 3723 | break; | 5986 | // InternalSolverLanguage.g:2111:1: ruleTypedArgument returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) ; |
| 5987 | public final EObject ruleTypedArgument() throws RecognitionException { | ||
| 5988 | EObject current = null; | ||
| 3724 | 5989 | ||
| 3725 | } | ||
| 3726 | 5990 | ||
| 3727 | // InternalSolverLanguage.g:1242:3: ( (lv_symbol_1_0= ruleModelSymbol ) ) | 5991 | enterRule(); |
| 3728 | // InternalSolverLanguage.g:1243:4: (lv_symbol_1_0= ruleModelSymbol ) | 5992 | |
| 5993 | try { | ||
| 5994 | // InternalSolverLanguage.g:2117:2: ( ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) ) | ||
| 5995 | // InternalSolverLanguage.g:2118:2: ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) | ||
| 5996 | { | ||
| 5997 | // InternalSolverLanguage.g:2118:2: ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) | ||
| 5998 | // InternalSolverLanguage.g:2119:3: ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) | ||
| 3729 | { | 5999 | { |
| 3730 | // InternalSolverLanguage.g:1243:4: (lv_symbol_1_0= ruleModelSymbol ) | 6000 | // InternalSolverLanguage.g:2119:3: ( ( ruleQualifiedName ) ) |
| 3731 | // InternalSolverLanguage.g:1244:5: lv_symbol_1_0= ruleModelSymbol | 6001 | // InternalSolverLanguage.g:2120:4: ( ruleQualifiedName ) |
| 3732 | { | 6002 | { |
| 6003 | // InternalSolverLanguage.g:2120:4: ( ruleQualifiedName ) | ||
| 6004 | // InternalSolverLanguage.g:2121:5: ruleQualifiedName | ||
| 6005 | { | ||
| 6006 | if ( state.backtracking==0 ) { | ||
| 3733 | 6007 | ||
| 3734 | newCompositeNode(grammarAccess.getPredicateAccess().getSymbolModelSymbolParserRuleCall_1_0()); | 6008 | if (current==null) { |
| 3735 | 6009 | current = createModelElement(grammarAccess.getTypedArgumentRule()); | |
| 3736 | pushFollow(FOLLOW_14); | 6010 | } |
| 3737 | lv_symbol_1_0=ruleModelSymbol(); | 6011 | |
| 6012 | } | ||
| 6013 | if ( state.backtracking==0 ) { | ||
| 3738 | 6014 | ||
| 3739 | state._fsp--; | 6015 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); |
| 6016 | |||
| 6017 | } | ||
| 6018 | pushFollow(FOLLOW_35); | ||
| 6019 | ruleQualifiedName(); | ||
| 3740 | 6020 | ||
| 6021 | state._fsp--; | ||
| 6022 | if (state.failed) return current; | ||
| 6023 | if ( state.backtracking==0 ) { | ||
| 3741 | 6024 | ||
| 3742 | if (current==null) { | 6025 | afterParserOrEnumRuleCall(); |
| 3743 | current = createModelElementForParent(grammarAccess.getPredicateRule()); | 6026 | |
| 3744 | } | 6027 | } |
| 3745 | set( | ||
| 3746 | current, | ||
| 3747 | "symbol", | ||
| 3748 | lv_symbol_1_0, | ||
| 3749 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 3750 | afterParserOrEnumRuleCall(); | ||
| 3751 | |||
| 3752 | 6028 | ||
| 3753 | } | 6029 | } |
| 3754 | 6030 | ||
| 3755 | 6031 | ||
| 3756 | } | 6032 | } |
| 3757 | 6033 | ||
| 3758 | // InternalSolverLanguage.g:1261:3: (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? | 6034 | // InternalSolverLanguage.g:2135:3: ( ( ruleQualifiedName ) ) |
| 3759 | int alt20=2; | 6035 | // InternalSolverLanguage.g:2136:4: ( ruleQualifiedName ) |
| 3760 | int LA20_0 = input.LA(1); | 6036 | { |
| 6037 | // InternalSolverLanguage.g:2136:4: ( ruleQualifiedName ) | ||
| 6038 | // InternalSolverLanguage.g:2137:5: ruleQualifiedName | ||
| 6039 | { | ||
| 6040 | if ( state.backtracking==0 ) { | ||
| 3761 | 6041 | ||
| 3762 | if ( (LA20_0==17) ) { | 6042 | if (current==null) { |
| 3763 | alt20=1; | 6043 | current = createModelElement(grammarAccess.getTypedArgumentRule()); |
| 6044 | } | ||
| 6045 | |||
| 3764 | } | 6046 | } |
| 3765 | switch (alt20) { | 6047 | if ( state.backtracking==0 ) { |
| 3766 | case 1 : | ||
| 3767 | // InternalSolverLanguage.g:1262:4: otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' | ||
| 3768 | { | ||
| 3769 | otherlv_2=(Token)match(input,17,FOLLOW_15); | ||
| 3770 | |||
| 3771 | newLeafNode(otherlv_2, grammarAccess.getPredicateAccess().getLeftParenthesisKeyword_2_0()); | ||
| 3772 | |||
| 3773 | // InternalSolverLanguage.g:1266:4: ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? | ||
| 3774 | int alt19=2; | ||
| 3775 | int LA19_0 = input.LA(1); | ||
| 3776 | 6048 | ||
| 3777 | if ( (LA19_0==RULE_ID) ) { | 6049 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); |
| 3778 | alt19=1; | 6050 | |
| 3779 | } | 6051 | } |
| 3780 | switch (alt19) { | 6052 | pushFollow(FOLLOW_2); |
| 3781 | case 1 : | 6053 | ruleQualifiedName(); |
| 3782 | // InternalSolverLanguage.g:1267:5: ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* | ||
| 3783 | { | ||
| 3784 | // InternalSolverLanguage.g:1267:5: ( (lv_parameters_3_0= ruleParameter ) ) | ||
| 3785 | // InternalSolverLanguage.g:1268:6: (lv_parameters_3_0= ruleParameter ) | ||
| 3786 | { | ||
| 3787 | // InternalSolverLanguage.g:1268:6: (lv_parameters_3_0= ruleParameter ) | ||
| 3788 | // InternalSolverLanguage.g:1269:7: lv_parameters_3_0= ruleParameter | ||
| 3789 | { | ||
| 3790 | 6054 | ||
| 3791 | newCompositeNode(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_0_0()); | 6055 | state._fsp--; |
| 3792 | 6056 | if (state.failed) return current; | |
| 3793 | pushFollow(FOLLOW_8); | 6057 | if ( state.backtracking==0 ) { |
| 3794 | lv_parameters_3_0=ruleParameter(); | ||
| 3795 | 6058 | ||
| 3796 | state._fsp--; | 6059 | afterParserOrEnumRuleCall(); |
| 6060 | |||
| 6061 | } | ||
| 3797 | 6062 | ||
| 6063 | } | ||
| 3798 | 6064 | ||
| 3799 | if (current==null) { | ||
| 3800 | current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 3801 | } | ||
| 3802 | add( | ||
| 3803 | current, | ||
| 3804 | "parameters", | ||
| 3805 | lv_parameters_3_0, | ||
| 3806 | "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | ||
| 3807 | afterParserOrEnumRuleCall(); | ||
| 3808 | |||
| 3809 | 6065 | ||
| 3810 | } | 6066 | } |
| 3811 | 6067 | ||
| 3812 | 6068 | ||
| 3813 | } | 6069 | } |
| 3814 | 6070 | ||
| 3815 | // InternalSolverLanguage.g:1286:5: (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* | ||
| 3816 | loop18: | ||
| 3817 | do { | ||
| 3818 | int alt18=2; | ||
| 3819 | int LA18_0 = input.LA(1); | ||
| 3820 | 6071 | ||
| 3821 | if ( (LA18_0==18) ) { | 6072 | } |
| 3822 | alt18=1; | ||
| 3823 | } | ||
| 3824 | 6073 | ||
| 6074 | if ( state.backtracking==0 ) { | ||
| 3825 | 6075 | ||
| 3826 | switch (alt18) { | 6076 | leaveRule(); |
| 3827 | case 1 : | ||
| 3828 | // InternalSolverLanguage.g:1287:6: otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) | ||
| 3829 | { | ||
| 3830 | otherlv_4=(Token)match(input,18,FOLLOW_12); | ||
| 3831 | 6077 | ||
| 3832 | newLeafNode(otherlv_4, grammarAccess.getPredicateAccess().getCommaKeyword_2_1_1_0()); | 6078 | } |
| 3833 | 6079 | } | |
| 3834 | // InternalSolverLanguage.g:1291:6: ( (lv_parameters_5_0= ruleParameter ) ) | ||
| 3835 | // InternalSolverLanguage.g:1292:7: (lv_parameters_5_0= ruleParameter ) | ||
| 3836 | { | ||
| 3837 | // InternalSolverLanguage.g:1292:7: (lv_parameters_5_0= ruleParameter ) | ||
| 3838 | // InternalSolverLanguage.g:1293:8: lv_parameters_5_0= ruleParameter | ||
| 3839 | { | ||
| 3840 | 6080 | ||
| 3841 | newCompositeNode(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_1_1_0()); | 6081 | catch (RecognitionException re) { |
| 3842 | 6082 | recover(input,re); | |
| 3843 | pushFollow(FOLLOW_8); | 6083 | appendSkippedTokens(); |
| 3844 | lv_parameters_5_0=ruleParameter(); | 6084 | } |
| 6085 | finally { | ||
| 6086 | } | ||
| 6087 | return current; | ||
| 6088 | } | ||
| 6089 | // $ANTLR end "ruleTypedArgument" | ||
| 3845 | 6090 | ||
| 3846 | state._fsp--; | ||
| 3847 | 6091 | ||
| 6092 | // $ANTLR start "entryRuleTypedStarArgument" | ||
| 6093 | // InternalSolverLanguage.g:2155:1: entryRuleTypedStarArgument returns [EObject current=null] : iv_ruleTypedStarArgument= ruleTypedStarArgument EOF ; | ||
| 6094 | public final EObject entryRuleTypedStarArgument() throws RecognitionException { | ||
| 6095 | EObject current = null; | ||
| 3848 | 6096 | ||
| 3849 | if (current==null) { | 6097 | EObject iv_ruleTypedStarArgument = null; |
| 3850 | current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 3851 | } | ||
| 3852 | add( | ||
| 3853 | current, | ||
| 3854 | "parameters", | ||
| 3855 | lv_parameters_5_0, | ||
| 3856 | "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | ||
| 3857 | afterParserOrEnumRuleCall(); | ||
| 3858 | |||
| 3859 | 6098 | ||
| 3860 | } | ||
| 3861 | 6099 | ||
| 6100 | try { | ||
| 6101 | // InternalSolverLanguage.g:2155:58: (iv_ruleTypedStarArgument= ruleTypedStarArgument EOF ) | ||
| 6102 | // InternalSolverLanguage.g:2156:2: iv_ruleTypedStarArgument= ruleTypedStarArgument EOF | ||
| 6103 | { | ||
| 6104 | if ( state.backtracking==0 ) { | ||
| 6105 | newCompositeNode(grammarAccess.getTypedStarArgumentRule()); | ||
| 6106 | } | ||
| 6107 | pushFollow(FOLLOW_1); | ||
| 6108 | iv_ruleTypedStarArgument=ruleTypedStarArgument(); | ||
| 3862 | 6109 | ||
| 3863 | } | 6110 | state._fsp--; |
| 6111 | if (state.failed) return current; | ||
| 6112 | if ( state.backtracking==0 ) { | ||
| 6113 | current =iv_ruleTypedStarArgument; | ||
| 6114 | } | ||
| 6115 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 3864 | 6116 | ||
| 6117 | } | ||
| 3865 | 6118 | ||
| 3866 | } | 6119 | } |
| 3867 | break; | ||
| 3868 | 6120 | ||
| 3869 | default : | 6121 | catch (RecognitionException re) { |
| 3870 | break loop18; | 6122 | recover(input,re); |
| 3871 | } | 6123 | appendSkippedTokens(); |
| 3872 | } while (true); | 6124 | } |
| 6125 | finally { | ||
| 6126 | } | ||
| 6127 | return current; | ||
| 6128 | } | ||
| 6129 | // $ANTLR end "entryRuleTypedStarArgument" | ||
| 3873 | 6130 | ||
| 3874 | 6131 | ||
| 3875 | } | 6132 | // $ANTLR start "ruleTypedStarArgument" |
| 3876 | break; | 6133 | // InternalSolverLanguage.g:2162:1: ruleTypedStarArgument returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) otherlv_1= '*' ) ; |
| 6134 | public final EObject ruleTypedStarArgument() throws RecognitionException { | ||
| 6135 | EObject current = null; | ||
| 3877 | 6136 | ||
| 3878 | } | 6137 | Token otherlv_1=null; |
| 3879 | 6138 | ||
| 3880 | otherlv_6=(Token)match(input,19,FOLLOW_16); | ||
| 3881 | 6139 | ||
| 3882 | newLeafNode(otherlv_6, grammarAccess.getPredicateAccess().getRightParenthesisKeyword_2_2()); | 6140 | enterRule(); |
| 3883 | |||
| 3884 | 6141 | ||
| 3885 | } | 6142 | try { |
| 3886 | break; | 6143 | // InternalSolverLanguage.g:2168:2: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '*' ) ) |
| 6144 | // InternalSolverLanguage.g:2169:2: ( ( ( ruleQualifiedName ) ) otherlv_1= '*' ) | ||
| 6145 | { | ||
| 6146 | // InternalSolverLanguage.g:2169:2: ( ( ( ruleQualifiedName ) ) otherlv_1= '*' ) | ||
| 6147 | // InternalSolverLanguage.g:2170:3: ( ( ruleQualifiedName ) ) otherlv_1= '*' | ||
| 6148 | { | ||
| 6149 | // InternalSolverLanguage.g:2170:3: ( ( ruleQualifiedName ) ) | ||
| 6150 | // InternalSolverLanguage.g:2171:4: ( ruleQualifiedName ) | ||
| 6151 | { | ||
| 6152 | // InternalSolverLanguage.g:2171:4: ( ruleQualifiedName ) | ||
| 6153 | // InternalSolverLanguage.g:2172:5: ruleQualifiedName | ||
| 6154 | { | ||
| 6155 | if ( state.backtracking==0 ) { | ||
| 3887 | 6156 | ||
| 6157 | if (current==null) { | ||
| 6158 | current = createModelElement(grammarAccess.getTypedStarArgumentRule()); | ||
| 6159 | } | ||
| 6160 | |||
| 3888 | } | 6161 | } |
| 6162 | if ( state.backtracking==0 ) { | ||
| 3889 | 6163 | ||
| 3890 | otherlv_7=(Token)match(input,28,FOLLOW_17); | 6164 | newCompositeNode(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); |
| 6165 | |||
| 6166 | } | ||
| 6167 | pushFollow(FOLLOW_36); | ||
| 6168 | ruleQualifiedName(); | ||
| 3891 | 6169 | ||
| 3892 | newLeafNode(otherlv_7, grammarAccess.getPredicateAccess().getColonHyphenMinusKeyword_3()); | 6170 | state._fsp--; |
| 3893 | 6171 | if (state.failed) return current; | |
| 3894 | // InternalSolverLanguage.g:1321:3: (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) | 6172 | if ( state.backtracking==0 ) { |
| 3895 | int alt22=2; | ||
| 3896 | int LA22_0 = input.LA(1); | ||
| 3897 | 6173 | ||
| 3898 | if ( (LA22_0==14) ) { | 6174 | afterParserOrEnumRuleCall(); |
| 3899 | alt22=1; | 6175 | |
| 3900 | } | 6176 | } |
| 3901 | else if ( (LA22_0==EOF||LA22_0==RULE_ID||(LA22_0>=11 && LA22_0<=13)||(LA22_0>=29 && LA22_0<=31)) ) { | ||
| 3902 | alt22=2; | ||
| 3903 | } | ||
| 3904 | else { | ||
| 3905 | NoViableAltException nvae = | ||
| 3906 | new NoViableAltException("", 22, 0, input); | ||
| 3907 | 6177 | ||
| 3908 | throw nvae; | ||
| 3909 | } | 6178 | } |
| 3910 | switch (alt22) { | ||
| 3911 | case 1 : | ||
| 3912 | // InternalSolverLanguage.g:1322:4: otherlv_8= 'false' | ||
| 3913 | { | ||
| 3914 | otherlv_8=(Token)match(input,14,FOLLOW_5); | ||
| 3915 | 6179 | ||
| 3916 | newLeafNode(otherlv_8, grammarAccess.getPredicateAccess().getFalseKeyword_4_0()); | ||
| 3917 | |||
| 3918 | 6180 | ||
| 3919 | } | 6181 | } |
| 3920 | break; | ||
| 3921 | case 2 : | ||
| 3922 | // InternalSolverLanguage.g:1327:4: ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) | ||
| 3923 | { | ||
| 3924 | // InternalSolverLanguage.g:1327:4: ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) | ||
| 3925 | // InternalSolverLanguage.g:1328:5: ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* | ||
| 3926 | { | ||
| 3927 | // InternalSolverLanguage.g:1328:5: ( (lv_bodies_9_0= rulePatternBody ) ) | ||
| 3928 | // InternalSolverLanguage.g:1329:6: (lv_bodies_9_0= rulePatternBody ) | ||
| 3929 | { | ||
| 3930 | // InternalSolverLanguage.g:1329:6: (lv_bodies_9_0= rulePatternBody ) | ||
| 3931 | // InternalSolverLanguage.g:1330:7: lv_bodies_9_0= rulePatternBody | ||
| 3932 | { | ||
| 3933 | 6182 | ||
| 3934 | newCompositeNode(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_0_0()); | 6183 | otherlv_1=(Token)match(input,35,FOLLOW_2); if (state.failed) return current; |
| 3935 | 6184 | if ( state.backtracking==0 ) { | |
| 3936 | pushFollow(FOLLOW_18); | ||
| 3937 | lv_bodies_9_0=rulePatternBody(); | ||
| 3938 | 6185 | ||
| 3939 | state._fsp--; | 6186 | newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); |
| 6187 | |||
| 6188 | } | ||
| 3940 | 6189 | ||
| 6190 | } | ||
| 3941 | 6191 | ||
| 3942 | if (current==null) { | ||
| 3943 | current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 3944 | } | ||
| 3945 | add( | ||
| 3946 | current, | ||
| 3947 | "bodies", | ||
| 3948 | lv_bodies_9_0, | ||
| 3949 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | ||
| 3950 | afterParserOrEnumRuleCall(); | ||
| 3951 | |||
| 3952 | 6192 | ||
| 3953 | } | 6193 | } |
| 3954 | 6194 | ||
| 6195 | if ( state.backtracking==0 ) { | ||
| 3955 | 6196 | ||
| 3956 | } | 6197 | leaveRule(); |
| 3957 | 6198 | ||
| 3958 | // InternalSolverLanguage.g:1347:5: (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* | 6199 | } |
| 3959 | loop21: | 6200 | } |
| 3960 | do { | ||
| 3961 | int alt21=2; | ||
| 3962 | int LA21_0 = input.LA(1); | ||
| 3963 | 6201 | ||
| 3964 | if ( (LA21_0==29) ) { | 6202 | catch (RecognitionException re) { |
| 3965 | alt21=1; | 6203 | recover(input,re); |
| 3966 | } | 6204 | appendSkippedTokens(); |
| 6205 | } | ||
| 6206 | finally { | ||
| 6207 | } | ||
| 6208 | return current; | ||
| 6209 | } | ||
| 6210 | // $ANTLR end "ruleTypedStarArgument" | ||
| 3967 | 6211 | ||
| 3968 | 6212 | ||
| 3969 | switch (alt21) { | 6213 | // $ANTLR start "entryRuleReference" |
| 3970 | case 1 : | 6214 | // InternalSolverLanguage.g:2194:1: entryRuleReference returns [EObject current=null] : iv_ruleReference= ruleReference EOF ; |
| 3971 | // InternalSolverLanguage.g:1348:6: otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) | 6215 | public final EObject entryRuleReference() throws RecognitionException { |
| 3972 | { | 6216 | EObject current = null; |
| 3973 | otherlv_10=(Token)match(input,29,FOLLOW_19); | ||
| 3974 | 6217 | ||
| 3975 | newLeafNode(otherlv_10, grammarAccess.getPredicateAccess().getVerticalLineKeyword_4_1_1_0()); | 6218 | EObject iv_ruleReference = null; |
| 3976 | |||
| 3977 | // InternalSolverLanguage.g:1352:6: ( (lv_bodies_11_0= rulePatternBody ) ) | ||
| 3978 | // InternalSolverLanguage.g:1353:7: (lv_bodies_11_0= rulePatternBody ) | ||
| 3979 | { | ||
| 3980 | // InternalSolverLanguage.g:1353:7: (lv_bodies_11_0= rulePatternBody ) | ||
| 3981 | // InternalSolverLanguage.g:1354:8: lv_bodies_11_0= rulePatternBody | ||
| 3982 | { | ||
| 3983 | 6219 | ||
| 3984 | newCompositeNode(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_1_1_0()); | ||
| 3985 | |||
| 3986 | pushFollow(FOLLOW_18); | ||
| 3987 | lv_bodies_11_0=rulePatternBody(); | ||
| 3988 | 6220 | ||
| 3989 | state._fsp--; | 6221 | try { |
| 6222 | // InternalSolverLanguage.g:2194:50: (iv_ruleReference= ruleReference EOF ) | ||
| 6223 | // InternalSolverLanguage.g:2195:2: iv_ruleReference= ruleReference EOF | ||
| 6224 | { | ||
| 6225 | if ( state.backtracking==0 ) { | ||
| 6226 | newCompositeNode(grammarAccess.getReferenceRule()); | ||
| 6227 | } | ||
| 6228 | pushFollow(FOLLOW_1); | ||
| 6229 | iv_ruleReference=ruleReference(); | ||
| 3990 | 6230 | ||
| 6231 | state._fsp--; | ||
| 6232 | if (state.failed) return current; | ||
| 6233 | if ( state.backtracking==0 ) { | ||
| 6234 | current =iv_ruleReference; | ||
| 6235 | } | ||
| 6236 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 3991 | 6237 | ||
| 3992 | if (current==null) { | 6238 | } |
| 3993 | current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 3994 | } | ||
| 3995 | add( | ||
| 3996 | current, | ||
| 3997 | "bodies", | ||
| 3998 | lv_bodies_11_0, | ||
| 3999 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | ||
| 4000 | afterParserOrEnumRuleCall(); | ||
| 4001 | |||
| 4002 | 6239 | ||
| 4003 | } | 6240 | } |
| 4004 | 6241 | ||
| 6242 | catch (RecognitionException re) { | ||
| 6243 | recover(input,re); | ||
| 6244 | appendSkippedTokens(); | ||
| 6245 | } | ||
| 6246 | finally { | ||
| 6247 | } | ||
| 6248 | return current; | ||
| 6249 | } | ||
| 6250 | // $ANTLR end "entryRuleReference" | ||
| 4005 | 6251 | ||
| 4006 | } | ||
| 4007 | 6252 | ||
| 6253 | // $ANTLR start "ruleReference" | ||
| 6254 | // InternalSolverLanguage.g:2201:1: ruleReference returns [EObject current=null] : ( ( ruleQualifiedName ) ) ; | ||
| 6255 | public final EObject ruleReference() throws RecognitionException { | ||
| 6256 | EObject current = null; | ||
| 4008 | 6257 | ||
| 4009 | } | ||
| 4010 | break; | ||
| 4011 | 6258 | ||
| 4012 | default : | 6259 | enterRule(); |
| 4013 | break loop21; | ||
| 4014 | } | ||
| 4015 | } while (true); | ||
| 4016 | 6260 | ||
| 6261 | try { | ||
| 6262 | // InternalSolverLanguage.g:2207:2: ( ( ( ruleQualifiedName ) ) ) | ||
| 6263 | // InternalSolverLanguage.g:2208:2: ( ( ruleQualifiedName ) ) | ||
| 6264 | { | ||
| 6265 | // InternalSolverLanguage.g:2208:2: ( ( ruleQualifiedName ) ) | ||
| 6266 | // InternalSolverLanguage.g:2209:3: ( ruleQualifiedName ) | ||
| 6267 | { | ||
| 6268 | // InternalSolverLanguage.g:2209:3: ( ruleQualifiedName ) | ||
| 6269 | // InternalSolverLanguage.g:2210:4: ruleQualifiedName | ||
| 6270 | { | ||
| 6271 | if ( state.backtracking==0 ) { | ||
| 4017 | 6272 | ||
| 4018 | } | 6273 | if (current==null) { |
| 6274 | current = createModelElement(grammarAccess.getReferenceRule()); | ||
| 6275 | } | ||
| 6276 | |||
| 6277 | } | ||
| 6278 | if ( state.backtracking==0 ) { | ||
| 4019 | 6279 | ||
| 6280 | newCompositeNode(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); | ||
| 6281 | |||
| 6282 | } | ||
| 6283 | pushFollow(FOLLOW_2); | ||
| 6284 | ruleQualifiedName(); | ||
| 4020 | 6285 | ||
| 4021 | } | 6286 | state._fsp--; |
| 4022 | break; | 6287 | if (state.failed) return current; |
| 6288 | if ( state.backtracking==0 ) { | ||
| 4023 | 6289 | ||
| 6290 | afterParserOrEnumRuleCall(); | ||
| 6291 | |||
| 4024 | } | 6292 | } |
| 4025 | 6293 | ||
| 4026 | otherlv_12=(Token)match(input,12,FOLLOW_2); | 6294 | } |
| 4027 | 6295 | ||
| 4028 | newLeafNode(otherlv_12, grammarAccess.getPredicateAccess().getFullStopKeyword_5()); | ||
| 4029 | |||
| 4030 | 6296 | ||
| 4031 | } | 6297 | } |
| 4032 | 6298 | ||
| 4033 | 6299 | ||
| 4034 | } | 6300 | } |
| 4035 | 6301 | ||
| 6302 | if ( state.backtracking==0 ) { | ||
| 4036 | 6303 | ||
| 4037 | leaveRule(); | 6304 | leaveRule(); |
| 4038 | 6305 | ||
| 6306 | } | ||
| 4039 | } | 6307 | } |
| 4040 | 6308 | ||
| 4041 | catch (RecognitionException re) { | 6309 | catch (RecognitionException re) { |
| @@ -4046,29 +6314,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4046 | } | 6314 | } |
| 4047 | return current; | 6315 | return current; |
| 4048 | } | 6316 | } |
| 4049 | // $ANTLR end "rulePredicate" | 6317 | // $ANTLR end "ruleReference" |
| 4050 | 6318 | ||
| 4051 | 6319 | ||
| 4052 | // $ANTLR start "entryRuleParameter" | 6320 | // $ANTLR start "entryRuleInterval" |
| 4053 | // InternalSolverLanguage.g:1382:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; | 6321 | // InternalSolverLanguage.g:2227:1: entryRuleInterval returns [EObject current=null] : iv_ruleInterval= ruleInterval EOF ; |
| 4054 | public final EObject entryRuleParameter() throws RecognitionException { | 6322 | public final EObject entryRuleInterval() throws RecognitionException { |
| 4055 | EObject current = null; | 6323 | EObject current = null; |
| 4056 | 6324 | ||
| 4057 | EObject iv_ruleParameter = null; | 6325 | EObject iv_ruleInterval = null; |
| 4058 | 6326 | ||
| 4059 | 6327 | ||
| 4060 | try { | 6328 | try { |
| 4061 | // InternalSolverLanguage.g:1382:50: (iv_ruleParameter= ruleParameter EOF ) | 6329 | // InternalSolverLanguage.g:2227:49: (iv_ruleInterval= ruleInterval EOF ) |
| 4062 | // InternalSolverLanguage.g:1383:2: iv_ruleParameter= ruleParameter EOF | 6330 | // InternalSolverLanguage.g:2228:2: iv_ruleInterval= ruleInterval EOF |
| 4063 | { | 6331 | { |
| 4064 | newCompositeNode(grammarAccess.getParameterRule()); | 6332 | if ( state.backtracking==0 ) { |
| 6333 | newCompositeNode(grammarAccess.getIntervalRule()); | ||
| 6334 | } | ||
| 4065 | pushFollow(FOLLOW_1); | 6335 | pushFollow(FOLLOW_1); |
| 4066 | iv_ruleParameter=ruleParameter(); | 6336 | iv_ruleInterval=ruleInterval(); |
| 4067 | 6337 | ||
| 4068 | state._fsp--; | 6338 | state._fsp--; |
| 4069 | 6339 | if (state.failed) return current; | |
| 4070 | current =iv_ruleParameter; | 6340 | if ( state.backtracking==0 ) { |
| 4071 | match(input,EOF,FOLLOW_2); | 6341 | current =iv_ruleInterval; |
| 6342 | } | ||
| 6343 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 4072 | 6344 | ||
| 4073 | } | 6345 | } |
| 4074 | 6346 | ||
| @@ -4082,122 +6354,131 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4082 | } | 6354 | } |
| 4083 | return current; | 6355 | return current; |
| 4084 | } | 6356 | } |
| 4085 | // $ANTLR end "entryRuleParameter" | 6357 | // $ANTLR end "entryRuleInterval" |
| 4086 | 6358 | ||
| 4087 | 6359 | ||
| 4088 | // $ANTLR start "ruleParameter" | 6360 | // $ANTLR start "ruleInterval" |
| 4089 | // InternalSolverLanguage.g:1389:1: ruleParameter returns [EObject current=null] : ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) ; | 6361 | // InternalSolverLanguage.g:2234:1: ruleInterval returns [EObject current=null] : (otherlv_0= '[' ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= ']' ) ; |
| 4090 | public final EObject ruleParameter() throws RecognitionException { | 6362 | public final EObject ruleInterval() throws RecognitionException { |
| 4091 | EObject current = null; | 6363 | EObject current = null; |
| 4092 | 6364 | ||
| 4093 | Token otherlv_1=null; | 6365 | Token otherlv_0=null; |
| 4094 | EObject lv_variable_0_0 = null; | 6366 | Token otherlv_2=null; |
| 6367 | Token otherlv_4=null; | ||
| 6368 | EObject lv_lowerBound_1_0 = null; | ||
| 4095 | 6369 | ||
| 4096 | EObject lv_type_2_0 = null; | 6370 | EObject lv_upperBound_3_0 = null; |
| 4097 | 6371 | ||
| 4098 | 6372 | ||
| 4099 | 6373 | ||
| 4100 | enterRule(); | 6374 | enterRule(); |
| 4101 | 6375 | ||
| 4102 | try { | 6376 | try { |
| 4103 | // InternalSolverLanguage.g:1395:2: ( ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) ) | 6377 | // InternalSolverLanguage.g:2240:2: ( (otherlv_0= '[' ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= ']' ) ) |
| 4104 | // InternalSolverLanguage.g:1396:2: ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) | 6378 | // InternalSolverLanguage.g:2241:2: (otherlv_0= '[' ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= ']' ) |
| 4105 | { | 6379 | { |
| 4106 | // InternalSolverLanguage.g:1396:2: ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) | 6380 | // InternalSolverLanguage.g:2241:2: (otherlv_0= '[' ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= ']' ) |
| 4107 | // InternalSolverLanguage.g:1397:3: ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? | 6381 | // InternalSolverLanguage.g:2242:3: otherlv_0= '[' ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= ']' |
| 4108 | { | 6382 | { |
| 4109 | // InternalSolverLanguage.g:1397:3: ( (lv_variable_0_0= ruleVariable ) ) | 6383 | otherlv_0=(Token)match(input,36,FOLLOW_6); if (state.failed) return current; |
| 4110 | // InternalSolverLanguage.g:1398:4: (lv_variable_0_0= ruleVariable ) | 6384 | if ( state.backtracking==0 ) { |
| 6385 | |||
| 6386 | newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); | ||
| 6387 | |||
| 6388 | } | ||
| 6389 | // InternalSolverLanguage.g:2246:3: ( (lv_lowerBound_1_0= ruleExpression ) ) | ||
| 6390 | // InternalSolverLanguage.g:2247:4: (lv_lowerBound_1_0= ruleExpression ) | ||
| 4111 | { | 6391 | { |
| 4112 | // InternalSolverLanguage.g:1398:4: (lv_variable_0_0= ruleVariable ) | 6392 | // InternalSolverLanguage.g:2247:4: (lv_lowerBound_1_0= ruleExpression ) |
| 4113 | // InternalSolverLanguage.g:1399:5: lv_variable_0_0= ruleVariable | 6393 | // InternalSolverLanguage.g:2248:5: lv_lowerBound_1_0= ruleExpression |
| 4114 | { | 6394 | { |
| 6395 | if ( state.backtracking==0 ) { | ||
| 4115 | 6396 | ||
| 4116 | newCompositeNode(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); | 6397 | newCompositeNode(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); |
| 4117 | 6398 | ||
| 4118 | pushFollow(FOLLOW_20); | 6399 | } |
| 4119 | lv_variable_0_0=ruleVariable(); | 6400 | pushFollow(FOLLOW_37); |
| 6401 | lv_lowerBound_1_0=ruleExpression(); | ||
| 4120 | 6402 | ||
| 4121 | state._fsp--; | 6403 | state._fsp--; |
| 6404 | if (state.failed) return current; | ||
| 6405 | if ( state.backtracking==0 ) { | ||
| 4122 | 6406 | ||
| 4123 | 6407 | if (current==null) { | |
| 4124 | if (current==null) { | 6408 | current = createModelElementForParent(grammarAccess.getIntervalRule()); |
| 4125 | current = createModelElementForParent(grammarAccess.getParameterRule()); | 6409 | } |
| 4126 | } | 6410 | set( |
| 4127 | set( | 6411 | current, |
| 4128 | current, | 6412 | "lowerBound", |
| 4129 | "variable", | 6413 | lv_lowerBound_1_0, |
| 4130 | lv_variable_0_0, | 6414 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
| 4131 | "org.eclipse.viatra.solver.language.SolverLanguage.Variable"); | 6415 | afterParserOrEnumRuleCall(); |
| 4132 | afterParserOrEnumRuleCall(); | 6416 | |
| 4133 | |||
| 4134 | |||
| 4135 | } | 6417 | } |
| 4136 | 6418 | ||
| 4137 | |||
| 4138 | } | 6419 | } |
| 4139 | 6420 | ||
| 4140 | // InternalSolverLanguage.g:1416:3: (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? | ||
| 4141 | int alt23=2; | ||
| 4142 | int LA23_0 = input.LA(1); | ||
| 4143 | 6421 | ||
| 4144 | if ( (LA23_0==20) ) { | ||
| 4145 | alt23=1; | ||
| 4146 | } | 6422 | } |
| 4147 | switch (alt23) { | ||
| 4148 | case 1 : | ||
| 4149 | // InternalSolverLanguage.g:1417:4: otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) | ||
| 4150 | { | ||
| 4151 | otherlv_1=(Token)match(input,20,FOLLOW_21); | ||
| 4152 | 6423 | ||
| 4153 | newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getColonKeyword_1_0()); | 6424 | otherlv_2=(Token)match(input,37,FOLLOW_6); if (state.failed) return current; |
| 4154 | 6425 | if ( state.backtracking==0 ) { | |
| 4155 | // InternalSolverLanguage.g:1421:4: ( (lv_type_2_0= ruleSymbol ) ) | ||
| 4156 | // InternalSolverLanguage.g:1422:5: (lv_type_2_0= ruleSymbol ) | ||
| 4157 | { | ||
| 4158 | // InternalSolverLanguage.g:1422:5: (lv_type_2_0= ruleSymbol ) | ||
| 4159 | // InternalSolverLanguage.g:1423:6: lv_type_2_0= ruleSymbol | ||
| 4160 | { | ||
| 4161 | |||
| 4162 | newCompositeNode(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); | ||
| 4163 | |||
| 4164 | pushFollow(FOLLOW_2); | ||
| 4165 | lv_type_2_0=ruleSymbol(); | ||
| 4166 | 6426 | ||
| 4167 | state._fsp--; | 6427 | newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); |
| 6428 | |||
| 6429 | } | ||
| 6430 | // InternalSolverLanguage.g:2269:3: ( (lv_upperBound_3_0= ruleExpression ) ) | ||
| 6431 | // InternalSolverLanguage.g:2270:4: (lv_upperBound_3_0= ruleExpression ) | ||
| 6432 | { | ||
| 6433 | // InternalSolverLanguage.g:2270:4: (lv_upperBound_3_0= ruleExpression ) | ||
| 6434 | // InternalSolverLanguage.g:2271:5: lv_upperBound_3_0= ruleExpression | ||
| 6435 | { | ||
| 6436 | if ( state.backtracking==0 ) { | ||
| 4168 | 6437 | ||
| 6438 | newCompositeNode(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); | ||
| 6439 | |||
| 6440 | } | ||
| 6441 | pushFollow(FOLLOW_38); | ||
| 6442 | lv_upperBound_3_0=ruleExpression(); | ||
| 4169 | 6443 | ||
| 4170 | if (current==null) { | 6444 | state._fsp--; |
| 4171 | current = createModelElementForParent(grammarAccess.getParameterRule()); | 6445 | if (state.failed) return current; |
| 4172 | } | 6446 | if ( state.backtracking==0 ) { |
| 4173 | set( | ||
| 4174 | current, | ||
| 4175 | "type", | ||
| 4176 | lv_type_2_0, | ||
| 4177 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 4178 | afterParserOrEnumRuleCall(); | ||
| 4179 | |||
| 4180 | 6447 | ||
| 4181 | } | 6448 | if (current==null) { |
| 6449 | current = createModelElementForParent(grammarAccess.getIntervalRule()); | ||
| 6450 | } | ||
| 6451 | set( | ||
| 6452 | current, | ||
| 6453 | "upperBound", | ||
| 6454 | lv_upperBound_3_0, | ||
| 6455 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 6456 | afterParserOrEnumRuleCall(); | ||
| 6457 | |||
| 6458 | } | ||
| 4182 | 6459 | ||
| 6460 | } | ||
| 4183 | 6461 | ||
| 4184 | } | ||
| 4185 | 6462 | ||
| 6463 | } | ||
| 4186 | 6464 | ||
| 4187 | } | 6465 | otherlv_4=(Token)match(input,38,FOLLOW_2); if (state.failed) return current; |
| 4188 | break; | 6466 | if ( state.backtracking==0 ) { |
| 4189 | 6467 | ||
| 6468 | newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); | ||
| 6469 | |||
| 4190 | } | 6470 | } |
| 4191 | 6471 | ||
| 4192 | |||
| 4193 | } | 6472 | } |
| 4194 | 6473 | ||
| 4195 | 6474 | ||
| 4196 | } | 6475 | } |
| 4197 | 6476 | ||
| 6477 | if ( state.backtracking==0 ) { | ||
| 4198 | 6478 | ||
| 4199 | leaveRule(); | 6479 | leaveRule(); |
| 4200 | 6480 | ||
| 6481 | } | ||
| 4201 | } | 6482 | } |
| 4202 | 6483 | ||
| 4203 | catch (RecognitionException re) { | 6484 | catch (RecognitionException re) { |
| @@ -4208,29 +6489,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4208 | } | 6489 | } |
| 4209 | return current; | 6490 | return current; |
| 4210 | } | 6491 | } |
| 4211 | // $ANTLR end "ruleParameter" | 6492 | // $ANTLR end "ruleInterval" |
| 4212 | 6493 | ||
| 4213 | 6494 | ||
| 4214 | // $ANTLR start "entryRulePatternBody" | 6495 | // $ANTLR start "entryRuleLiteral" |
| 4215 | // InternalSolverLanguage.g:1445:1: entryRulePatternBody returns [EObject current=null] : iv_rulePatternBody= rulePatternBody EOF ; | 6496 | // InternalSolverLanguage.g:2296:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; |
| 4216 | public final EObject entryRulePatternBody() throws RecognitionException { | 6497 | public final EObject entryRuleLiteral() throws RecognitionException { |
| 4217 | EObject current = null; | 6498 | EObject current = null; |
| 4218 | 6499 | ||
| 4219 | EObject iv_rulePatternBody = null; | 6500 | EObject iv_ruleLiteral = null; |
| 4220 | 6501 | ||
| 4221 | 6502 | ||
| 4222 | try { | 6503 | try { |
| 4223 | // InternalSolverLanguage.g:1445:52: (iv_rulePatternBody= rulePatternBody EOF ) | 6504 | // InternalSolverLanguage.g:2296:48: (iv_ruleLiteral= ruleLiteral EOF ) |
| 4224 | // InternalSolverLanguage.g:1446:2: iv_rulePatternBody= rulePatternBody EOF | 6505 | // InternalSolverLanguage.g:2297:2: iv_ruleLiteral= ruleLiteral EOF |
| 4225 | { | 6506 | { |
| 4226 | newCompositeNode(grammarAccess.getPatternBodyRule()); | 6507 | if ( state.backtracking==0 ) { |
| 6508 | newCompositeNode(grammarAccess.getLiteralRule()); | ||
| 6509 | } | ||
| 4227 | pushFollow(FOLLOW_1); | 6510 | pushFollow(FOLLOW_1); |
| 4228 | iv_rulePatternBody=rulePatternBody(); | 6511 | iv_ruleLiteral=ruleLiteral(); |
| 4229 | 6512 | ||
| 4230 | state._fsp--; | 6513 | state._fsp--; |
| 4231 | 6514 | if (state.failed) return current; | |
| 4232 | current =iv_rulePatternBody; | 6515 | if ( state.backtracking==0 ) { |
| 4233 | match(input,EOF,FOLLOW_2); | 6516 | current =iv_ruleLiteral; |
| 6517 | } | ||
| 6518 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 4234 | 6519 | ||
| 4235 | } | 6520 | } |
| 4236 | 6521 | ||
| @@ -4244,133 +6529,193 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4244 | } | 6529 | } |
| 4245 | return current; | 6530 | return current; |
| 4246 | } | 6531 | } |
| 4247 | // $ANTLR end "entryRulePatternBody" | 6532 | // $ANTLR end "entryRuleLiteral" |
| 4248 | 6533 | ||
| 4249 | 6534 | ||
| 4250 | // $ANTLR start "rulePatternBody" | 6535 | // $ANTLR start "ruleLiteral" |
| 4251 | // InternalSolverLanguage.g:1452:1: rulePatternBody returns [EObject current=null] : ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) ; | 6536 | // InternalSolverLanguage.g:2303:1: ruleLiteral returns [EObject current=null] : (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) ; |
| 4252 | public final EObject rulePatternBody() throws RecognitionException { | 6537 | public final EObject ruleLiteral() throws RecognitionException { |
| 4253 | EObject current = null; | 6538 | EObject current = null; |
| 4254 | 6539 | ||
| 4255 | Token otherlv_1=null; | 6540 | EObject this_LogicLiteral_0 = null; |
| 4256 | EObject lv_constraints_2_0 = null; | ||
| 4257 | 6541 | ||
| 6542 | EObject this_NumericLiteral_1 = null; | ||
| 4258 | 6543 | ||
| 6544 | EObject this_InfinityLiteral_2 = null; | ||
| 4259 | 6545 | ||
| 4260 | enterRule(); | 6546 | EObject this_EmptyIntervalLiteral_3 = null; |
| 4261 | 6547 | ||
| 4262 | try { | 6548 | EObject this_StringLiteral_4 = null; |
| 4263 | // InternalSolverLanguage.g:1458:2: ( ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) ) | ||
| 4264 | // InternalSolverLanguage.g:1459:2: ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) | ||
| 4265 | { | ||
| 4266 | // InternalSolverLanguage.g:1459:2: ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) | ||
| 4267 | // InternalSolverLanguage.g:1460:3: () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) | ||
| 4268 | { | ||
| 4269 | // InternalSolverLanguage.g:1460:3: () | ||
| 4270 | // InternalSolverLanguage.g:1461:4: | ||
| 4271 | { | ||
| 4272 | 6549 | ||
| 4273 | current = forceCreateModelElement( | ||
| 4274 | grammarAccess.getPatternBodyAccess().getPatternBodyAction_0(), | ||
| 4275 | current); | ||
| 4276 | |||
| 4277 | 6550 | ||
| 4278 | } | ||
| 4279 | 6551 | ||
| 4280 | // InternalSolverLanguage.g:1467:3: (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) | 6552 | enterRule(); |
| 4281 | int alt25=2; | ||
| 4282 | int LA25_0 = input.LA(1); | ||
| 4283 | 6553 | ||
| 4284 | if ( (LA25_0==13) ) { | 6554 | try { |
| 4285 | alt25=1; | 6555 | // InternalSolverLanguage.g:2309:2: ( (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) ) |
| 4286 | } | 6556 | // InternalSolverLanguage.g:2310:2: (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) |
| 4287 | else if ( (LA25_0==EOF||LA25_0==RULE_ID||(LA25_0>=11 && LA25_0<=12)||(LA25_0>=29 && LA25_0<=31)) ) { | 6557 | { |
| 4288 | alt25=2; | 6558 | // InternalSolverLanguage.g:2310:2: (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) |
| 4289 | } | 6559 | int alt26=5; |
| 4290 | else { | 6560 | switch ( input.LA(1) ) { |
| 6561 | case 19: | ||
| 6562 | case 70: | ||
| 6563 | case 71: | ||
| 6564 | case 72: | ||
| 6565 | { | ||
| 6566 | alt26=1; | ||
| 6567 | } | ||
| 6568 | break; | ||
| 6569 | case RULE_INT: | ||
| 6570 | { | ||
| 6571 | alt26=2; | ||
| 6572 | } | ||
| 6573 | break; | ||
| 6574 | case 39: | ||
| 6575 | { | ||
| 6576 | alt26=3; | ||
| 6577 | } | ||
| 6578 | break; | ||
| 6579 | case 40: | ||
| 6580 | { | ||
| 6581 | alt26=4; | ||
| 6582 | } | ||
| 6583 | break; | ||
| 6584 | case RULE_STRING: | ||
| 6585 | { | ||
| 6586 | alt26=5; | ||
| 6587 | } | ||
| 6588 | break; | ||
| 6589 | default: | ||
| 6590 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 4291 | NoViableAltException nvae = | 6591 | NoViableAltException nvae = |
| 4292 | new NoViableAltException("", 25, 0, input); | 6592 | new NoViableAltException("", 26, 0, input); |
| 4293 | 6593 | ||
| 4294 | throw nvae; | 6594 | throw nvae; |
| 4295 | } | 6595 | } |
| 4296 | switch (alt25) { | 6596 | |
| 6597 | switch (alt26) { | ||
| 4297 | case 1 : | 6598 | case 1 : |
| 4298 | // InternalSolverLanguage.g:1468:4: otherlv_1= 'true' | 6599 | // InternalSolverLanguage.g:2311:3: this_LogicLiteral_0= ruleLogicLiteral |
| 4299 | { | 6600 | { |
| 4300 | otherlv_1=(Token)match(input,13,FOLLOW_2); | 6601 | if ( state.backtracking==0 ) { |
| 4301 | 6602 | ||
| 4302 | newLeafNode(otherlv_1, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); | 6603 | newCompositeNode(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); |
| 4303 | 6604 | ||
| 6605 | } | ||
| 6606 | pushFollow(FOLLOW_2); | ||
| 6607 | this_LogicLiteral_0=ruleLogicLiteral(); | ||
| 6608 | |||
| 6609 | state._fsp--; | ||
| 6610 | if (state.failed) return current; | ||
| 6611 | if ( state.backtracking==0 ) { | ||
| 6612 | |||
| 6613 | current = this_LogicLiteral_0; | ||
| 6614 | afterParserOrEnumRuleCall(); | ||
| 6615 | |||
| 6616 | } | ||
| 4304 | 6617 | ||
| 4305 | } | 6618 | } |
| 4306 | break; | 6619 | break; |
| 4307 | case 2 : | 6620 | case 2 : |
| 4308 | // InternalSolverLanguage.g:1473:4: ( (lv_constraints_2_0= ruleConstraint ) )* | 6621 | // InternalSolverLanguage.g:2320:3: this_NumericLiteral_1= ruleNumericLiteral |
| 4309 | { | 6622 | { |
| 4310 | // InternalSolverLanguage.g:1473:4: ( (lv_constraints_2_0= ruleConstraint ) )* | 6623 | if ( state.backtracking==0 ) { |
| 4311 | loop24: | ||
| 4312 | do { | ||
| 4313 | int alt24=2; | ||
| 4314 | int LA24_0 = input.LA(1); | ||
| 4315 | |||
| 4316 | if ( (LA24_0==RULE_ID||LA24_0==11||(LA24_0>=30 && LA24_0<=31)) ) { | ||
| 4317 | alt24=1; | ||
| 4318 | } | ||
| 4319 | 6624 | ||
| 6625 | newCompositeNode(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); | ||
| 6626 | |||
| 6627 | } | ||
| 6628 | pushFollow(FOLLOW_2); | ||
| 6629 | this_NumericLiteral_1=ruleNumericLiteral(); | ||
| 4320 | 6630 | ||
| 4321 | switch (alt24) { | 6631 | state._fsp--; |
| 4322 | case 1 : | 6632 | if (state.failed) return current; |
| 4323 | // InternalSolverLanguage.g:1474:5: (lv_constraints_2_0= ruleConstraint ) | 6633 | if ( state.backtracking==0 ) { |
| 4324 | { | ||
| 4325 | // InternalSolverLanguage.g:1474:5: (lv_constraints_2_0= ruleConstraint ) | ||
| 4326 | // InternalSolverLanguage.g:1475:6: lv_constraints_2_0= ruleConstraint | ||
| 4327 | { | ||
| 4328 | 6634 | ||
| 4329 | newCompositeNode(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); | 6635 | current = this_NumericLiteral_1; |
| 4330 | 6636 | afterParserOrEnumRuleCall(); | |
| 4331 | pushFollow(FOLLOW_22); | 6637 | |
| 4332 | lv_constraints_2_0=ruleConstraint(); | 6638 | } |
| 4333 | 6639 | ||
| 4334 | state._fsp--; | 6640 | } |
| 6641 | break; | ||
| 6642 | case 3 : | ||
| 6643 | // InternalSolverLanguage.g:2329:3: this_InfinityLiteral_2= ruleInfinityLiteral | ||
| 6644 | { | ||
| 6645 | if ( state.backtracking==0 ) { | ||
| 4335 | 6646 | ||
| 6647 | newCompositeNode(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); | ||
| 6648 | |||
| 6649 | } | ||
| 6650 | pushFollow(FOLLOW_2); | ||
| 6651 | this_InfinityLiteral_2=ruleInfinityLiteral(); | ||
| 4336 | 6652 | ||
| 4337 | if (current==null) { | 6653 | state._fsp--; |
| 4338 | current = createModelElementForParent(grammarAccess.getPatternBodyRule()); | 6654 | if (state.failed) return current; |
| 4339 | } | 6655 | if ( state.backtracking==0 ) { |
| 4340 | add( | ||
| 4341 | current, | ||
| 4342 | "constraints", | ||
| 4343 | lv_constraints_2_0, | ||
| 4344 | "org.eclipse.viatra.solver.language.SolverLanguage.Constraint"); | ||
| 4345 | afterParserOrEnumRuleCall(); | ||
| 4346 | |||
| 4347 | 6656 | ||
| 4348 | } | 6657 | current = this_InfinityLiteral_2; |
| 6658 | afterParserOrEnumRuleCall(); | ||
| 6659 | |||
| 6660 | } | ||
| 4349 | 6661 | ||
| 6662 | } | ||
| 6663 | break; | ||
| 6664 | case 4 : | ||
| 6665 | // InternalSolverLanguage.g:2338:3: this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | ||
| 6666 | { | ||
| 6667 | if ( state.backtracking==0 ) { | ||
| 4350 | 6668 | ||
| 4351 | } | 6669 | newCompositeNode(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); |
| 4352 | break; | 6670 | |
| 6671 | } | ||
| 6672 | pushFollow(FOLLOW_2); | ||
| 6673 | this_EmptyIntervalLiteral_3=ruleEmptyIntervalLiteral(); | ||
| 4353 | 6674 | ||
| 4354 | default : | 6675 | state._fsp--; |
| 4355 | break loop24; | 6676 | if (state.failed) return current; |
| 4356 | } | 6677 | if ( state.backtracking==0 ) { |
| 4357 | } while (true); | ||
| 4358 | 6678 | ||
| 6679 | current = this_EmptyIntervalLiteral_3; | ||
| 6680 | afterParserOrEnumRuleCall(); | ||
| 6681 | |||
| 6682 | } | ||
| 4359 | 6683 | ||
| 4360 | } | 6684 | } |
| 4361 | break; | 6685 | break; |
| 6686 | case 5 : | ||
| 6687 | // InternalSolverLanguage.g:2347:3: this_StringLiteral_4= ruleStringLiteral | ||
| 6688 | { | ||
| 6689 | if ( state.backtracking==0 ) { | ||
| 4362 | 6690 | ||
| 4363 | } | 6691 | newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); |
| 6692 | |||
| 6693 | } | ||
| 6694 | pushFollow(FOLLOW_2); | ||
| 6695 | this_StringLiteral_4=ruleStringLiteral(); | ||
| 6696 | |||
| 6697 | state._fsp--; | ||
| 6698 | if (state.failed) return current; | ||
| 6699 | if ( state.backtracking==0 ) { | ||
| 4364 | 6700 | ||
| 6701 | current = this_StringLiteral_4; | ||
| 6702 | afterParserOrEnumRuleCall(); | ||
| 6703 | |||
| 6704 | } | ||
| 6705 | |||
| 6706 | } | ||
| 6707 | break; | ||
| 4365 | 6708 | ||
| 4366 | } | 6709 | } |
| 4367 | 6710 | ||
| 4368 | 6711 | ||
| 4369 | } | 6712 | } |
| 4370 | 6713 | ||
| 6714 | if ( state.backtracking==0 ) { | ||
| 4371 | 6715 | ||
| 4372 | leaveRule(); | 6716 | leaveRule(); |
| 4373 | 6717 | ||
| 6718 | } | ||
| 4374 | } | 6719 | } |
| 4375 | 6720 | ||
| 4376 | catch (RecognitionException re) { | 6721 | catch (RecognitionException re) { |
| @@ -4381,29 +6726,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4381 | } | 6726 | } |
| 4382 | return current; | 6727 | return current; |
| 4383 | } | 6728 | } |
| 4384 | // $ANTLR end "rulePatternBody" | 6729 | // $ANTLR end "ruleLiteral" |
| 4385 | 6730 | ||
| 4386 | 6731 | ||
| 4387 | // $ANTLR start "entryRulePolarity" | 6732 | // $ANTLR start "entryRuleLogicLiteral" |
| 4388 | // InternalSolverLanguage.g:1497:1: entryRulePolarity returns [EObject current=null] : iv_rulePolarity= rulePolarity EOF ; | 6733 | // InternalSolverLanguage.g:2359:1: entryRuleLogicLiteral returns [EObject current=null] : iv_ruleLogicLiteral= ruleLogicLiteral EOF ; |
| 4389 | public final EObject entryRulePolarity() throws RecognitionException { | 6734 | public final EObject entryRuleLogicLiteral() throws RecognitionException { |
| 4390 | EObject current = null; | 6735 | EObject current = null; |
| 4391 | 6736 | ||
| 4392 | EObject iv_rulePolarity = null; | 6737 | EObject iv_ruleLogicLiteral = null; |
| 4393 | 6738 | ||
| 4394 | 6739 | ||
| 4395 | try { | 6740 | try { |
| 4396 | // InternalSolverLanguage.g:1497:49: (iv_rulePolarity= rulePolarity EOF ) | 6741 | // InternalSolverLanguage.g:2359:53: (iv_ruleLogicLiteral= ruleLogicLiteral EOF ) |
| 4397 | // InternalSolverLanguage.g:1498:2: iv_rulePolarity= rulePolarity EOF | 6742 | // InternalSolverLanguage.g:2360:2: iv_ruleLogicLiteral= ruleLogicLiteral EOF |
| 4398 | { | 6743 | { |
| 4399 | newCompositeNode(grammarAccess.getPolarityRule()); | 6744 | if ( state.backtracking==0 ) { |
| 6745 | newCompositeNode(grammarAccess.getLogicLiteralRule()); | ||
| 6746 | } | ||
| 4400 | pushFollow(FOLLOW_1); | 6747 | pushFollow(FOLLOW_1); |
| 4401 | iv_rulePolarity=rulePolarity(); | 6748 | iv_ruleLogicLiteral=ruleLogicLiteral(); |
| 4402 | 6749 | ||
| 4403 | state._fsp--; | 6750 | state._fsp--; |
| 4404 | 6751 | if (state.failed) return current; | |
| 4405 | current =iv_rulePolarity; | 6752 | if ( state.backtracking==0 ) { |
| 4406 | match(input,EOF,FOLLOW_2); | 6753 | current =iv_ruleLogicLiteral; |
| 6754 | } | ||
| 6755 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 4407 | 6756 | ||
| 4408 | } | 6757 | } |
| 4409 | 6758 | ||
| @@ -4417,104 +6766,178 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4417 | } | 6766 | } |
| 4418 | return current; | 6767 | return current; |
| 4419 | } | 6768 | } |
| 4420 | // $ANTLR end "entryRulePolarity" | 6769 | // $ANTLR end "entryRuleLogicLiteral" |
| 4421 | 6770 | ||
| 4422 | 6771 | ||
| 4423 | // $ANTLR start "rulePolarity" | 6772 | // $ANTLR start "ruleLogicLiteral" |
| 4424 | // InternalSolverLanguage.g:1504:1: rulePolarity returns [EObject current=null] : ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) ; | 6773 | // InternalSolverLanguage.g:2366:1: ruleLogicLiteral returns [EObject current=null] : ( (lv_value_0_0= ruleLogicValue ) ) ; |
| 4425 | public final EObject rulePolarity() throws RecognitionException { | 6774 | public final EObject ruleLogicLiteral() throws RecognitionException { |
| 4426 | EObject current = null; | 6775 | EObject current = null; |
| 4427 | 6776 | ||
| 4428 | Token otherlv_1=null; | 6777 | Enumerator lv_value_0_0 = null; |
| 4429 | Token otherlv_3=null; | 6778 | |
| 4430 | 6779 | ||
| 4431 | 6780 | ||
| 4432 | enterRule(); | 6781 | enterRule(); |
| 4433 | 6782 | ||
| 4434 | try { | 6783 | try { |
| 4435 | // InternalSolverLanguage.g:1510:2: ( ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) ) | 6784 | // InternalSolverLanguage.g:2372:2: ( ( (lv_value_0_0= ruleLogicValue ) ) ) |
| 4436 | // InternalSolverLanguage.g:1511:2: ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) | 6785 | // InternalSolverLanguage.g:2373:2: ( (lv_value_0_0= ruleLogicValue ) ) |
| 6786 | { | ||
| 6787 | // InternalSolverLanguage.g:2373:2: ( (lv_value_0_0= ruleLogicValue ) ) | ||
| 6788 | // InternalSolverLanguage.g:2374:3: (lv_value_0_0= ruleLogicValue ) | ||
| 6789 | { | ||
| 6790 | // InternalSolverLanguage.g:2374:3: (lv_value_0_0= ruleLogicValue ) | ||
| 6791 | // InternalSolverLanguage.g:2375:4: lv_value_0_0= ruleLogicValue | ||
| 4437 | { | 6792 | { |
| 4438 | // InternalSolverLanguage.g:1511:2: ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) | 6793 | if ( state.backtracking==0 ) { |
| 4439 | int alt26=2; | ||
| 4440 | int LA26_0 = input.LA(1); | ||
| 4441 | 6794 | ||
| 4442 | if ( (LA26_0==30) ) { | 6795 | newCompositeNode(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); |
| 4443 | alt26=1; | 6796 | |
| 4444 | } | 6797 | } |
| 4445 | else if ( (LA26_0==11) ) { | 6798 | pushFollow(FOLLOW_2); |
| 4446 | alt26=2; | 6799 | lv_value_0_0=ruleLogicValue(); |
| 6800 | |||
| 6801 | state._fsp--; | ||
| 6802 | if (state.failed) return current; | ||
| 6803 | if ( state.backtracking==0 ) { | ||
| 6804 | |||
| 6805 | if (current==null) { | ||
| 6806 | current = createModelElementForParent(grammarAccess.getLogicLiteralRule()); | ||
| 6807 | } | ||
| 6808 | set( | ||
| 6809 | current, | ||
| 6810 | "value", | ||
| 6811 | lv_value_0_0, | ||
| 6812 | "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue"); | ||
| 6813 | afterParserOrEnumRuleCall(); | ||
| 6814 | |||
| 4447 | } | 6815 | } |
| 4448 | else { | ||
| 4449 | NoViableAltException nvae = | ||
| 4450 | new NoViableAltException("", 26, 0, input); | ||
| 4451 | 6816 | ||
| 4452 | throw nvae; | ||
| 4453 | } | 6817 | } |
| 4454 | switch (alt26) { | ||
| 4455 | case 1 : | ||
| 4456 | // InternalSolverLanguage.g:1512:3: ( () otherlv_1= '+' ) | ||
| 4457 | { | ||
| 4458 | // InternalSolverLanguage.g:1512:3: ( () otherlv_1= '+' ) | ||
| 4459 | // InternalSolverLanguage.g:1513:4: () otherlv_1= '+' | ||
| 4460 | { | ||
| 4461 | // InternalSolverLanguage.g:1513:4: () | ||
| 4462 | // InternalSolverLanguage.g:1514:5: | ||
| 4463 | { | ||
| 4464 | 6818 | ||
| 4465 | current = forceCreateModelElement( | ||
| 4466 | grammarAccess.getPolarityAccess().getPositiveAction_0_0(), | ||
| 4467 | current); | ||
| 4468 | |||
| 4469 | 6819 | ||
| 4470 | } | 6820 | } |
| 4471 | 6821 | ||
| 4472 | otherlv_1=(Token)match(input,30,FOLLOW_2); | ||
| 4473 | 6822 | ||
| 4474 | newLeafNode(otherlv_1, grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); | 6823 | } |
| 4475 | |||
| 4476 | 6824 | ||
| 4477 | } | 6825 | if ( state.backtracking==0 ) { |
| 4478 | 6826 | ||
| 6827 | leaveRule(); | ||
| 4479 | 6828 | ||
| 4480 | } | 6829 | } |
| 4481 | break; | 6830 | } |
| 4482 | case 2 : | ||
| 4483 | // InternalSolverLanguage.g:1526:3: ( () otherlv_3= '-' ) | ||
| 4484 | { | ||
| 4485 | // InternalSolverLanguage.g:1526:3: ( () otherlv_3= '-' ) | ||
| 4486 | // InternalSolverLanguage.g:1527:4: () otherlv_3= '-' | ||
| 4487 | { | ||
| 4488 | // InternalSolverLanguage.g:1527:4: () | ||
| 4489 | // InternalSolverLanguage.g:1528:5: | ||
| 4490 | { | ||
| 4491 | 6831 | ||
| 4492 | current = forceCreateModelElement( | 6832 | catch (RecognitionException re) { |
| 4493 | grammarAccess.getPolarityAccess().getNegativeAction_1_0(), | 6833 | recover(input,re); |
| 4494 | current); | 6834 | appendSkippedTokens(); |
| 4495 | 6835 | } | |
| 6836 | finally { | ||
| 6837 | } | ||
| 6838 | return current; | ||
| 6839 | } | ||
| 6840 | // $ANTLR end "ruleLogicLiteral" | ||
| 4496 | 6841 | ||
| 4497 | } | ||
| 4498 | 6842 | ||
| 4499 | otherlv_3=(Token)match(input,11,FOLLOW_2); | 6843 | // $ANTLR start "entryRuleNumericLiteral" |
| 6844 | // InternalSolverLanguage.g:2395:1: entryRuleNumericLiteral returns [EObject current=null] : iv_ruleNumericLiteral= ruleNumericLiteral EOF ; | ||
| 6845 | public final EObject entryRuleNumericLiteral() throws RecognitionException { | ||
| 6846 | EObject current = null; | ||
| 4500 | 6847 | ||
| 4501 | newLeafNode(otherlv_3, grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); | 6848 | EObject iv_ruleNumericLiteral = null; |
| 4502 | |||
| 4503 | 6849 | ||
| 4504 | } | ||
| 4505 | 6850 | ||
| 6851 | try { | ||
| 6852 | // InternalSolverLanguage.g:2395:55: (iv_ruleNumericLiteral= ruleNumericLiteral EOF ) | ||
| 6853 | // InternalSolverLanguage.g:2396:2: iv_ruleNumericLiteral= ruleNumericLiteral EOF | ||
| 6854 | { | ||
| 6855 | if ( state.backtracking==0 ) { | ||
| 6856 | newCompositeNode(grammarAccess.getNumericLiteralRule()); | ||
| 6857 | } | ||
| 6858 | pushFollow(FOLLOW_1); | ||
| 6859 | iv_ruleNumericLiteral=ruleNumericLiteral(); | ||
| 4506 | 6860 | ||
| 4507 | } | 6861 | state._fsp--; |
| 4508 | break; | 6862 | if (state.failed) return current; |
| 6863 | if ( state.backtracking==0 ) { | ||
| 6864 | current =iv_ruleNumericLiteral; | ||
| 6865 | } | ||
| 6866 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 4509 | 6867 | ||
| 4510 | } | 6868 | } |
| 4511 | 6869 | ||
| 6870 | } | ||
| 4512 | 6871 | ||
| 6872 | catch (RecognitionException re) { | ||
| 6873 | recover(input,re); | ||
| 6874 | appendSkippedTokens(); | ||
| 6875 | } | ||
| 6876 | finally { | ||
| 6877 | } | ||
| 6878 | return current; | ||
| 6879 | } | ||
| 6880 | // $ANTLR end "entryRuleNumericLiteral" | ||
| 6881 | |||
| 6882 | |||
| 6883 | // $ANTLR start "ruleNumericLiteral" | ||
| 6884 | // InternalSolverLanguage.g:2402:1: ruleNumericLiteral returns [EObject current=null] : ( (lv_value_0_0= ruleReal ) ) ; | ||
| 6885 | public final EObject ruleNumericLiteral() throws RecognitionException { | ||
| 6886 | EObject current = null; | ||
| 6887 | |||
| 6888 | AntlrDatatypeRuleToken lv_value_0_0 = null; | ||
| 6889 | |||
| 6890 | |||
| 6891 | |||
| 6892 | enterRule(); | ||
| 6893 | |||
| 6894 | try { | ||
| 6895 | // InternalSolverLanguage.g:2408:2: ( ( (lv_value_0_0= ruleReal ) ) ) | ||
| 6896 | // InternalSolverLanguage.g:2409:2: ( (lv_value_0_0= ruleReal ) ) | ||
| 6897 | { | ||
| 6898 | // InternalSolverLanguage.g:2409:2: ( (lv_value_0_0= ruleReal ) ) | ||
| 6899 | // InternalSolverLanguage.g:2410:3: (lv_value_0_0= ruleReal ) | ||
| 6900 | { | ||
| 6901 | // InternalSolverLanguage.g:2410:3: (lv_value_0_0= ruleReal ) | ||
| 6902 | // InternalSolverLanguage.g:2411:4: lv_value_0_0= ruleReal | ||
| 6903 | { | ||
| 6904 | if ( state.backtracking==0 ) { | ||
| 6905 | |||
| 6906 | newCompositeNode(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); | ||
| 6907 | |||
| 6908 | } | ||
| 6909 | pushFollow(FOLLOW_2); | ||
| 6910 | lv_value_0_0=ruleReal(); | ||
| 6911 | |||
| 6912 | state._fsp--; | ||
| 6913 | if (state.failed) return current; | ||
| 6914 | if ( state.backtracking==0 ) { | ||
| 6915 | |||
| 6916 | if (current==null) { | ||
| 6917 | current = createModelElementForParent(grammarAccess.getNumericLiteralRule()); | ||
| 6918 | } | ||
| 6919 | set( | ||
| 6920 | current, | ||
| 6921 | "value", | ||
| 6922 | lv_value_0_0, | ||
| 6923 | "org.eclipse.viatra.solver.language.SolverLanguage.Real"); | ||
| 6924 | afterParserOrEnumRuleCall(); | ||
| 6925 | |||
| 4513 | } | 6926 | } |
| 4514 | 6927 | ||
| 6928 | } | ||
| 6929 | |||
| 6930 | |||
| 6931 | } | ||
| 6932 | |||
| 6933 | |||
| 6934 | } | ||
| 4515 | 6935 | ||
| 4516 | leaveRule(); | 6936 | if ( state.backtracking==0 ) { |
| 4517 | 6937 | ||
| 6938 | leaveRule(); | ||
| 6939 | |||
| 6940 | } | ||
| 4518 | } | 6941 | } |
| 4519 | 6942 | ||
| 4520 | catch (RecognitionException re) { | 6943 | catch (RecognitionException re) { |
| @@ -4525,32 +6948,96 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4525 | } | 6948 | } |
| 4526 | return current; | 6949 | return current; |
| 4527 | } | 6950 | } |
| 4528 | // $ANTLR end "rulePolarity" | 6951 | // $ANTLR end "ruleNumericLiteral" |
| 4529 | 6952 | ||
| 4530 | 6953 | ||
| 4531 | // $ANTLR start "entryRuleConstraint" | 6954 | // $ANTLR start "entryRuleInfinityLiteral" |
| 4532 | // InternalSolverLanguage.g:1543:1: entryRuleConstraint returns [EObject current=null] : iv_ruleConstraint= ruleConstraint EOF ; | 6955 | // InternalSolverLanguage.g:2431:1: entryRuleInfinityLiteral returns [EObject current=null] : iv_ruleInfinityLiteral= ruleInfinityLiteral EOF ; |
| 4533 | public final EObject entryRuleConstraint() throws RecognitionException { | 6956 | public final EObject entryRuleInfinityLiteral() throws RecognitionException { |
| 4534 | EObject current = null; | 6957 | EObject current = null; |
| 4535 | 6958 | ||
| 4536 | EObject iv_ruleConstraint = null; | 6959 | EObject iv_ruleInfinityLiteral = null; |
| 4537 | 6960 | ||
| 4538 | 6961 | ||
| 4539 | try { | 6962 | try { |
| 4540 | // InternalSolverLanguage.g:1543:51: (iv_ruleConstraint= ruleConstraint EOF ) | 6963 | // InternalSolverLanguage.g:2431:56: (iv_ruleInfinityLiteral= ruleInfinityLiteral EOF ) |
| 4541 | // InternalSolverLanguage.g:1544:2: iv_ruleConstraint= ruleConstraint EOF | 6964 | // InternalSolverLanguage.g:2432:2: iv_ruleInfinityLiteral= ruleInfinityLiteral EOF |
| 4542 | { | 6965 | { |
| 4543 | newCompositeNode(grammarAccess.getConstraintRule()); | 6966 | if ( state.backtracking==0 ) { |
| 6967 | newCompositeNode(grammarAccess.getInfinityLiteralRule()); | ||
| 6968 | } | ||
| 4544 | pushFollow(FOLLOW_1); | 6969 | pushFollow(FOLLOW_1); |
| 4545 | iv_ruleConstraint=ruleConstraint(); | 6970 | iv_ruleInfinityLiteral=ruleInfinityLiteral(); |
| 4546 | 6971 | ||
| 4547 | state._fsp--; | 6972 | state._fsp--; |
| 6973 | if (state.failed) return current; | ||
| 6974 | if ( state.backtracking==0 ) { | ||
| 6975 | current =iv_ruleInfinityLiteral; | ||
| 6976 | } | ||
| 6977 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 6978 | |||
| 6979 | } | ||
| 6980 | |||
| 6981 | } | ||
| 6982 | |||
| 6983 | catch (RecognitionException re) { | ||
| 6984 | recover(input,re); | ||
| 6985 | appendSkippedTokens(); | ||
| 6986 | } | ||
| 6987 | finally { | ||
| 6988 | } | ||
| 6989 | return current; | ||
| 6990 | } | ||
| 6991 | // $ANTLR end "entryRuleInfinityLiteral" | ||
| 6992 | |||
| 6993 | |||
| 6994 | // $ANTLR start "ruleInfinityLiteral" | ||
| 6995 | // InternalSolverLanguage.g:2438:1: ruleInfinityLiteral returns [EObject current=null] : ( () otherlv_1= 'inf' ) ; | ||
| 6996 | public final EObject ruleInfinityLiteral() throws RecognitionException { | ||
| 6997 | EObject current = null; | ||
| 6998 | |||
| 6999 | Token otherlv_1=null; | ||
| 7000 | |||
| 7001 | |||
| 7002 | enterRule(); | ||
| 7003 | |||
| 7004 | try { | ||
| 7005 | // InternalSolverLanguage.g:2444:2: ( ( () otherlv_1= 'inf' ) ) | ||
| 7006 | // InternalSolverLanguage.g:2445:2: ( () otherlv_1= 'inf' ) | ||
| 7007 | { | ||
| 7008 | // InternalSolverLanguage.g:2445:2: ( () otherlv_1= 'inf' ) | ||
| 7009 | // InternalSolverLanguage.g:2446:3: () otherlv_1= 'inf' | ||
| 7010 | { | ||
| 7011 | // InternalSolverLanguage.g:2446:3: () | ||
| 7012 | // InternalSolverLanguage.g:2447:4: | ||
| 7013 | { | ||
| 7014 | if ( state.backtracking==0 ) { | ||
| 7015 | |||
| 7016 | current = forceCreateModelElement( | ||
| 7017 | grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0(), | ||
| 7018 | current); | ||
| 7019 | |||
| 7020 | } | ||
| 7021 | |||
| 7022 | } | ||
| 7023 | |||
| 7024 | otherlv_1=(Token)match(input,39,FOLLOW_2); if (state.failed) return current; | ||
| 7025 | if ( state.backtracking==0 ) { | ||
| 4548 | 7026 | ||
| 4549 | current =iv_ruleConstraint; | 7027 | newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); |
| 4550 | match(input,EOF,FOLLOW_2); | 7028 | |
| 7029 | } | ||
| 4551 | 7030 | ||
| 4552 | } | 7031 | } |
| 4553 | 7032 | ||
| 7033 | |||
| 7034 | } | ||
| 7035 | |||
| 7036 | if ( state.backtracking==0 ) { | ||
| 7037 | |||
| 7038 | leaveRule(); | ||
| 7039 | |||
| 7040 | } | ||
| 4554 | } | 7041 | } |
| 4555 | 7042 | ||
| 4556 | catch (RecognitionException re) { | 7043 | catch (RecognitionException re) { |
| @@ -4561,420 +7048,452 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4561 | } | 7048 | } |
| 4562 | return current; | 7049 | return current; |
| 4563 | } | 7050 | } |
| 4564 | // $ANTLR end "entryRuleConstraint" | 7051 | // $ANTLR end "ruleInfinityLiteral" |
| 4565 | 7052 | ||
| 4566 | 7053 | ||
| 4567 | // $ANTLR start "ruleConstraint" | 7054 | // $ANTLR start "entryRuleEmptyIntervalLiteral" |
| 4568 | // InternalSolverLanguage.g:1550: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_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) ) ; | 7055 | // InternalSolverLanguage.g:2461:1: entryRuleEmptyIntervalLiteral returns [EObject current=null] : iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF ; |
| 4569 | public final EObject ruleConstraint() throws RecognitionException { | 7056 | public final EObject entryRuleEmptyIntervalLiteral() throws RecognitionException { |
| 4570 | EObject current = null; | 7057 | EObject current = null; |
| 4571 | 7058 | ||
| 4572 | Token otherlv_2=null; | 7059 | EObject iv_ruleEmptyIntervalLiteral = null; |
| 4573 | Token otherlv_4=null; | ||
| 4574 | Token otherlv_6=null; | ||
| 4575 | Token otherlv_8=null; | ||
| 4576 | Token otherlv_10=null; | ||
| 4577 | Token otherlv_12=null; | ||
| 4578 | EObject lv_polarity_0_0 = null; | ||
| 4579 | 7060 | ||
| 4580 | EObject lv_symbol_1_0 = null; | ||
| 4581 | 7061 | ||
| 4582 | EObject lv_params_3_0 = null; | 7062 | try { |
| 7063 | // InternalSolverLanguage.g:2461:61: (iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF ) | ||
| 7064 | // InternalSolverLanguage.g:2462:2: iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF | ||
| 7065 | { | ||
| 7066 | if ( state.backtracking==0 ) { | ||
| 7067 | newCompositeNode(grammarAccess.getEmptyIntervalLiteralRule()); | ||
| 7068 | } | ||
| 7069 | pushFollow(FOLLOW_1); | ||
| 7070 | iv_ruleEmptyIntervalLiteral=ruleEmptyIntervalLiteral(); | ||
| 4583 | 7071 | ||
| 4584 | EObject lv_params_5_0 = null; | 7072 | state._fsp--; |
| 7073 | if (state.failed) return current; | ||
| 7074 | if ( state.backtracking==0 ) { | ||
| 7075 | current =iv_ruleEmptyIntervalLiteral; | ||
| 7076 | } | ||
| 7077 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 4585 | 7078 | ||
| 4586 | EObject lv_closureType_7_0 = null; | 7079 | } |
| 7080 | |||
| 7081 | } | ||
| 7082 | |||
| 7083 | catch (RecognitionException re) { | ||
| 7084 | recover(input,re); | ||
| 7085 | appendSkippedTokens(); | ||
| 7086 | } | ||
| 7087 | finally { | ||
| 7088 | } | ||
| 7089 | return current; | ||
| 7090 | } | ||
| 7091 | // $ANTLR end "entryRuleEmptyIntervalLiteral" | ||
| 4587 | 7092 | ||
| 4588 | EObject lv_params_9_0 = null; | ||
| 4589 | 7093 | ||
| 4590 | EObject lv_params_11_0 = null; | 7094 | // $ANTLR start "ruleEmptyIntervalLiteral" |
| 7095 | // InternalSolverLanguage.g:2468:1: ruleEmptyIntervalLiteral returns [EObject current=null] : ( () otherlv_1= 'empty' ) ; | ||
| 7096 | public final EObject ruleEmptyIntervalLiteral() throws RecognitionException { | ||
| 7097 | EObject current = null; | ||
| 4591 | 7098 | ||
| 7099 | Token otherlv_1=null; | ||
| 4592 | 7100 | ||
| 4593 | 7101 | ||
| 4594 | enterRule(); | 7102 | enterRule(); |
| 4595 | 7103 | ||
| 4596 | try { | 7104 | try { |
| 4597 | // InternalSolverLanguage.g:1556:2: ( ( ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) ) ) | 7105 | // InternalSolverLanguage.g:2474:2: ( ( () otherlv_1= 'empty' ) ) |
| 4598 | // InternalSolverLanguage.g:1557:2: ( ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) ) | 7106 | // InternalSolverLanguage.g:2475:2: ( () otherlv_1= 'empty' ) |
| 4599 | { | 7107 | { |
| 4600 | // InternalSolverLanguage.g:1557:2: ( ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) ) | 7108 | // InternalSolverLanguage.g:2475:2: ( () otherlv_1= 'empty' ) |
| 4601 | int alt33=2; | 7109 | // InternalSolverLanguage.g:2476:3: () otherlv_1= 'empty' |
| 4602 | switch ( input.LA(1) ) { | 7110 | { |
| 4603 | case 30: | 7111 | // InternalSolverLanguage.g:2476:3: () |
| 4604 | { | 7112 | // InternalSolverLanguage.g:2477:4: |
| 4605 | int LA33_1 = input.LA(2); | 7113 | { |
| 7114 | if ( state.backtracking==0 ) { | ||
| 4606 | 7115 | ||
| 4607 | if ( (LA33_1==17) ) { | 7116 | current = forceCreateModelElement( |
| 4608 | alt33=2; | 7117 | grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0(), |
| 4609 | } | 7118 | current); |
| 4610 | else if ( (LA33_1==RULE_ID) ) { | 7119 | |
| 4611 | alt33=1; | 7120 | } |
| 4612 | } | ||
| 4613 | else { | ||
| 4614 | NoViableAltException nvae = | ||
| 4615 | new NoViableAltException("", 33, 1, input); | ||
| 4616 | 7121 | ||
| 4617 | throw nvae; | 7122 | } |
| 4618 | } | ||
| 4619 | } | ||
| 4620 | break; | ||
| 4621 | case RULE_ID: | ||
| 4622 | case 11: | ||
| 4623 | { | ||
| 4624 | alt33=1; | ||
| 4625 | } | ||
| 4626 | break; | ||
| 4627 | case 31: | ||
| 4628 | { | ||
| 4629 | alt33=2; | ||
| 4630 | } | ||
| 4631 | break; | ||
| 4632 | default: | ||
| 4633 | NoViableAltException nvae = | ||
| 4634 | new NoViableAltException("", 33, 0, input); | ||
| 4635 | 7123 | ||
| 4636 | throw nvae; | 7124 | otherlv_1=(Token)match(input,40,FOLLOW_2); if (state.failed) return current; |
| 7125 | if ( state.backtracking==0 ) { | ||
| 7126 | |||
| 7127 | newLeafNode(otherlv_1, grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); | ||
| 7128 | |||
| 4637 | } | 7129 | } |
| 4638 | 7130 | ||
| 4639 | switch (alt33) { | 7131 | } |
| 4640 | case 1 : | ||
| 4641 | // InternalSolverLanguage.g:1558:3: ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ||
| 4642 | { | ||
| 4643 | // InternalSolverLanguage.g:1558:3: ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ||
| 4644 | // InternalSolverLanguage.g:1559:4: ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? | ||
| 4645 | { | ||
| 4646 | // InternalSolverLanguage.g:1559:4: ( (lv_polarity_0_0= rulePolarity ) )? | ||
| 4647 | int alt27=2; | ||
| 4648 | int LA27_0 = input.LA(1); | ||
| 4649 | 7132 | ||
| 4650 | if ( (LA27_0==11||LA27_0==30) ) { | ||
| 4651 | alt27=1; | ||
| 4652 | } | ||
| 4653 | switch (alt27) { | ||
| 4654 | case 1 : | ||
| 4655 | // InternalSolverLanguage.g:1560:5: (lv_polarity_0_0= rulePolarity ) | ||
| 4656 | { | ||
| 4657 | // InternalSolverLanguage.g:1560:5: (lv_polarity_0_0= rulePolarity ) | ||
| 4658 | // InternalSolverLanguage.g:1561:6: lv_polarity_0_0= rulePolarity | ||
| 4659 | { | ||
| 4660 | 7133 | ||
| 4661 | newCompositeNode(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0_0()); | 7134 | } |
| 4662 | |||
| 4663 | pushFollow(FOLLOW_12); | ||
| 4664 | lv_polarity_0_0=rulePolarity(); | ||
| 4665 | 7135 | ||
| 4666 | state._fsp--; | 7136 | if ( state.backtracking==0 ) { |
| 4667 | 7137 | ||
| 7138 | leaveRule(); | ||
| 4668 | 7139 | ||
| 4669 | if (current==null) { | 7140 | } |
| 4670 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | 7141 | } |
| 4671 | } | ||
| 4672 | set( | ||
| 4673 | current, | ||
| 4674 | "polarity", | ||
| 4675 | lv_polarity_0_0, | ||
| 4676 | "org.eclipse.viatra.solver.language.SolverLanguage.Polarity"); | ||
| 4677 | afterParserOrEnumRuleCall(); | ||
| 4678 | |||
| 4679 | 7142 | ||
| 4680 | } | 7143 | catch (RecognitionException re) { |
| 7144 | recover(input,re); | ||
| 7145 | appendSkippedTokens(); | ||
| 7146 | } | ||
| 7147 | finally { | ||
| 7148 | } | ||
| 7149 | return current; | ||
| 7150 | } | ||
| 7151 | // $ANTLR end "ruleEmptyIntervalLiteral" | ||
| 4681 | 7152 | ||
| 4682 | 7153 | ||
| 4683 | } | 7154 | // $ANTLR start "entryRuleStringLiteral" |
| 4684 | break; | 7155 | // InternalSolverLanguage.g:2491:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ; |
| 7156 | public final EObject entryRuleStringLiteral() throws RecognitionException { | ||
| 7157 | EObject current = null; | ||
| 4685 | 7158 | ||
| 4686 | } | 7159 | EObject iv_ruleStringLiteral = null; |
| 4687 | 7160 | ||
| 4688 | // InternalSolverLanguage.g:1578:4: ( (lv_symbol_1_0= ruleModelSymbol ) ) | ||
| 4689 | // InternalSolverLanguage.g:1579:5: (lv_symbol_1_0= ruleModelSymbol ) | ||
| 4690 | { | ||
| 4691 | // InternalSolverLanguage.g:1579:5: (lv_symbol_1_0= ruleModelSymbol ) | ||
| 4692 | // InternalSolverLanguage.g:1580:6: lv_symbol_1_0= ruleModelSymbol | ||
| 4693 | { | ||
| 4694 | 7161 | ||
| 4695 | newCompositeNode(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_0_1_0()); | 7162 | try { |
| 4696 | 7163 | // InternalSolverLanguage.g:2491:54: (iv_ruleStringLiteral= ruleStringLiteral EOF ) | |
| 4697 | pushFollow(FOLLOW_23); | 7164 | // InternalSolverLanguage.g:2492:2: iv_ruleStringLiteral= ruleStringLiteral EOF |
| 4698 | lv_symbol_1_0=ruleModelSymbol(); | 7165 | { |
| 7166 | if ( state.backtracking==0 ) { | ||
| 7167 | newCompositeNode(grammarAccess.getStringLiteralRule()); | ||
| 7168 | } | ||
| 7169 | pushFollow(FOLLOW_1); | ||
| 7170 | iv_ruleStringLiteral=ruleStringLiteral(); | ||
| 4699 | 7171 | ||
| 4700 | state._fsp--; | 7172 | state._fsp--; |
| 7173 | if (state.failed) return current; | ||
| 7174 | if ( state.backtracking==0 ) { | ||
| 7175 | current =iv_ruleStringLiteral; | ||
| 7176 | } | ||
| 7177 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 4701 | 7178 | ||
| 7179 | } | ||
| 4702 | 7180 | ||
| 4703 | if (current==null) { | 7181 | } |
| 4704 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 4705 | } | ||
| 4706 | set( | ||
| 4707 | current, | ||
| 4708 | "symbol", | ||
| 4709 | lv_symbol_1_0, | ||
| 4710 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 4711 | afterParserOrEnumRuleCall(); | ||
| 4712 | |||
| 4713 | 7182 | ||
| 4714 | } | 7183 | catch (RecognitionException re) { |
| 7184 | recover(input,re); | ||
| 7185 | appendSkippedTokens(); | ||
| 7186 | } | ||
| 7187 | finally { | ||
| 7188 | } | ||
| 7189 | return current; | ||
| 7190 | } | ||
| 7191 | // $ANTLR end "entryRuleStringLiteral" | ||
| 4715 | 7192 | ||
| 4716 | 7193 | ||
| 4717 | } | 7194 | // $ANTLR start "ruleStringLiteral" |
| 7195 | // InternalSolverLanguage.g:2498:1: ruleStringLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; | ||
| 7196 | public final EObject ruleStringLiteral() throws RecognitionException { | ||
| 7197 | EObject current = null; | ||
| 4718 | 7198 | ||
| 4719 | // InternalSolverLanguage.g:1597:4: (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? | 7199 | Token lv_value_0_0=null; |
| 4720 | int alt30=2; | ||
| 4721 | int LA30_0 = input.LA(1); | ||
| 4722 | 7200 | ||
| 4723 | if ( (LA30_0==17) ) { | ||
| 4724 | alt30=1; | ||
| 4725 | } | ||
| 4726 | switch (alt30) { | ||
| 4727 | case 1 : | ||
| 4728 | // InternalSolverLanguage.g:1598:5: otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' | ||
| 4729 | { | ||
| 4730 | otherlv_2=(Token)match(input,17,FOLLOW_24); | ||
| 4731 | 7201 | ||
| 4732 | newLeafNode(otherlv_2, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_0_2_0()); | 7202 | enterRule(); |
| 4733 | |||
| 4734 | // InternalSolverLanguage.g:1602:5: ( (lv_params_3_0= ruleLiteral ) )? | ||
| 4735 | int alt28=2; | ||
| 4736 | int LA28_0 = input.LA(1); | ||
| 4737 | 7203 | ||
| 4738 | if ( ((LA28_0>=RULE_INT && LA28_0<=RULE_STRING)||LA28_0==11||(LA28_0>=13 && LA28_0<=14)||LA28_0==27) ) { | 7204 | try { |
| 4739 | alt28=1; | 7205 | // InternalSolverLanguage.g:2504:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) |
| 4740 | } | 7206 | // InternalSolverLanguage.g:2505:2: ( (lv_value_0_0= RULE_STRING ) ) |
| 4741 | switch (alt28) { | 7207 | { |
| 4742 | case 1 : | 7208 | // InternalSolverLanguage.g:2505:2: ( (lv_value_0_0= RULE_STRING ) ) |
| 4743 | // InternalSolverLanguage.g:1603:6: (lv_params_3_0= ruleLiteral ) | 7209 | // InternalSolverLanguage.g:2506:3: (lv_value_0_0= RULE_STRING ) |
| 4744 | { | 7210 | { |
| 4745 | // InternalSolverLanguage.g:1603:6: (lv_params_3_0= ruleLiteral ) | 7211 | // InternalSolverLanguage.g:2506:3: (lv_value_0_0= RULE_STRING ) |
| 4746 | // InternalSolverLanguage.g:1604:7: lv_params_3_0= ruleLiteral | 7212 | // InternalSolverLanguage.g:2507:4: lv_value_0_0= RULE_STRING |
| 4747 | { | 7213 | { |
| 7214 | lv_value_0_0=(Token)match(input,RULE_STRING,FOLLOW_2); if (state.failed) return current; | ||
| 7215 | if ( state.backtracking==0 ) { | ||
| 4748 | 7216 | ||
| 4749 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_1_0()); | 7217 | newLeafNode(lv_value_0_0, grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); |
| 4750 | 7218 | ||
| 4751 | pushFollow(FOLLOW_8); | 7219 | } |
| 4752 | lv_params_3_0=ruleLiteral(); | 7220 | if ( state.backtracking==0 ) { |
| 4753 | 7221 | ||
| 4754 | state._fsp--; | 7222 | if (current==null) { |
| 7223 | current = createModelElement(grammarAccess.getStringLiteralRule()); | ||
| 7224 | } | ||
| 7225 | setWithLastConsumed( | ||
| 7226 | current, | ||
| 7227 | "value", | ||
| 7228 | lv_value_0_0, | ||
| 7229 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
| 7230 | |||
| 7231 | } | ||
| 4755 | 7232 | ||
| 7233 | } | ||
| 4756 | 7234 | ||
| 4757 | if (current==null) { | ||
| 4758 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 4759 | } | ||
| 4760 | add( | ||
| 4761 | current, | ||
| 4762 | "params", | ||
| 4763 | lv_params_3_0, | ||
| 4764 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 4765 | afterParserOrEnumRuleCall(); | ||
| 4766 | |||
| 4767 | 7235 | ||
| 4768 | } | 7236 | } |
| 4769 | 7237 | ||
| 4770 | 7238 | ||
| 4771 | } | 7239 | } |
| 4772 | break; | ||
| 4773 | 7240 | ||
| 4774 | } | 7241 | if ( state.backtracking==0 ) { |
| 7242 | |||
| 7243 | leaveRule(); | ||
| 4775 | 7244 | ||
| 4776 | // InternalSolverLanguage.g:1621:5: (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* | 7245 | } |
| 4777 | loop29: | 7246 | } |
| 4778 | do { | 7247 | |
| 4779 | int alt29=2; | 7248 | catch (RecognitionException re) { |
| 4780 | int LA29_0 = input.LA(1); | 7249 | recover(input,re); |
| 7250 | appendSkippedTokens(); | ||
| 7251 | } | ||
| 7252 | finally { | ||
| 7253 | } | ||
| 7254 | return current; | ||
| 7255 | } | ||
| 7256 | // $ANTLR end "ruleStringLiteral" | ||
| 4781 | 7257 | ||
| 4782 | if ( (LA29_0==18) ) { | ||
| 4783 | alt29=1; | ||
| 4784 | } | ||
| 4785 | 7258 | ||
| 7259 | // $ANTLR start "entryRuleClassDefinition" | ||
| 7260 | // InternalSolverLanguage.g:2526:1: entryRuleClassDefinition returns [EObject current=null] : iv_ruleClassDefinition= ruleClassDefinition EOF ; | ||
| 7261 | public final EObject entryRuleClassDefinition() throws RecognitionException { | ||
| 7262 | EObject current = null; | ||
| 4786 | 7263 | ||
| 4787 | switch (alt29) { | 7264 | EObject iv_ruleClassDefinition = null; |
| 4788 | case 1 : | ||
| 4789 | // InternalSolverLanguage.g:1622:6: otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) | ||
| 4790 | { | ||
| 4791 | otherlv_4=(Token)match(input,18,FOLLOW_25); | ||
| 4792 | 7265 | ||
| 4793 | newLeafNode(otherlv_4, grammarAccess.getConstraintAccess().getCommaKeyword_0_2_2_0()); | ||
| 4794 | |||
| 4795 | // InternalSolverLanguage.g:1626:6: ( (lv_params_5_0= ruleLiteral ) ) | ||
| 4796 | // InternalSolverLanguage.g:1627:7: (lv_params_5_0= ruleLiteral ) | ||
| 4797 | { | ||
| 4798 | // InternalSolverLanguage.g:1627:7: (lv_params_5_0= ruleLiteral ) | ||
| 4799 | // InternalSolverLanguage.g:1628:8: lv_params_5_0= ruleLiteral | ||
| 4800 | { | ||
| 4801 | 7266 | ||
| 4802 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_2_1_0()); | 7267 | try { |
| 4803 | 7268 | // InternalSolverLanguage.g:2526:56: (iv_ruleClassDefinition= ruleClassDefinition EOF ) | |
| 4804 | pushFollow(FOLLOW_8); | 7269 | // InternalSolverLanguage.g:2527:2: iv_ruleClassDefinition= ruleClassDefinition EOF |
| 4805 | lv_params_5_0=ruleLiteral(); | 7270 | { |
| 7271 | if ( state.backtracking==0 ) { | ||
| 7272 | newCompositeNode(grammarAccess.getClassDefinitionRule()); | ||
| 7273 | } | ||
| 7274 | pushFollow(FOLLOW_1); | ||
| 7275 | iv_ruleClassDefinition=ruleClassDefinition(); | ||
| 4806 | 7276 | ||
| 4807 | state._fsp--; | 7277 | state._fsp--; |
| 7278 | if (state.failed) return current; | ||
| 7279 | if ( state.backtracking==0 ) { | ||
| 7280 | current =iv_ruleClassDefinition; | ||
| 7281 | } | ||
| 7282 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 4808 | 7283 | ||
| 7284 | } | ||
| 4809 | 7285 | ||
| 4810 | if (current==null) { | 7286 | } |
| 4811 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 4812 | } | ||
| 4813 | add( | ||
| 4814 | current, | ||
| 4815 | "params", | ||
| 4816 | lv_params_5_0, | ||
| 4817 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 4818 | afterParserOrEnumRuleCall(); | ||
| 4819 | |||
| 4820 | 7287 | ||
| 4821 | } | 7288 | catch (RecognitionException re) { |
| 7289 | recover(input,re); | ||
| 7290 | appendSkippedTokens(); | ||
| 7291 | } | ||
| 7292 | finally { | ||
| 7293 | } | ||
| 7294 | return current; | ||
| 7295 | } | ||
| 7296 | // $ANTLR end "entryRuleClassDefinition" | ||
| 4822 | 7297 | ||
| 4823 | 7298 | ||
| 4824 | } | 7299 | // $ANTLR start "ruleClassDefinition" |
| 7300 | // InternalSolverLanguage.g:2533:1: ruleClassDefinition returns [EObject current=null] : ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_7= '{' ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= '}' ) ; | ||
| 7301 | public final EObject ruleClassDefinition() throws RecognitionException { | ||
| 7302 | EObject current = null; | ||
| 4825 | 7303 | ||
| 7304 | Token lv_abstract_0_0=null; | ||
| 7305 | Token otherlv_1=null; | ||
| 7306 | Token lv_name_2_0=null; | ||
| 7307 | Token otherlv_3=null; | ||
| 7308 | Token otherlv_5=null; | ||
| 7309 | Token otherlv_7=null; | ||
| 7310 | Token otherlv_9=null; | ||
| 7311 | EObject lv_members_8_0 = null; | ||
| 4826 | 7312 | ||
| 4827 | } | ||
| 4828 | break; | ||
| 4829 | 7313 | ||
| 4830 | default : | ||
| 4831 | break loop29; | ||
| 4832 | } | ||
| 4833 | } while (true); | ||
| 4834 | 7314 | ||
| 4835 | otherlv_6=(Token)match(input,19,FOLLOW_2); | 7315 | enterRule(); |
| 4836 | 7316 | ||
| 4837 | newLeafNode(otherlv_6, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_0_2_3()); | 7317 | try { |
| 4838 | 7318 | // InternalSolverLanguage.g:2539:2: ( ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_7= '{' ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= '}' ) ) | |
| 7319 | // InternalSolverLanguage.g:2540:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_7= '{' ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= '}' ) | ||
| 7320 | { | ||
| 7321 | // InternalSolverLanguage.g:2540:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_7= '{' ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= '}' ) | ||
| 7322 | // InternalSolverLanguage.g:2541:3: ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_7= '{' ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= '}' | ||
| 7323 | { | ||
| 7324 | // InternalSolverLanguage.g:2541:3: ( (lv_abstract_0_0= 'abstract' ) )? | ||
| 7325 | int alt27=2; | ||
| 7326 | int LA27_0 = input.LA(1); | ||
| 4839 | 7327 | ||
| 4840 | } | 7328 | if ( (LA27_0==41) ) { |
| 4841 | break; | 7329 | alt27=1; |
| 7330 | } | ||
| 7331 | switch (alt27) { | ||
| 7332 | case 1 : | ||
| 7333 | // InternalSolverLanguage.g:2542:4: (lv_abstract_0_0= 'abstract' ) | ||
| 7334 | { | ||
| 7335 | // InternalSolverLanguage.g:2542:4: (lv_abstract_0_0= 'abstract' ) | ||
| 7336 | // InternalSolverLanguage.g:2543:5: lv_abstract_0_0= 'abstract' | ||
| 7337 | { | ||
| 7338 | lv_abstract_0_0=(Token)match(input,41,FOLLOW_39); if (state.failed) return current; | ||
| 7339 | if ( state.backtracking==0 ) { | ||
| 4842 | 7340 | ||
| 7341 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); | ||
| 7342 | |||
| 4843 | } | 7343 | } |
| 7344 | if ( state.backtracking==0 ) { | ||
| 4844 | 7345 | ||
| 7346 | if (current==null) { | ||
| 7347 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 7348 | } | ||
| 7349 | setWithLastConsumed(current, "abstract", true, "abstract"); | ||
| 7350 | |||
| 7351 | } | ||
| 4845 | 7352 | ||
| 4846 | } | 7353 | } |
| 4847 | 7354 | ||
| 4848 | 7355 | ||
| 4849 | } | 7356 | } |
| 4850 | break; | 7357 | break; |
| 4851 | case 2 : | ||
| 4852 | // InternalSolverLanguage.g:1653:3: ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) | ||
| 4853 | { | ||
| 4854 | // InternalSolverLanguage.g:1653:3: ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) | ||
| 4855 | // InternalSolverLanguage.g:1654:4: ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' | ||
| 4856 | { | ||
| 4857 | // InternalSolverLanguage.g:1654:4: ( (lv_closureType_7_0= ruleClosureType ) ) | ||
| 4858 | // InternalSolverLanguage.g:1655:5: (lv_closureType_7_0= ruleClosureType ) | ||
| 4859 | { | ||
| 4860 | // InternalSolverLanguage.g:1655:5: (lv_closureType_7_0= ruleClosureType ) | ||
| 4861 | // InternalSolverLanguage.g:1656:6: lv_closureType_7_0= ruleClosureType | ||
| 4862 | { | ||
| 4863 | 7358 | ||
| 4864 | newCompositeNode(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_1_0_0()); | 7359 | } |
| 4865 | |||
| 4866 | pushFollow(FOLLOW_26); | ||
| 4867 | lv_closureType_7_0=ruleClosureType(); | ||
| 4868 | 7360 | ||
| 4869 | state._fsp--; | 7361 | otherlv_1=(Token)match(input,42,FOLLOW_40); if (state.failed) return current; |
| 7362 | if ( state.backtracking==0 ) { | ||
| 4870 | 7363 | ||
| 7364 | newLeafNode(otherlv_1, grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); | ||
| 7365 | |||
| 7366 | } | ||
| 7367 | // InternalSolverLanguage.g:2559:3: ( (lv_name_2_0= RULE_ID ) ) | ||
| 7368 | // InternalSolverLanguage.g:2560:4: (lv_name_2_0= RULE_ID ) | ||
| 7369 | { | ||
| 7370 | // InternalSolverLanguage.g:2560:4: (lv_name_2_0= RULE_ID ) | ||
| 7371 | // InternalSolverLanguage.g:2561:5: lv_name_2_0= RULE_ID | ||
| 7372 | { | ||
| 7373 | lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_41); if (state.failed) return current; | ||
| 7374 | if ( state.backtracking==0 ) { | ||
| 4871 | 7375 | ||
| 4872 | if (current==null) { | 7376 | newLeafNode(lv_name_2_0, grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); |
| 4873 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | 7377 | |
| 4874 | } | 7378 | } |
| 4875 | set( | 7379 | if ( state.backtracking==0 ) { |
| 4876 | current, | ||
| 4877 | "closureType", | ||
| 4878 | lv_closureType_7_0, | ||
| 4879 | "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType"); | ||
| 4880 | afterParserOrEnumRuleCall(); | ||
| 4881 | |||
| 4882 | 7380 | ||
| 4883 | } | 7381 | if (current==null) { |
| 7382 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 7383 | } | ||
| 7384 | setWithLastConsumed( | ||
| 7385 | current, | ||
| 7386 | "name", | ||
| 7387 | lv_name_2_0, | ||
| 7388 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 7389 | |||
| 7390 | } | ||
| 4884 | 7391 | ||
| 7392 | } | ||
| 4885 | 7393 | ||
| 4886 | } | ||
| 4887 | 7394 | ||
| 4888 | otherlv_8=(Token)match(input,17,FOLLOW_24); | 7395 | } |
| 4889 | 7396 | ||
| 4890 | newLeafNode(otherlv_8, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_1_1()); | 7397 | // InternalSolverLanguage.g:2577:3: (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? |
| 4891 | 7398 | int alt29=2; | |
| 4892 | // InternalSolverLanguage.g:1677:4: ( (lv_params_9_0= ruleLiteral ) )? | 7399 | int LA29_0 = input.LA(1); |
| 4893 | int alt31=2; | ||
| 4894 | int LA31_0 = input.LA(1); | ||
| 4895 | 7400 | ||
| 4896 | if ( ((LA31_0>=RULE_INT && LA31_0<=RULE_STRING)||LA31_0==11||(LA31_0>=13 && LA31_0<=14)||LA31_0==27) ) { | 7401 | if ( (LA29_0==43) ) { |
| 4897 | alt31=1; | 7402 | alt29=1; |
| 4898 | } | 7403 | } |
| 4899 | switch (alt31) { | 7404 | switch (alt29) { |
| 4900 | case 1 : | 7405 | case 1 : |
| 4901 | // InternalSolverLanguage.g:1678:5: (lv_params_9_0= ruleLiteral ) | 7406 | // InternalSolverLanguage.g:2578:4: otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* |
| 4902 | { | 7407 | { |
| 4903 | // InternalSolverLanguage.g:1678:5: (lv_params_9_0= ruleLiteral ) | 7408 | otherlv_3=(Token)match(input,43,FOLLOW_35); if (state.failed) return current; |
| 4904 | // InternalSolverLanguage.g:1679:6: lv_params_9_0= ruleLiteral | 7409 | if ( state.backtracking==0 ) { |
| 4905 | { | ||
| 4906 | 7410 | ||
| 4907 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_2_0()); | 7411 | newLeafNode(otherlv_3, grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); |
| 4908 | 7412 | ||
| 4909 | pushFollow(FOLLOW_8); | 7413 | } |
| 4910 | lv_params_9_0=ruleLiteral(); | 7414 | // InternalSolverLanguage.g:2582:4: ( ( ruleQualifiedName ) ) |
| 7415 | // InternalSolverLanguage.g:2583:5: ( ruleQualifiedName ) | ||
| 7416 | { | ||
| 7417 | // InternalSolverLanguage.g:2583:5: ( ruleQualifiedName ) | ||
| 7418 | // InternalSolverLanguage.g:2584:6: ruleQualifiedName | ||
| 7419 | { | ||
| 7420 | if ( state.backtracking==0 ) { | ||
| 4911 | 7421 | ||
| 4912 | state._fsp--; | 7422 | if (current==null) { |
| 7423 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 7424 | } | ||
| 7425 | |||
| 7426 | } | ||
| 7427 | if ( state.backtracking==0 ) { | ||
| 4913 | 7428 | ||
| 7429 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); | ||
| 7430 | |||
| 7431 | } | ||
| 7432 | pushFollow(FOLLOW_42); | ||
| 7433 | ruleQualifiedName(); | ||
| 4914 | 7434 | ||
| 4915 | if (current==null) { | 7435 | state._fsp--; |
| 4916 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | 7436 | if (state.failed) return current; |
| 4917 | } | 7437 | if ( state.backtracking==0 ) { |
| 4918 | add( | ||
| 4919 | current, | ||
| 4920 | "params", | ||
| 4921 | lv_params_9_0, | ||
| 4922 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 4923 | afterParserOrEnumRuleCall(); | ||
| 4924 | |||
| 4925 | 7438 | ||
| 4926 | } | 7439 | afterParserOrEnumRuleCall(); |
| 7440 | |||
| 7441 | } | ||
| 4927 | 7442 | ||
| 7443 | } | ||
| 4928 | 7444 | ||
| 4929 | } | ||
| 4930 | break; | ||
| 4931 | 7445 | ||
| 4932 | } | 7446 | } |
| 4933 | 7447 | ||
| 4934 | // InternalSolverLanguage.g:1696:4: (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* | 7448 | // InternalSolverLanguage.g:2598:4: (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* |
| 4935 | loop32: | 7449 | loop28: |
| 4936 | do { | 7450 | do { |
| 4937 | int alt32=2; | 7451 | int alt28=2; |
| 4938 | int LA32_0 = input.LA(1); | 7452 | int LA28_0 = input.LA(1); |
| 4939 | 7453 | ||
| 4940 | if ( (LA32_0==18) ) { | 7454 | if ( (LA28_0==28) ) { |
| 4941 | alt32=1; | 7455 | alt28=1; |
| 4942 | } | 7456 | } |
| 4943 | 7457 | ||
| 4944 | 7458 | ||
| 4945 | switch (alt32) { | 7459 | switch (alt28) { |
| 4946 | case 1 : | 7460 | case 1 : |
| 4947 | // InternalSolverLanguage.g:1697:5: otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) | 7461 | // InternalSolverLanguage.g:2599:5: otherlv_5= ',' ( ( ruleQualifiedName ) ) |
| 4948 | { | 7462 | { |
| 4949 | otherlv_10=(Token)match(input,18,FOLLOW_25); | 7463 | otherlv_5=(Token)match(input,28,FOLLOW_35); if (state.failed) return current; |
| 7464 | if ( state.backtracking==0 ) { | ||
| 4950 | 7465 | ||
| 4951 | newLeafNode(otherlv_10, grammarAccess.getConstraintAccess().getCommaKeyword_1_3_0()); | 7466 | newLeafNode(otherlv_5, grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); |
| 4952 | 7467 | ||
| 4953 | // InternalSolverLanguage.g:1701:5: ( (lv_params_11_0= ruleLiteral ) ) | 7468 | } |
| 4954 | // InternalSolverLanguage.g:1702:6: (lv_params_11_0= ruleLiteral ) | 7469 | // InternalSolverLanguage.g:2603:5: ( ( ruleQualifiedName ) ) |
| 7470 | // InternalSolverLanguage.g:2604:6: ( ruleQualifiedName ) | ||
| 4955 | { | 7471 | { |
| 4956 | // InternalSolverLanguage.g:1702:6: (lv_params_11_0= ruleLiteral ) | 7472 | // InternalSolverLanguage.g:2604:6: ( ruleQualifiedName ) |
| 4957 | // InternalSolverLanguage.g:1703:7: lv_params_11_0= ruleLiteral | 7473 | // InternalSolverLanguage.g:2605:7: ruleQualifiedName |
| 4958 | { | 7474 | { |
| 7475 | if ( state.backtracking==0 ) { | ||
| 4959 | 7476 | ||
| 4960 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_3_1_0()); | 7477 | if (current==null) { |
| 4961 | 7478 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | |
| 4962 | pushFollow(FOLLOW_8); | 7479 | } |
| 4963 | lv_params_11_0=ruleLiteral(); | 7480 | |
| 7481 | } | ||
| 7482 | if ( state.backtracking==0 ) { | ||
| 4964 | 7483 | ||
| 4965 | state._fsp--; | 7484 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); |
| 7485 | |||
| 7486 | } | ||
| 7487 | pushFollow(FOLLOW_42); | ||
| 7488 | ruleQualifiedName(); | ||
| 4966 | 7489 | ||
| 7490 | state._fsp--; | ||
| 7491 | if (state.failed) return current; | ||
| 7492 | if ( state.backtracking==0 ) { | ||
| 4967 | 7493 | ||
| 4968 | if (current==null) { | 7494 | afterParserOrEnumRuleCall(); |
| 4969 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | 7495 | |
| 4970 | } | 7496 | } |
| 4971 | add( | ||
| 4972 | current, | ||
| 4973 | "params", | ||
| 4974 | lv_params_11_0, | ||
| 4975 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 4976 | afterParserOrEnumRuleCall(); | ||
| 4977 | |||
| 4978 | 7497 | ||
| 4979 | } | 7498 | } |
| 4980 | 7499 | ||
| @@ -4986,29 +7505,92 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4986 | break; | 7505 | break; |
| 4987 | 7506 | ||
| 4988 | default : | 7507 | default : |
| 4989 | break loop32; | 7508 | break loop28; |
| 4990 | } | 7509 | } |
| 4991 | } while (true); | 7510 | } while (true); |
| 4992 | 7511 | ||
| 4993 | otherlv_12=(Token)match(input,19,FOLLOW_2); | ||
| 4994 | |||
| 4995 | newLeafNode(otherlv_12, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_1_4()); | ||
| 4996 | |||
| 4997 | 7512 | ||
| 4998 | } | 7513 | } |
| 7514 | break; | ||
| 4999 | 7515 | ||
| 7516 | } | ||
| 7517 | |||
| 7518 | otherlv_7=(Token)match(input,30,FOLLOW_43); if (state.failed) return current; | ||
| 7519 | if ( state.backtracking==0 ) { | ||
| 7520 | |||
| 7521 | newLeafNode(otherlv_7, grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); | ||
| 7522 | |||
| 7523 | } | ||
| 7524 | // InternalSolverLanguage.g:2625:3: ( (lv_members_8_0= ruleMemberDefinition ) )* | ||
| 7525 | loop30: | ||
| 7526 | do { | ||
| 7527 | int alt30=2; | ||
| 7528 | int LA30_0 = input.LA(1); | ||
| 7529 | |||
| 7530 | if ( (LA30_0==RULE_ID||LA30_0==RULE_QUOTED_ID||LA30_0==44) ) { | ||
| 7531 | alt30=1; | ||
| 7532 | } | ||
| 7533 | |||
| 7534 | |||
| 7535 | switch (alt30) { | ||
| 7536 | case 1 : | ||
| 7537 | // InternalSolverLanguage.g:2626:4: (lv_members_8_0= ruleMemberDefinition ) | ||
| 7538 | { | ||
| 7539 | // InternalSolverLanguage.g:2626:4: (lv_members_8_0= ruleMemberDefinition ) | ||
| 7540 | // InternalSolverLanguage.g:2627:5: lv_members_8_0= ruleMemberDefinition | ||
| 7541 | { | ||
| 7542 | if ( state.backtracking==0 ) { | ||
| 7543 | |||
| 7544 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); | ||
| 7545 | |||
| 7546 | } | ||
| 7547 | pushFollow(FOLLOW_43); | ||
| 7548 | lv_members_8_0=ruleMemberDefinition(); | ||
| 7549 | |||
| 7550 | state._fsp--; | ||
| 7551 | if (state.failed) return current; | ||
| 7552 | if ( state.backtracking==0 ) { | ||
| 7553 | |||
| 7554 | if (current==null) { | ||
| 7555 | current = createModelElementForParent(grammarAccess.getClassDefinitionRule()); | ||
| 7556 | } | ||
| 7557 | add( | ||
| 7558 | current, | ||
| 7559 | "members", | ||
| 7560 | lv_members_8_0, | ||
| 7561 | "org.eclipse.viatra.solver.language.SolverLanguage.MemberDefinition"); | ||
| 7562 | afterParserOrEnumRuleCall(); | ||
| 7563 | |||
| 7564 | } | ||
| 7565 | |||
| 7566 | } | ||
| 5000 | 7567 | ||
| 5001 | } | 7568 | |
| 5002 | break; | 7569 | } |
| 7570 | break; | ||
| 7571 | |||
| 7572 | default : | ||
| 7573 | break loop30; | ||
| 7574 | } | ||
| 7575 | } while (true); | ||
| 7576 | |||
| 7577 | otherlv_9=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; | ||
| 7578 | if ( state.backtracking==0 ) { | ||
| 7579 | |||
| 7580 | newLeafNode(otherlv_9, grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); | ||
| 7581 | |||
| 7582 | } | ||
| 5003 | 7583 | ||
| 5004 | } | 7584 | } |
| 5005 | 7585 | ||
| 5006 | 7586 | ||
| 5007 | } | 7587 | } |
| 5008 | 7588 | ||
| 7589 | if ( state.backtracking==0 ) { | ||
| 5009 | 7590 | ||
| 5010 | leaveRule(); | 7591 | leaveRule(); |
| 5011 | 7592 | ||
| 7593 | } | ||
| 5012 | } | 7594 | } |
| 5013 | 7595 | ||
| 5014 | catch (RecognitionException re) { | 7596 | catch (RecognitionException re) { |
| @@ -5019,29 +7601,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5019 | } | 7601 | } |
| 5020 | return current; | 7602 | return current; |
| 5021 | } | 7603 | } |
| 5022 | // $ANTLR end "ruleConstraint" | 7604 | // $ANTLR end "ruleClassDefinition" |
| 5023 | 7605 | ||
| 5024 | 7606 | ||
| 5025 | // $ANTLR start "entryRuleClosureType" | 7607 | // $ANTLR start "entryRuleMemberDefinition" |
| 5026 | // InternalSolverLanguage.g:1730:1: entryRuleClosureType returns [EObject current=null] : iv_ruleClosureType= ruleClosureType EOF ; | 7608 | // InternalSolverLanguage.g:2652:1: entryRuleMemberDefinition returns [EObject current=null] : iv_ruleMemberDefinition= ruleMemberDefinition EOF ; |
| 5027 | public final EObject entryRuleClosureType() throws RecognitionException { | 7609 | public final EObject entryRuleMemberDefinition() throws RecognitionException { |
| 5028 | EObject current = null; | 7610 | EObject current = null; |
| 5029 | 7611 | ||
| 5030 | EObject iv_ruleClosureType = null; | 7612 | EObject iv_ruleMemberDefinition = null; |
| 5031 | 7613 | ||
| 5032 | 7614 | ||
| 5033 | try { | 7615 | try { |
| 5034 | // InternalSolverLanguage.g:1730:52: (iv_ruleClosureType= ruleClosureType EOF ) | 7616 | // InternalSolverLanguage.g:2652:57: (iv_ruleMemberDefinition= ruleMemberDefinition EOF ) |
| 5035 | // InternalSolverLanguage.g:1731:2: iv_ruleClosureType= ruleClosureType EOF | 7617 | // InternalSolverLanguage.g:2653:2: iv_ruleMemberDefinition= ruleMemberDefinition EOF |
| 5036 | { | 7618 | { |
| 5037 | newCompositeNode(grammarAccess.getClosureTypeRule()); | 7619 | if ( state.backtracking==0 ) { |
| 7620 | newCompositeNode(grammarAccess.getMemberDefinitionRule()); | ||
| 7621 | } | ||
| 5038 | pushFollow(FOLLOW_1); | 7622 | pushFollow(FOLLOW_1); |
| 5039 | iv_ruleClosureType=ruleClosureType(); | 7623 | iv_ruleMemberDefinition=ruleMemberDefinition(); |
| 5040 | 7624 | ||
| 5041 | state._fsp--; | 7625 | state._fsp--; |
| 5042 | 7626 | if (state.failed) return current; | |
| 5043 | current =iv_ruleClosureType; | 7627 | if ( state.backtracking==0 ) { |
| 5044 | match(input,EOF,FOLLOW_2); | 7628 | current =iv_ruleMemberDefinition; |
| 7629 | } | ||
| 7630 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 5045 | 7631 | ||
| 5046 | } | 7632 | } |
| 5047 | 7633 | ||
| @@ -5055,89 +7641,226 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5055 | } | 7641 | } |
| 5056 | return current; | 7642 | return current; |
| 5057 | } | 7643 | } |
| 5058 | // $ANTLR end "entryRuleClosureType" | 7644 | // $ANTLR end "entryRuleMemberDefinition" |
| 5059 | 7645 | ||
| 5060 | 7646 | ||
| 5061 | // $ANTLR start "ruleClosureType" | 7647 | // $ANTLR start "ruleMemberDefinition" |
| 5062 | // InternalSolverLanguage.g:1737:1: ruleClosureType returns [EObject current=null] : ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) ; | 7648 | // InternalSolverLanguage.g:2659:1: ruleMemberDefinition returns [EObject current=null] : ( ( (lv_containment_0_0= 'contains' ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? (otherlv_6= ';' )? ) ; |
| 5063 | public final EObject ruleClosureType() throws RecognitionException { | 7649 | public final EObject ruleMemberDefinition() throws RecognitionException { |
| 5064 | EObject current = null; | 7650 | EObject current = null; |
| 5065 | 7651 | ||
| 5066 | Token otherlv_1=null; | 7652 | Token lv_containment_0_0=null; |
| 5067 | Token otherlv_3=null; | 7653 | Token lv_name_3_0=null; |
| 7654 | Token otherlv_4=null; | ||
| 7655 | Token otherlv_6=null; | ||
| 7656 | EObject lv_multiplicity_2_0 = null; | ||
| 7657 | |||
| 5068 | 7658 | ||
| 5069 | 7659 | ||
| 5070 | enterRule(); | 7660 | enterRule(); |
| 5071 | 7661 | ||
| 5072 | try { | 7662 | try { |
| 5073 | // InternalSolverLanguage.g:1743:2: ( ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) ) | 7663 | // InternalSolverLanguage.g:2665:2: ( ( ( (lv_containment_0_0= 'contains' ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? (otherlv_6= ';' )? ) ) |
| 5074 | // InternalSolverLanguage.g:1744:2: ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) | 7664 | // InternalSolverLanguage.g:2666:2: ( ( (lv_containment_0_0= 'contains' ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? (otherlv_6= ';' )? ) |
| 5075 | { | 7665 | { |
| 5076 | // InternalSolverLanguage.g:1744:2: ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) | 7666 | // InternalSolverLanguage.g:2666:2: ( ( (lv_containment_0_0= 'contains' ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? (otherlv_6= ';' )? ) |
| 5077 | int alt34=2; | 7667 | // InternalSolverLanguage.g:2667:3: ( (lv_containment_0_0= 'contains' ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? (otherlv_6= ';' )? |
| 5078 | int LA34_0 = input.LA(1); | 7668 | { |
| 7669 | // InternalSolverLanguage.g:2667:3: ( (lv_containment_0_0= 'contains' ) )? | ||
| 7670 | int alt31=2; | ||
| 7671 | int LA31_0 = input.LA(1); | ||
| 7672 | |||
| 7673 | if ( (LA31_0==44) ) { | ||
| 7674 | alt31=1; | ||
| 7675 | } | ||
| 7676 | switch (alt31) { | ||
| 7677 | case 1 : | ||
| 7678 | // InternalSolverLanguage.g:2668:4: (lv_containment_0_0= 'contains' ) | ||
| 7679 | { | ||
| 7680 | // InternalSolverLanguage.g:2668:4: (lv_containment_0_0= 'contains' ) | ||
| 7681 | // InternalSolverLanguage.g:2669:5: lv_containment_0_0= 'contains' | ||
| 7682 | { | ||
| 7683 | lv_containment_0_0=(Token)match(input,44,FOLLOW_35); if (state.failed) return current; | ||
| 7684 | if ( state.backtracking==0 ) { | ||
| 7685 | |||
| 7686 | newLeafNode(lv_containment_0_0, grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); | ||
| 7687 | |||
| 7688 | } | ||
| 7689 | if ( state.backtracking==0 ) { | ||
| 7690 | |||
| 7691 | if (current==null) { | ||
| 7692 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 7693 | } | ||
| 7694 | setWithLastConsumed(current, "containment", true, "contains"); | ||
| 7695 | |||
| 7696 | } | ||
| 7697 | |||
| 7698 | } | ||
| 7699 | |||
| 7700 | |||
| 7701 | } | ||
| 7702 | break; | ||
| 5079 | 7703 | ||
| 5080 | if ( (LA34_0==31) ) { | ||
| 5081 | alt34=1; | ||
| 5082 | } | 7704 | } |
| 5083 | else if ( (LA34_0==30) ) { | 7705 | |
| 5084 | alt34=2; | 7706 | // InternalSolverLanguage.g:2681:3: ( ( ruleQualifiedName ) ) |
| 7707 | // InternalSolverLanguage.g:2682:4: ( ruleQualifiedName ) | ||
| 7708 | { | ||
| 7709 | // InternalSolverLanguage.g:2682:4: ( ruleQualifiedName ) | ||
| 7710 | // InternalSolverLanguage.g:2683:5: ruleQualifiedName | ||
| 7711 | { | ||
| 7712 | if ( state.backtracking==0 ) { | ||
| 7713 | |||
| 7714 | if (current==null) { | ||
| 7715 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 7716 | } | ||
| 7717 | |||
| 5085 | } | 7718 | } |
| 5086 | else { | 7719 | if ( state.backtracking==0 ) { |
| 5087 | NoViableAltException nvae = | ||
| 5088 | new NoViableAltException("", 34, 0, input); | ||
| 5089 | 7720 | ||
| 5090 | throw nvae; | 7721 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); |
| 7722 | |||
| 5091 | } | 7723 | } |
| 5092 | switch (alt34) { | 7724 | pushFollow(FOLLOW_44); |
| 7725 | ruleQualifiedName(); | ||
| 7726 | |||
| 7727 | state._fsp--; | ||
| 7728 | if (state.failed) return current; | ||
| 7729 | if ( state.backtracking==0 ) { | ||
| 7730 | |||
| 7731 | afterParserOrEnumRuleCall(); | ||
| 7732 | |||
| 7733 | } | ||
| 7734 | |||
| 7735 | } | ||
| 7736 | |||
| 7737 | |||
| 7738 | } | ||
| 7739 | |||
| 7740 | // InternalSolverLanguage.g:2697:3: ( (lv_multiplicity_2_0= ruleMultiplicity ) )? | ||
| 7741 | int alt32=2; | ||
| 7742 | int LA32_0 = input.LA(1); | ||
| 7743 | |||
| 7744 | if ( (LA32_0==36) ) { | ||
| 7745 | alt32=1; | ||
| 7746 | } | ||
| 7747 | switch (alt32) { | ||
| 5093 | case 1 : | 7748 | case 1 : |
| 5094 | // InternalSolverLanguage.g:1745:3: ( () otherlv_1= '*' ) | 7749 | // InternalSolverLanguage.g:2698:4: (lv_multiplicity_2_0= ruleMultiplicity ) |
| 5095 | { | ||
| 5096 | // InternalSolverLanguage.g:1745:3: ( () otherlv_1= '*' ) | ||
| 5097 | // InternalSolverLanguage.g:1746:4: () otherlv_1= '*' | ||
| 5098 | { | 7750 | { |
| 5099 | // InternalSolverLanguage.g:1746:4: () | 7751 | // InternalSolverLanguage.g:2698:4: (lv_multiplicity_2_0= ruleMultiplicity ) |
| 5100 | // InternalSolverLanguage.g:1747:5: | 7752 | // InternalSolverLanguage.g:2699:5: lv_multiplicity_2_0= ruleMultiplicity |
| 5101 | { | 7753 | { |
| 7754 | if ( state.backtracking==0 ) { | ||
| 5102 | 7755 | ||
| 5103 | current = forceCreateModelElement( | 7756 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); |
| 5104 | grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0(), | 7757 | |
| 5105 | current); | ||
| 5106 | |||
| 5107 | |||
| 5108 | } | 7758 | } |
| 7759 | pushFollow(FOLLOW_40); | ||
| 7760 | lv_multiplicity_2_0=ruleMultiplicity(); | ||
| 5109 | 7761 | ||
| 5110 | otherlv_1=(Token)match(input,31,FOLLOW_2); | 7762 | state._fsp--; |
| 5111 | 7763 | if (state.failed) return current; | |
| 5112 | newLeafNode(otherlv_1, grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); | 7764 | if ( state.backtracking==0 ) { |
| 5113 | 7765 | ||
| 7766 | if (current==null) { | ||
| 7767 | current = createModelElementForParent(grammarAccess.getMemberDefinitionRule()); | ||
| 7768 | } | ||
| 7769 | set( | ||
| 7770 | current, | ||
| 7771 | "multiplicity", | ||
| 7772 | lv_multiplicity_2_0, | ||
| 7773 | "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity"); | ||
| 7774 | afterParserOrEnumRuleCall(); | ||
| 7775 | |||
| 7776 | } | ||
| 5114 | 7777 | ||
| 5115 | } | 7778 | } |
| 5116 | 7779 | ||
| 5117 | 7780 | ||
| 5118 | } | 7781 | } |
| 5119 | break; | 7782 | break; |
| 5120 | case 2 : | 7783 | |
| 5121 | // InternalSolverLanguage.g:1759:3: ( () otherlv_3= '+' ) | 7784 | } |
| 7785 | |||
| 7786 | // InternalSolverLanguage.g:2716:3: ( (lv_name_3_0= RULE_ID ) ) | ||
| 7787 | // InternalSolverLanguage.g:2717:4: (lv_name_3_0= RULE_ID ) | ||
| 7788 | { | ||
| 7789 | // InternalSolverLanguage.g:2717:4: (lv_name_3_0= RULE_ID ) | ||
| 7790 | // InternalSolverLanguage.g:2718:5: lv_name_3_0= RULE_ID | ||
| 7791 | { | ||
| 7792 | lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_45); if (state.failed) return current; | ||
| 7793 | if ( state.backtracking==0 ) { | ||
| 7794 | |||
| 7795 | newLeafNode(lv_name_3_0, grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); | ||
| 7796 | |||
| 7797 | } | ||
| 7798 | if ( state.backtracking==0 ) { | ||
| 7799 | |||
| 7800 | if (current==null) { | ||
| 7801 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 7802 | } | ||
| 7803 | setWithLastConsumed( | ||
| 7804 | current, | ||
| 7805 | "name", | ||
| 7806 | lv_name_3_0, | ||
| 7807 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 7808 | |||
| 7809 | } | ||
| 7810 | |||
| 7811 | } | ||
| 7812 | |||
| 7813 | |||
| 7814 | } | ||
| 7815 | |||
| 7816 | // InternalSolverLanguage.g:2734:3: (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? | ||
| 7817 | int alt33=2; | ||
| 7818 | int LA33_0 = input.LA(1); | ||
| 7819 | |||
| 7820 | if ( (LA33_0==45) ) { | ||
| 7821 | alt33=1; | ||
| 7822 | } | ||
| 7823 | switch (alt33) { | ||
| 7824 | case 1 : | ||
| 7825 | // InternalSolverLanguage.g:2735:4: otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) | ||
| 5122 | { | 7826 | { |
| 5123 | // InternalSolverLanguage.g:1759:3: ( () otherlv_3= '+' ) | 7827 | otherlv_4=(Token)match(input,45,FOLLOW_35); if (state.failed) return current; |
| 5124 | // InternalSolverLanguage.g:1760:4: () otherlv_3= '+' | 7828 | if ( state.backtracking==0 ) { |
| 7829 | |||
| 7830 | newLeafNode(otherlv_4, grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); | ||
| 7831 | |||
| 7832 | } | ||
| 7833 | // InternalSolverLanguage.g:2739:4: ( ( ruleQualifiedName ) ) | ||
| 7834 | // InternalSolverLanguage.g:2740:5: ( ruleQualifiedName ) | ||
| 5125 | { | 7835 | { |
| 5126 | // InternalSolverLanguage.g:1760:4: () | 7836 | // InternalSolverLanguage.g:2740:5: ( ruleQualifiedName ) |
| 5127 | // InternalSolverLanguage.g:1761:5: | 7837 | // InternalSolverLanguage.g:2741:6: ruleQualifiedName |
| 5128 | { | 7838 | { |
| 7839 | if ( state.backtracking==0 ) { | ||
| 5129 | 7840 | ||
| 5130 | current = forceCreateModelElement( | 7841 | if (current==null) { |
| 5131 | grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0(), | 7842 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); |
| 5132 | current); | 7843 | } |
| 5133 | 7844 | ||
| 7845 | } | ||
| 7846 | if ( state.backtracking==0 ) { | ||
| 5134 | 7847 | ||
| 7848 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); | ||
| 7849 | |||
| 5135 | } | 7850 | } |
| 7851 | pushFollow(FOLLOW_18); | ||
| 7852 | ruleQualifiedName(); | ||
| 5136 | 7853 | ||
| 5137 | otherlv_3=(Token)match(input,30,FOLLOW_2); | 7854 | state._fsp--; |
| 7855 | if (state.failed) return current; | ||
| 7856 | if ( state.backtracking==0 ) { | ||
| 7857 | |||
| 7858 | afterParserOrEnumRuleCall(); | ||
| 7859 | |||
| 7860 | } | ||
| 7861 | |||
| 7862 | } | ||
| 5138 | 7863 | ||
| 5139 | newLeafNode(otherlv_3, grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); | ||
| 5140 | |||
| 5141 | 7864 | ||
| 5142 | } | 7865 | } |
| 5143 | 7866 | ||
| @@ -5147,12 +7870,40 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5147 | 7870 | ||
| 5148 | } | 7871 | } |
| 5149 | 7872 | ||
| 7873 | // InternalSolverLanguage.g:2756:3: (otherlv_6= ';' )? | ||
| 7874 | int alt34=2; | ||
| 7875 | int LA34_0 = input.LA(1); | ||
| 5150 | 7876 | ||
| 7877 | if ( (LA34_0==26) ) { | ||
| 7878 | alt34=1; | ||
| 5151 | } | 7879 | } |
| 7880 | switch (alt34) { | ||
| 7881 | case 1 : | ||
| 7882 | // InternalSolverLanguage.g:2757:4: otherlv_6= ';' | ||
| 7883 | { | ||
| 7884 | otherlv_6=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; | ||
| 7885 | if ( state.backtracking==0 ) { | ||
| 5152 | 7886 | ||
| 7887 | newLeafNode(otherlv_6, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); | ||
| 7888 | |||
| 7889 | } | ||
| 5153 | 7890 | ||
| 5154 | leaveRule(); | 7891 | } |
| 7892 | break; | ||
| 5155 | 7893 | ||
| 7894 | } | ||
| 7895 | |||
| 7896 | |||
| 7897 | } | ||
| 7898 | |||
| 7899 | |||
| 7900 | } | ||
| 7901 | |||
| 7902 | if ( state.backtracking==0 ) { | ||
| 7903 | |||
| 7904 | leaveRule(); | ||
| 7905 | |||
| 7906 | } | ||
| 5156 | } | 7907 | } |
| 5157 | 7908 | ||
| 5158 | catch (RecognitionException re) { | 7909 | catch (RecognitionException re) { |
| @@ -5163,29 +7914,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5163 | } | 7914 | } |
| 5164 | return current; | 7915 | return current; |
| 5165 | } | 7916 | } |
| 5166 | // $ANTLR end "ruleClosureType" | 7917 | // $ANTLR end "ruleMemberDefinition" |
| 5167 | 7918 | ||
| 5168 | 7919 | ||
| 5169 | // $ANTLR start "entryRuleLiteral" | 7920 | // $ANTLR start "entryRuleMultiplicity" |
| 5170 | // InternalSolverLanguage.g:1776:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; | 7921 | // InternalSolverLanguage.g:2766:1: entryRuleMultiplicity returns [EObject current=null] : iv_ruleMultiplicity= ruleMultiplicity EOF ; |
| 5171 | public final EObject entryRuleLiteral() throws RecognitionException { | 7922 | public final EObject entryRuleMultiplicity() throws RecognitionException { |
| 5172 | EObject current = null; | 7923 | EObject current = null; |
| 5173 | 7924 | ||
| 5174 | EObject iv_ruleLiteral = null; | 7925 | EObject iv_ruleMultiplicity = null; |
| 5175 | 7926 | ||
| 5176 | 7927 | ||
| 5177 | try { | 7928 | try { |
| 5178 | // InternalSolverLanguage.g:1776:48: (iv_ruleLiteral= ruleLiteral EOF ) | 7929 | // InternalSolverLanguage.g:2766:53: (iv_ruleMultiplicity= ruleMultiplicity EOF ) |
| 5179 | // InternalSolverLanguage.g:1777:2: iv_ruleLiteral= ruleLiteral EOF | 7930 | // InternalSolverLanguage.g:2767:2: iv_ruleMultiplicity= ruleMultiplicity EOF |
| 5180 | { | 7931 | { |
| 5181 | newCompositeNode(grammarAccess.getLiteralRule()); | 7932 | if ( state.backtracking==0 ) { |
| 7933 | newCompositeNode(grammarAccess.getMultiplicityRule()); | ||
| 7934 | } | ||
| 5182 | pushFollow(FOLLOW_1); | 7935 | pushFollow(FOLLOW_1); |
| 5183 | iv_ruleLiteral=ruleLiteral(); | 7936 | iv_ruleMultiplicity=ruleMultiplicity(); |
| 5184 | 7937 | ||
| 5185 | state._fsp--; | 7938 | state._fsp--; |
| 5186 | 7939 | if (state.failed) return current; | |
| 5187 | current =iv_ruleLiteral; | 7940 | if ( state.backtracking==0 ) { |
| 5188 | match(input,EOF,FOLLOW_2); | 7941 | current =iv_ruleMultiplicity; |
| 7942 | } | ||
| 7943 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 5189 | 7944 | ||
| 5190 | } | 7945 | } |
| 5191 | 7946 | ||
| @@ -5199,109 +7954,143 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5199 | } | 7954 | } |
| 5200 | return current; | 7955 | return current; |
| 5201 | } | 7956 | } |
| 5202 | // $ANTLR end "entryRuleLiteral" | 7957 | // $ANTLR end "entryRuleMultiplicity" |
| 5203 | 7958 | ||
| 5204 | 7959 | ||
| 5205 | // $ANTLR start "ruleLiteral" | 7960 | // $ANTLR start "ruleMultiplicity" |
| 5206 | // InternalSolverLanguage.g:1783:1: ruleLiteral returns [EObject current=null] : (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject | this_NamedObject_2= ruleNamedObject ) ; | 7961 | // InternalSolverLanguage.g:2773:1: ruleMultiplicity returns [EObject current=null] : (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) ; |
| 5207 | public final EObject ruleLiteral() throws RecognitionException { | 7962 | public final EObject ruleMultiplicity() throws RecognitionException { |
| 5208 | EObject current = null; | 7963 | EObject current = null; |
| 5209 | 7964 | ||
| 5210 | EObject this_Variable_0 = null; | 7965 | EObject this_ManyMultiplicity_0 = null; |
| 5211 | 7966 | ||
| 5212 | EObject this_DataObject_1 = null; | 7967 | EObject this_ExactMultiplicity_1 = null; |
| 5213 | 7968 | ||
| 5214 | EObject this_NamedObject_2 = null; | 7969 | EObject this_BoundedMultiplicity_2 = null; |
| 5215 | 7970 | ||
| 5216 | 7971 | ||
| 5217 | 7972 | ||
| 5218 | enterRule(); | 7973 | enterRule(); |
| 5219 | 7974 | ||
| 5220 | try { | 7975 | try { |
| 5221 | // InternalSolverLanguage.g:1789:2: ( (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject | this_NamedObject_2= ruleNamedObject ) ) | 7976 | // InternalSolverLanguage.g:2779:2: ( (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) ) |
| 5222 | // InternalSolverLanguage.g:1790:2: (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject | this_NamedObject_2= ruleNamedObject ) | 7977 | // InternalSolverLanguage.g:2780:2: (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) |
| 5223 | { | 7978 | { |
| 5224 | // InternalSolverLanguage.g:1790:2: (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject | this_NamedObject_2= ruleNamedObject ) | 7979 | // InternalSolverLanguage.g:2780:2: (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) |
| 5225 | int alt35=3; | 7980 | int alt35=3; |
| 5226 | switch ( input.LA(1) ) { | 7981 | int LA35_0 = input.LA(1); |
| 5227 | case RULE_ID: | 7982 | |
| 5228 | { | 7983 | if ( (LA35_0==36) ) { |
| 5229 | alt35=1; | 7984 | switch ( input.LA(2) ) { |
| 5230 | } | 7985 | case RULE_INT: |
| 5231 | break; | 7986 | { |
| 5232 | case RULE_INT: | 7987 | int LA35_2 = input.LA(3); |
| 5233 | case RULE_STRING: | 7988 | |
| 5234 | case 11: | 7989 | if ( (LA35_2==38) ) { |
| 5235 | case 13: | 7990 | alt35=2; |
| 5236 | case 14: | 7991 | } |
| 5237 | { | 7992 | else if ( (LA35_2==37) ) { |
| 5238 | alt35=2; | 7993 | alt35=3; |
| 5239 | } | 7994 | } |
| 5240 | break; | 7995 | else { |
| 5241 | case 27: | 7996 | if (state.backtracking>0) {state.failed=true; return current;} |
| 5242 | { | 7997 | NoViableAltException nvae = |
| 5243 | alt35=3; | 7998 | new NoViableAltException("", 35, 2, input); |
| 7999 | |||
| 8000 | throw nvae; | ||
| 8001 | } | ||
| 8002 | } | ||
| 8003 | break; | ||
| 8004 | case 35: | ||
| 8005 | { | ||
| 8006 | alt35=2; | ||
| 8007 | } | ||
| 8008 | break; | ||
| 8009 | case 38: | ||
| 8010 | { | ||
| 8011 | alt35=1; | ||
| 8012 | } | ||
| 8013 | break; | ||
| 8014 | default: | ||
| 8015 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 8016 | NoViableAltException nvae = | ||
| 8017 | new NoViableAltException("", 35, 1, input); | ||
| 8018 | |||
| 8019 | throw nvae; | ||
| 5244 | } | 8020 | } |
| 5245 | break; | 8021 | |
| 5246 | default: | 8022 | } |
| 8023 | else { | ||
| 8024 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 5247 | NoViableAltException nvae = | 8025 | NoViableAltException nvae = |
| 5248 | new NoViableAltException("", 35, 0, input); | 8026 | new NoViableAltException("", 35, 0, input); |
| 5249 | 8027 | ||
| 5250 | throw nvae; | 8028 | throw nvae; |
| 5251 | } | 8029 | } |
| 5252 | |||
| 5253 | switch (alt35) { | 8030 | switch (alt35) { |
| 5254 | case 1 : | 8031 | case 1 : |
| 5255 | // InternalSolverLanguage.g:1791:3: this_Variable_0= ruleVariable | 8032 | // InternalSolverLanguage.g:2781:3: this_ManyMultiplicity_0= ruleManyMultiplicity |
| 5256 | { | 8033 | { |
| 8034 | if ( state.backtracking==0 ) { | ||
| 5257 | 8035 | ||
| 5258 | newCompositeNode(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); | 8036 | newCompositeNode(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); |
| 5259 | 8037 | ||
| 8038 | } | ||
| 5260 | pushFollow(FOLLOW_2); | 8039 | pushFollow(FOLLOW_2); |
| 5261 | this_Variable_0=ruleVariable(); | 8040 | this_ManyMultiplicity_0=ruleManyMultiplicity(); |
| 5262 | 8041 | ||
| 5263 | state._fsp--; | 8042 | state._fsp--; |
| 8043 | if (state.failed) return current; | ||
| 8044 | if ( state.backtracking==0 ) { | ||
| 5264 | 8045 | ||
| 5265 | 8046 | current = this_ManyMultiplicity_0; | |
| 5266 | current = this_Variable_0; | 8047 | afterParserOrEnumRuleCall(); |
| 5267 | afterParserOrEnumRuleCall(); | 8048 | |
| 5268 | 8049 | } | |
| 5269 | 8050 | ||
| 5270 | } | 8051 | } |
| 5271 | break; | 8052 | break; |
| 5272 | case 2 : | 8053 | case 2 : |
| 5273 | // InternalSolverLanguage.g:1800:3: this_DataObject_1= ruleDataObject | 8054 | // InternalSolverLanguage.g:2790:3: this_ExactMultiplicity_1= ruleExactMultiplicity |
| 5274 | { | 8055 | { |
| 8056 | if ( state.backtracking==0 ) { | ||
| 5275 | 8057 | ||
| 5276 | newCompositeNode(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); | 8058 | newCompositeNode(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); |
| 5277 | 8059 | ||
| 8060 | } | ||
| 5278 | pushFollow(FOLLOW_2); | 8061 | pushFollow(FOLLOW_2); |
| 5279 | this_DataObject_1=ruleDataObject(); | 8062 | this_ExactMultiplicity_1=ruleExactMultiplicity(); |
| 5280 | 8063 | ||
| 5281 | state._fsp--; | 8064 | state._fsp--; |
| 8065 | if (state.failed) return current; | ||
| 8066 | if ( state.backtracking==0 ) { | ||
| 5282 | 8067 | ||
| 5283 | 8068 | current = this_ExactMultiplicity_1; | |
| 5284 | current = this_DataObject_1; | 8069 | afterParserOrEnumRuleCall(); |
| 5285 | afterParserOrEnumRuleCall(); | 8070 | |
| 5286 | 8071 | } | |
| 5287 | 8072 | ||
| 5288 | } | 8073 | } |
| 5289 | break; | 8074 | break; |
| 5290 | case 3 : | 8075 | case 3 : |
| 5291 | // InternalSolverLanguage.g:1809:3: this_NamedObject_2= ruleNamedObject | 8076 | // InternalSolverLanguage.g:2799:3: this_BoundedMultiplicity_2= ruleBoundedMultiplicity |
| 5292 | { | 8077 | { |
| 8078 | if ( state.backtracking==0 ) { | ||
| 5293 | 8079 | ||
| 5294 | newCompositeNode(grammarAccess.getLiteralAccess().getNamedObjectParserRuleCall_2()); | 8080 | newCompositeNode(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); |
| 5295 | 8081 | ||
| 8082 | } | ||
| 5296 | pushFollow(FOLLOW_2); | 8083 | pushFollow(FOLLOW_2); |
| 5297 | this_NamedObject_2=ruleNamedObject(); | 8084 | this_BoundedMultiplicity_2=ruleBoundedMultiplicity(); |
| 5298 | 8085 | ||
| 5299 | state._fsp--; | 8086 | state._fsp--; |
| 8087 | if (state.failed) return current; | ||
| 8088 | if ( state.backtracking==0 ) { | ||
| 5300 | 8089 | ||
| 5301 | 8090 | current = this_BoundedMultiplicity_2; | |
| 5302 | current = this_NamedObject_2; | 8091 | afterParserOrEnumRuleCall(); |
| 5303 | afterParserOrEnumRuleCall(); | 8092 | |
| 5304 | 8093 | } | |
| 5305 | 8094 | ||
| 5306 | } | 8095 | } |
| 5307 | break; | 8096 | break; |
| @@ -5311,9 +8100,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5311 | 8100 | ||
| 5312 | } | 8101 | } |
| 5313 | 8102 | ||
| 8103 | if ( state.backtracking==0 ) { | ||
| 5314 | 8104 | ||
| 5315 | leaveRule(); | 8105 | leaveRule(); |
| 5316 | 8106 | ||
| 8107 | } | ||
| 5317 | } | 8108 | } |
| 5318 | 8109 | ||
| 5319 | catch (RecognitionException re) { | 8110 | catch (RecognitionException re) { |
| @@ -5324,29 +8115,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5324 | } | 8115 | } |
| 5325 | return current; | 8116 | return current; |
| 5326 | } | 8117 | } |
| 5327 | // $ANTLR end "ruleLiteral" | 8118 | // $ANTLR end "ruleMultiplicity" |
| 5328 | 8119 | ||
| 5329 | 8120 | ||
| 5330 | // $ANTLR start "entryRuleVariable" | 8121 | // $ANTLR start "entryRuleManyMultiplicity" |
| 5331 | // InternalSolverLanguage.g:1821:1: entryRuleVariable returns [EObject current=null] : iv_ruleVariable= ruleVariable EOF ; | 8122 | // InternalSolverLanguage.g:2811:1: entryRuleManyMultiplicity returns [EObject current=null] : iv_ruleManyMultiplicity= ruleManyMultiplicity EOF ; |
| 5332 | public final EObject entryRuleVariable() throws RecognitionException { | 8123 | public final EObject entryRuleManyMultiplicity() throws RecognitionException { |
| 5333 | EObject current = null; | 8124 | EObject current = null; |
| 5334 | 8125 | ||
| 5335 | EObject iv_ruleVariable = null; | 8126 | EObject iv_ruleManyMultiplicity = null; |
| 5336 | 8127 | ||
| 5337 | 8128 | ||
| 5338 | try { | 8129 | try { |
| 5339 | // InternalSolverLanguage.g:1821:49: (iv_ruleVariable= ruleVariable EOF ) | 8130 | // InternalSolverLanguage.g:2811:57: (iv_ruleManyMultiplicity= ruleManyMultiplicity EOF ) |
| 5340 | // InternalSolverLanguage.g:1822:2: iv_ruleVariable= ruleVariable EOF | 8131 | // InternalSolverLanguage.g:2812:2: iv_ruleManyMultiplicity= ruleManyMultiplicity EOF |
| 5341 | { | 8132 | { |
| 5342 | newCompositeNode(grammarAccess.getVariableRule()); | 8133 | if ( state.backtracking==0 ) { |
| 8134 | newCompositeNode(grammarAccess.getManyMultiplicityRule()); | ||
| 8135 | } | ||
| 5343 | pushFollow(FOLLOW_1); | 8136 | pushFollow(FOLLOW_1); |
| 5344 | iv_ruleVariable=ruleVariable(); | 8137 | iv_ruleManyMultiplicity=ruleManyMultiplicity(); |
| 5345 | 8138 | ||
| 5346 | state._fsp--; | 8139 | state._fsp--; |
| 5347 | 8140 | if (state.failed) return current; | |
| 5348 | current =iv_ruleVariable; | 8141 | if ( state.backtracking==0 ) { |
| 5349 | match(input,EOF,FOLLOW_2); | 8142 | current =iv_ruleManyMultiplicity; |
| 8143 | } | ||
| 8144 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 5350 | 8145 | ||
| 5351 | } | 8146 | } |
| 5352 | 8147 | ||
| @@ -5360,55 +8155,63 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5360 | } | 8155 | } |
| 5361 | return current; | 8156 | return current; |
| 5362 | } | 8157 | } |
| 5363 | // $ANTLR end "entryRuleVariable" | 8158 | // $ANTLR end "entryRuleManyMultiplicity" |
| 5364 | 8159 | ||
| 5365 | 8160 | ||
| 5366 | // $ANTLR start "ruleVariable" | 8161 | // $ANTLR start "ruleManyMultiplicity" |
| 5367 | // InternalSolverLanguage.g:1828:1: ruleVariable returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; | 8162 | // InternalSolverLanguage.g:2818:1: ruleManyMultiplicity returns [EObject current=null] : ( () otherlv_1= '[' otherlv_2= ']' ) ; |
| 5368 | public final EObject ruleVariable() throws RecognitionException { | 8163 | public final EObject ruleManyMultiplicity() throws RecognitionException { |
| 5369 | EObject current = null; | 8164 | EObject current = null; |
| 5370 | 8165 | ||
| 5371 | Token lv_name_0_0=null; | 8166 | Token otherlv_1=null; |
| 8167 | Token otherlv_2=null; | ||
| 5372 | 8168 | ||
| 5373 | 8169 | ||
| 5374 | enterRule(); | 8170 | enterRule(); |
| 5375 | 8171 | ||
| 5376 | try { | 8172 | try { |
| 5377 | // InternalSolverLanguage.g:1834:2: ( ( (lv_name_0_0= RULE_ID ) ) ) | 8173 | // InternalSolverLanguage.g:2824:2: ( ( () otherlv_1= '[' otherlv_2= ']' ) ) |
| 5378 | // InternalSolverLanguage.g:1835:2: ( (lv_name_0_0= RULE_ID ) ) | 8174 | // InternalSolverLanguage.g:2825:2: ( () otherlv_1= '[' otherlv_2= ']' ) |
| 5379 | { | 8175 | { |
| 5380 | // InternalSolverLanguage.g:1835:2: ( (lv_name_0_0= RULE_ID ) ) | 8176 | // InternalSolverLanguage.g:2825:2: ( () otherlv_1= '[' otherlv_2= ']' ) |
| 5381 | // InternalSolverLanguage.g:1836:3: (lv_name_0_0= RULE_ID ) | 8177 | // InternalSolverLanguage.g:2826:3: () otherlv_1= '[' otherlv_2= ']' |
| 5382 | { | 8178 | { |
| 5383 | // InternalSolverLanguage.g:1836:3: (lv_name_0_0= RULE_ID ) | 8179 | // InternalSolverLanguage.g:2826:3: () |
| 5384 | // InternalSolverLanguage.g:1837:4: lv_name_0_0= RULE_ID | 8180 | // InternalSolverLanguage.g:2827:4: |
| 5385 | { | 8181 | { |
| 5386 | lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); | 8182 | if ( state.backtracking==0 ) { |
| 5387 | 8183 | ||
| 5388 | newLeafNode(lv_name_0_0, grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); | 8184 | current = forceCreateModelElement( |
| 5389 | 8185 | grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0(), | |
| 8186 | current); | ||
| 8187 | |||
| 8188 | } | ||
| 8189 | |||
| 8190 | } | ||
| 5390 | 8191 | ||
| 5391 | if (current==null) { | 8192 | otherlv_1=(Token)match(input,36,FOLLOW_38); if (state.failed) return current; |
| 5392 | current = createModelElement(grammarAccess.getVariableRule()); | 8193 | if ( state.backtracking==0 ) { |
| 5393 | } | ||
| 5394 | setWithLastConsumed( | ||
| 5395 | current, | ||
| 5396 | "name", | ||
| 5397 | lv_name_0_0, | ||
| 5398 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 5399 | |||
| 5400 | 8194 | ||
| 8195 | newLeafNode(otherlv_1, grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); | ||
| 8196 | |||
| 5401 | } | 8197 | } |
| 8198 | otherlv_2=(Token)match(input,38,FOLLOW_2); if (state.failed) return current; | ||
| 8199 | if ( state.backtracking==0 ) { | ||
| 5402 | 8200 | ||
| 8201 | newLeafNode(otherlv_2, grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
| 8202 | |||
| 8203 | } | ||
| 5403 | 8204 | ||
| 5404 | } | 8205 | } |
| 5405 | 8206 | ||
| 5406 | 8207 | ||
| 5407 | } | 8208 | } |
| 5408 | 8209 | ||
| 8210 | if ( state.backtracking==0 ) { | ||
| 5409 | 8211 | ||
| 5410 | leaveRule(); | 8212 | leaveRule(); |
| 5411 | 8213 | ||
| 8214 | } | ||
| 5412 | } | 8215 | } |
| 5413 | 8216 | ||
| 5414 | catch (RecognitionException re) { | 8217 | catch (RecognitionException re) { |
| @@ -5419,29 +8222,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5419 | } | 8222 | } |
| 5420 | return current; | 8223 | return current; |
| 5421 | } | 8224 | } |
| 5422 | // $ANTLR end "ruleVariable" | 8225 | // $ANTLR end "ruleManyMultiplicity" |
| 5423 | 8226 | ||
| 5424 | 8227 | ||
| 5425 | // $ANTLR start "entryRuleAllInstances" | 8228 | // $ANTLR start "entryRuleExactMultiplicity" |
| 5426 | // InternalSolverLanguage.g:1856:1: entryRuleAllInstances returns [EObject current=null] : iv_ruleAllInstances= ruleAllInstances EOF ; | 8229 | // InternalSolverLanguage.g:2845:1: entryRuleExactMultiplicity returns [EObject current=null] : iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ; |
| 5427 | public final EObject entryRuleAllInstances() throws RecognitionException { | 8230 | public final EObject entryRuleExactMultiplicity() throws RecognitionException { |
| 5428 | EObject current = null; | 8231 | EObject current = null; |
| 5429 | 8232 | ||
| 5430 | EObject iv_ruleAllInstances = null; | 8233 | EObject iv_ruleExactMultiplicity = null; |
| 5431 | 8234 | ||
| 5432 | 8235 | ||
| 5433 | try { | 8236 | try { |
| 5434 | // InternalSolverLanguage.g:1856:53: (iv_ruleAllInstances= ruleAllInstances EOF ) | 8237 | // InternalSolverLanguage.g:2845:58: (iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ) |
| 5435 | // InternalSolverLanguage.g:1857:2: iv_ruleAllInstances= ruleAllInstances EOF | 8238 | // InternalSolverLanguage.g:2846:2: iv_ruleExactMultiplicity= ruleExactMultiplicity EOF |
| 5436 | { | 8239 | { |
| 5437 | newCompositeNode(grammarAccess.getAllInstancesRule()); | 8240 | if ( state.backtracking==0 ) { |
| 8241 | newCompositeNode(grammarAccess.getExactMultiplicityRule()); | ||
| 8242 | } | ||
| 5438 | pushFollow(FOLLOW_1); | 8243 | pushFollow(FOLLOW_1); |
| 5439 | iv_ruleAllInstances=ruleAllInstances(); | 8244 | iv_ruleExactMultiplicity=ruleExactMultiplicity(); |
| 5440 | 8245 | ||
| 5441 | state._fsp--; | 8246 | state._fsp--; |
| 5442 | 8247 | if (state.failed) return current; | |
| 5443 | current =iv_ruleAllInstances; | 8248 | if ( state.backtracking==0 ) { |
| 5444 | match(input,EOF,FOLLOW_2); | 8249 | current =iv_ruleExactMultiplicity; |
| 8250 | } | ||
| 8251 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 5445 | 8252 | ||
| 5446 | } | 8253 | } |
| 5447 | 8254 | ||
| @@ -5455,72 +8262,87 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5455 | } | 8262 | } |
| 5456 | return current; | 8263 | return current; |
| 5457 | } | 8264 | } |
| 5458 | // $ANTLR end "entryRuleAllInstances" | 8265 | // $ANTLR end "entryRuleExactMultiplicity" |
| 5459 | 8266 | ||
| 5460 | 8267 | ||
| 5461 | // $ANTLR start "ruleAllInstances" | 8268 | // $ANTLR start "ruleExactMultiplicity" |
| 5462 | // InternalSolverLanguage.g:1863:1: ruleAllInstances returns [EObject current=null] : (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) ; | 8269 | // InternalSolverLanguage.g:2852:1: ruleExactMultiplicity returns [EObject current=null] : (otherlv_0= '[' ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= ']' ) ; |
| 5463 | public final EObject ruleAllInstances() throws RecognitionException { | 8270 | public final EObject ruleExactMultiplicity() throws RecognitionException { |
| 5464 | EObject current = null; | 8271 | EObject current = null; |
| 5465 | 8272 | ||
| 5466 | Token otherlv_0=null; | 8273 | Token otherlv_0=null; |
| 5467 | EObject lv_symbol_1_0 = null; | 8274 | Token otherlv_2=null; |
| 8275 | AntlrDatatypeRuleToken lv_multiplicity_1_0 = null; | ||
| 5468 | 8276 | ||
| 5469 | 8277 | ||
| 5470 | 8278 | ||
| 5471 | enterRule(); | 8279 | enterRule(); |
| 5472 | 8280 | ||
| 5473 | try { | 8281 | try { |
| 5474 | // InternalSolverLanguage.g:1869:2: ( (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) ) | 8282 | // InternalSolverLanguage.g:2858:2: ( (otherlv_0= '[' ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= ']' ) ) |
| 5475 | // InternalSolverLanguage.g:1870:2: (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) | 8283 | // InternalSolverLanguage.g:2859:2: (otherlv_0= '[' ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= ']' ) |
| 5476 | { | 8284 | { |
| 5477 | // InternalSolverLanguage.g:1870:2: (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) | 8285 | // InternalSolverLanguage.g:2859:2: (otherlv_0= '[' ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= ']' ) |
| 5478 | // InternalSolverLanguage.g:1871:3: otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) | 8286 | // InternalSolverLanguage.g:2860:3: otherlv_0= '[' ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= ']' |
| 5479 | { | 8287 | { |
| 5480 | otherlv_0=(Token)match(input,20,FOLLOW_21); | 8288 | otherlv_0=(Token)match(input,36,FOLLOW_46); if (state.failed) return current; |
| 8289 | if ( state.backtracking==0 ) { | ||
| 5481 | 8290 | ||
| 5482 | newLeafNode(otherlv_0, grammarAccess.getAllInstancesAccess().getColonKeyword_0()); | 8291 | newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); |
| 5483 | 8292 | ||
| 5484 | // InternalSolverLanguage.g:1875:3: ( (lv_symbol_1_0= ruleSymbol ) ) | 8293 | } |
| 5485 | // InternalSolverLanguage.g:1876:4: (lv_symbol_1_0= ruleSymbol ) | 8294 | // InternalSolverLanguage.g:2864:3: ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) |
| 8295 | // InternalSolverLanguage.g:2865:4: (lv_multiplicity_1_0= ruleUpperMultiplicty ) | ||
| 5486 | { | 8296 | { |
| 5487 | // InternalSolverLanguage.g:1876:4: (lv_symbol_1_0= ruleSymbol ) | 8297 | // InternalSolverLanguage.g:2865:4: (lv_multiplicity_1_0= ruleUpperMultiplicty ) |
| 5488 | // InternalSolverLanguage.g:1877:5: lv_symbol_1_0= ruleSymbol | 8298 | // InternalSolverLanguage.g:2866:5: lv_multiplicity_1_0= ruleUpperMultiplicty |
| 5489 | { | 8299 | { |
| 8300 | if ( state.backtracking==0 ) { | ||
| 5490 | 8301 | ||
| 5491 | newCompositeNode(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); | 8302 | newCompositeNode(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); |
| 5492 | 8303 | ||
| 5493 | pushFollow(FOLLOW_2); | 8304 | } |
| 5494 | lv_symbol_1_0=ruleSymbol(); | 8305 | pushFollow(FOLLOW_38); |
| 8306 | lv_multiplicity_1_0=ruleUpperMultiplicty(); | ||
| 5495 | 8307 | ||
| 5496 | state._fsp--; | 8308 | state._fsp--; |
| 8309 | if (state.failed) return current; | ||
| 8310 | if ( state.backtracking==0 ) { | ||
| 5497 | 8311 | ||
| 5498 | 8312 | if (current==null) { | |
| 5499 | if (current==null) { | 8313 | current = createModelElementForParent(grammarAccess.getExactMultiplicityRule()); |
| 5500 | current = createModelElementForParent(grammarAccess.getAllInstancesRule()); | 8314 | } |
| 5501 | } | 8315 | set( |
| 5502 | set( | 8316 | current, |
| 5503 | current, | 8317 | "multiplicity", |
| 5504 | "symbol", | 8318 | lv_multiplicity_1_0, |
| 5505 | lv_symbol_1_0, | 8319 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); |
| 5506 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | 8320 | afterParserOrEnumRuleCall(); |
| 5507 | afterParserOrEnumRuleCall(); | 8321 | |
| 5508 | 8322 | } | |
| 5509 | 8323 | ||
| 5510 | } | 8324 | } |
| 5511 | 8325 | ||
| 5512 | 8326 | ||
| 5513 | } | 8327 | } |
| 5514 | 8328 | ||
| 8329 | otherlv_2=(Token)match(input,38,FOLLOW_2); if (state.failed) return current; | ||
| 8330 | if ( state.backtracking==0 ) { | ||
| 8331 | |||
| 8332 | newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
| 8333 | |||
| 8334 | } | ||
| 5515 | 8335 | ||
| 5516 | } | 8336 | } |
| 5517 | 8337 | ||
| 5518 | 8338 | ||
| 5519 | } | 8339 | } |
| 5520 | 8340 | ||
| 8341 | if ( state.backtracking==0 ) { | ||
| 5521 | 8342 | ||
| 5522 | leaveRule(); | 8343 | leaveRule(); |
| 5523 | 8344 | ||
| 8345 | } | ||
| 5524 | } | 8346 | } |
| 5525 | 8347 | ||
| 5526 | catch (RecognitionException re) { | 8348 | catch (RecognitionException re) { |
| @@ -5531,29 +8353,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5531 | } | 8353 | } |
| 5532 | return current; | 8354 | return current; |
| 5533 | } | 8355 | } |
| 5534 | // $ANTLR end "ruleAllInstances" | 8356 | // $ANTLR end "ruleExactMultiplicity" |
| 5535 | 8357 | ||
| 5536 | 8358 | ||
| 5537 | // $ANTLR start "entryRuleAllObjects" | 8359 | // $ANTLR start "entryRuleBoundedMultiplicity" |
| 5538 | // InternalSolverLanguage.g:1898:1: entryRuleAllObjects returns [EObject current=null] : iv_ruleAllObjects= ruleAllObjects EOF ; | 8360 | // InternalSolverLanguage.g:2891:1: entryRuleBoundedMultiplicity returns [EObject current=null] : iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF ; |
| 5539 | public final EObject entryRuleAllObjects() throws RecognitionException { | 8361 | public final EObject entryRuleBoundedMultiplicity() throws RecognitionException { |
| 5540 | EObject current = null; | 8362 | EObject current = null; |
| 5541 | 8363 | ||
| 5542 | EObject iv_ruleAllObjects = null; | 8364 | EObject iv_ruleBoundedMultiplicity = null; |
| 5543 | 8365 | ||
| 5544 | 8366 | ||
| 5545 | try { | 8367 | try { |
| 5546 | // InternalSolverLanguage.g:1898:51: (iv_ruleAllObjects= ruleAllObjects EOF ) | 8368 | // InternalSolverLanguage.g:2891:60: (iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF ) |
| 5547 | // InternalSolverLanguage.g:1899:2: iv_ruleAllObjects= ruleAllObjects EOF | 8369 | // InternalSolverLanguage.g:2892:2: iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF |
| 5548 | { | 8370 | { |
| 5549 | newCompositeNode(grammarAccess.getAllObjectsRule()); | 8371 | if ( state.backtracking==0 ) { |
| 8372 | newCompositeNode(grammarAccess.getBoundedMultiplicityRule()); | ||
| 8373 | } | ||
| 5550 | pushFollow(FOLLOW_1); | 8374 | pushFollow(FOLLOW_1); |
| 5551 | iv_ruleAllObjects=ruleAllObjects(); | 8375 | iv_ruleBoundedMultiplicity=ruleBoundedMultiplicity(); |
| 5552 | 8376 | ||
| 5553 | state._fsp--; | 8377 | state._fsp--; |
| 5554 | 8378 | if (state.failed) return current; | |
| 5555 | current =iv_ruleAllObjects; | 8379 | if ( state.backtracking==0 ) { |
| 5556 | match(input,EOF,FOLLOW_2); | 8380 | current =iv_ruleBoundedMultiplicity; |
| 8381 | } | ||
| 8382 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 5557 | 8383 | ||
| 5558 | } | 8384 | } |
| 5559 | 8385 | ||
| @@ -5567,50 +8393,125 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5567 | } | 8393 | } |
| 5568 | return current; | 8394 | return current; |
| 5569 | } | 8395 | } |
| 5570 | // $ANTLR end "entryRuleAllObjects" | 8396 | // $ANTLR end "entryRuleBoundedMultiplicity" |
| 5571 | 8397 | ||
| 5572 | 8398 | ||
| 5573 | // $ANTLR start "ruleAllObjects" | 8399 | // $ANTLR start "ruleBoundedMultiplicity" |
| 5574 | // InternalSolverLanguage.g:1905:1: ruleAllObjects returns [EObject current=null] : ( () otherlv_1= '*' ) ; | 8400 | // InternalSolverLanguage.g:2898:1: ruleBoundedMultiplicity returns [EObject current=null] : (otherlv_0= '[' ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= ']' ) ; |
| 5575 | public final EObject ruleAllObjects() throws RecognitionException { | 8401 | public final EObject ruleBoundedMultiplicity() throws RecognitionException { |
| 5576 | EObject current = null; | 8402 | EObject current = null; |
| 5577 | 8403 | ||
| 5578 | Token otherlv_1=null; | 8404 | Token otherlv_0=null; |
| 8405 | Token lv_lowerBound_1_0=null; | ||
| 8406 | Token otherlv_2=null; | ||
| 8407 | Token otherlv_4=null; | ||
| 8408 | AntlrDatatypeRuleToken lv_upperBound_3_0 = null; | ||
| 8409 | |||
| 5579 | 8410 | ||
| 5580 | 8411 | ||
| 5581 | enterRule(); | 8412 | enterRule(); |
| 5582 | 8413 | ||
| 5583 | try { | 8414 | try { |
| 5584 | // InternalSolverLanguage.g:1911:2: ( ( () otherlv_1= '*' ) ) | 8415 | // InternalSolverLanguage.g:2904:2: ( (otherlv_0= '[' ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= ']' ) ) |
| 5585 | // InternalSolverLanguage.g:1912:2: ( () otherlv_1= '*' ) | 8416 | // InternalSolverLanguage.g:2905:2: (otherlv_0= '[' ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= ']' ) |
| 5586 | { | 8417 | { |
| 5587 | // InternalSolverLanguage.g:1912:2: ( () otherlv_1= '*' ) | 8418 | // InternalSolverLanguage.g:2905:2: (otherlv_0= '[' ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= ']' ) |
| 5588 | // InternalSolverLanguage.g:1913:3: () otherlv_1= '*' | 8419 | // InternalSolverLanguage.g:2906:3: otherlv_0= '[' ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= ']' |
| 5589 | { | 8420 | { |
| 5590 | // InternalSolverLanguage.g:1913:3: () | 8421 | otherlv_0=(Token)match(input,36,FOLLOW_47); if (state.failed) return current; |
| 5591 | // InternalSolverLanguage.g:1914:4: | 8422 | if ( state.backtracking==0 ) { |
| 8423 | |||
| 8424 | newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
| 8425 | |||
| 8426 | } | ||
| 8427 | // InternalSolverLanguage.g:2910:3: ( (lv_lowerBound_1_0= RULE_INT ) ) | ||
| 8428 | // InternalSolverLanguage.g:2911:4: (lv_lowerBound_1_0= RULE_INT ) | ||
| 5592 | { | 8429 | { |
| 8430 | // InternalSolverLanguage.g:2911:4: (lv_lowerBound_1_0= RULE_INT ) | ||
| 8431 | // InternalSolverLanguage.g:2912:5: lv_lowerBound_1_0= RULE_INT | ||
| 8432 | { | ||
| 8433 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_37); if (state.failed) return current; | ||
| 8434 | if ( state.backtracking==0 ) { | ||
| 5593 | 8435 | ||
| 5594 | current = forceCreateModelElement( | 8436 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); |
| 5595 | grammarAccess.getAllObjectsAccess().getAllObjectsAction_0(), | 8437 | |
| 5596 | current); | 8438 | } |
| 5597 | 8439 | if ( state.backtracking==0 ) { | |
| 5598 | 8440 | ||
| 8441 | if (current==null) { | ||
| 8442 | current = createModelElement(grammarAccess.getBoundedMultiplicityRule()); | ||
| 8443 | } | ||
| 8444 | setWithLastConsumed( | ||
| 8445 | current, | ||
| 8446 | "lowerBound", | ||
| 8447 | lv_lowerBound_1_0, | ||
| 8448 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 8449 | |||
| 5599 | } | 8450 | } |
| 5600 | 8451 | ||
| 5601 | otherlv_1=(Token)match(input,31,FOLLOW_2); | 8452 | } |
| 5602 | 8453 | ||
| 5603 | newLeafNode(otherlv_1, grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); | ||
| 5604 | |||
| 5605 | 8454 | ||
| 5606 | } | 8455 | } |
| 5607 | 8456 | ||
| 8457 | otherlv_2=(Token)match(input,37,FOLLOW_46); if (state.failed) return current; | ||
| 8458 | if ( state.backtracking==0 ) { | ||
| 5608 | 8459 | ||
| 8460 | newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); | ||
| 8461 | |||
| 5609 | } | 8462 | } |
| 8463 | // InternalSolverLanguage.g:2932:3: ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) | ||
| 8464 | // InternalSolverLanguage.g:2933:4: (lv_upperBound_3_0= ruleUpperMultiplicty ) | ||
| 8465 | { | ||
| 8466 | // InternalSolverLanguage.g:2933:4: (lv_upperBound_3_0= ruleUpperMultiplicty ) | ||
| 8467 | // InternalSolverLanguage.g:2934:5: lv_upperBound_3_0= ruleUpperMultiplicty | ||
| 8468 | { | ||
| 8469 | if ( state.backtracking==0 ) { | ||
| 8470 | |||
| 8471 | newCompositeNode(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); | ||
| 8472 | |||
| 8473 | } | ||
| 8474 | pushFollow(FOLLOW_38); | ||
| 8475 | lv_upperBound_3_0=ruleUpperMultiplicty(); | ||
| 5610 | 8476 | ||
| 8477 | state._fsp--; | ||
| 8478 | if (state.failed) return current; | ||
| 8479 | if ( state.backtracking==0 ) { | ||
| 8480 | |||
| 8481 | if (current==null) { | ||
| 8482 | current = createModelElementForParent(grammarAccess.getBoundedMultiplicityRule()); | ||
| 8483 | } | ||
| 8484 | set( | ||
| 8485 | current, | ||
| 8486 | "upperBound", | ||
| 8487 | lv_upperBound_3_0, | ||
| 8488 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
| 8489 | afterParserOrEnumRuleCall(); | ||
| 8490 | |||
| 8491 | } | ||
| 5611 | 8492 | ||
| 5612 | leaveRule(); | 8493 | } |
| 5613 | 8494 | ||
| 8495 | |||
| 8496 | } | ||
| 8497 | |||
| 8498 | otherlv_4=(Token)match(input,38,FOLLOW_2); if (state.failed) return current; | ||
| 8499 | if ( state.backtracking==0 ) { | ||
| 8500 | |||
| 8501 | newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); | ||
| 8502 | |||
| 8503 | } | ||
| 8504 | |||
| 8505 | } | ||
| 8506 | |||
| 8507 | |||
| 8508 | } | ||
| 8509 | |||
| 8510 | if ( state.backtracking==0 ) { | ||
| 8511 | |||
| 8512 | leaveRule(); | ||
| 8513 | |||
| 8514 | } | ||
| 5614 | } | 8515 | } |
| 5615 | 8516 | ||
| 5616 | catch (RecognitionException re) { | 8517 | catch (RecognitionException re) { |
| @@ -5621,32 +8522,149 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5621 | } | 8522 | } |
| 5622 | return current; | 8523 | return current; |
| 5623 | } | 8524 | } |
| 5624 | // $ANTLR end "ruleAllObjects" | 8525 | // $ANTLR end "ruleBoundedMultiplicity" |
| 5625 | 8526 | ||
| 5626 | 8527 | ||
| 5627 | // $ANTLR start "entryRuleDefaultInterpretation" | 8528 | // $ANTLR start "entryRuleScopeDefinition" |
| 5628 | // InternalSolverLanguage.g:1928:1: entryRuleDefaultInterpretation returns [EObject current=null] : iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF ; | 8529 | // InternalSolverLanguage.g:2959:1: entryRuleScopeDefinition returns [EObject current=null] : iv_ruleScopeDefinition= ruleScopeDefinition EOF ; |
| 5629 | public final EObject entryRuleDefaultInterpretation() throws RecognitionException { | 8530 | public final EObject entryRuleScopeDefinition() throws RecognitionException { |
| 5630 | EObject current = null; | 8531 | EObject current = null; |
| 5631 | 8532 | ||
| 5632 | EObject iv_ruleDefaultInterpretation = null; | 8533 | EObject iv_ruleScopeDefinition = null; |
| 5633 | 8534 | ||
| 5634 | 8535 | ||
| 5635 | try { | 8536 | try { |
| 5636 | // InternalSolverLanguage.g:1928:62: (iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF ) | 8537 | // InternalSolverLanguage.g:2959:56: (iv_ruleScopeDefinition= ruleScopeDefinition EOF ) |
| 5637 | // InternalSolverLanguage.g:1929:2: iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF | 8538 | // InternalSolverLanguage.g:2960:2: iv_ruleScopeDefinition= ruleScopeDefinition EOF |
| 5638 | { | 8539 | { |
| 5639 | newCompositeNode(grammarAccess.getDefaultInterpretationRule()); | 8540 | if ( state.backtracking==0 ) { |
| 8541 | newCompositeNode(grammarAccess.getScopeDefinitionRule()); | ||
| 8542 | } | ||
| 5640 | pushFollow(FOLLOW_1); | 8543 | pushFollow(FOLLOW_1); |
| 5641 | iv_ruleDefaultInterpretation=ruleDefaultInterpretation(); | 8544 | iv_ruleScopeDefinition=ruleScopeDefinition(); |
| 5642 | 8545 | ||
| 5643 | state._fsp--; | 8546 | state._fsp--; |
| 8547 | if (state.failed) return current; | ||
| 8548 | if ( state.backtracking==0 ) { | ||
| 8549 | current =iv_ruleScopeDefinition; | ||
| 8550 | } | ||
| 8551 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 8552 | |||
| 8553 | } | ||
| 8554 | |||
| 8555 | } | ||
| 8556 | |||
| 8557 | catch (RecognitionException re) { | ||
| 8558 | recover(input,re); | ||
| 8559 | appendSkippedTokens(); | ||
| 8560 | } | ||
| 8561 | finally { | ||
| 8562 | } | ||
| 8563 | return current; | ||
| 8564 | } | ||
| 8565 | // $ANTLR end "entryRuleScopeDefinition" | ||
| 8566 | |||
| 8567 | |||
| 8568 | // $ANTLR start "ruleScopeDefinition" | ||
| 8569 | // InternalSolverLanguage.g:2966:1: ruleScopeDefinition returns [EObject current=null] : (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) ; | ||
| 8570 | public final EObject ruleScopeDefinition() throws RecognitionException { | ||
| 8571 | EObject current = null; | ||
| 8572 | |||
| 8573 | EObject this_ExactScopeDefinition_0 = null; | ||
| 8574 | |||
| 8575 | EObject this_BoundedScopeDefinition_1 = null; | ||
| 8576 | |||
| 8577 | EObject this_LowerBoundedScopeDefinition_2 = null; | ||
| 8578 | |||
| 8579 | |||
| 8580 | |||
| 8581 | enterRule(); | ||
| 8582 | |||
| 8583 | try { | ||
| 8584 | // InternalSolverLanguage.g:2972:2: ( (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) ) | ||
| 8585 | // InternalSolverLanguage.g:2973:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) | ||
| 8586 | { | ||
| 8587 | // InternalSolverLanguage.g:2973:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) | ||
| 8588 | int alt36=3; | ||
| 8589 | alt36 = dfa36.predict(input); | ||
| 8590 | switch (alt36) { | ||
| 8591 | case 1 : | ||
| 8592 | // InternalSolverLanguage.g:2974:3: this_ExactScopeDefinition_0= ruleExactScopeDefinition | ||
| 8593 | { | ||
| 8594 | if ( state.backtracking==0 ) { | ||
| 8595 | |||
| 8596 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); | ||
| 8597 | |||
| 8598 | } | ||
| 8599 | pushFollow(FOLLOW_2); | ||
| 8600 | this_ExactScopeDefinition_0=ruleExactScopeDefinition(); | ||
| 8601 | |||
| 8602 | state._fsp--; | ||
| 8603 | if (state.failed) return current; | ||
| 8604 | if ( state.backtracking==0 ) { | ||
| 5644 | 8605 | ||
| 5645 | current =iv_ruleDefaultInterpretation; | 8606 | current = this_ExactScopeDefinition_0; |
| 5646 | match(input,EOF,FOLLOW_2); | 8607 | afterParserOrEnumRuleCall(); |
| 8608 | |||
| 8609 | } | ||
| 8610 | |||
| 8611 | } | ||
| 8612 | break; | ||
| 8613 | case 2 : | ||
| 8614 | // InternalSolverLanguage.g:2983:3: this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | ||
| 8615 | { | ||
| 8616 | if ( state.backtracking==0 ) { | ||
| 8617 | |||
| 8618 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); | ||
| 8619 | |||
| 8620 | } | ||
| 8621 | pushFollow(FOLLOW_2); | ||
| 8622 | this_BoundedScopeDefinition_1=ruleBoundedScopeDefinition(); | ||
| 8623 | |||
| 8624 | state._fsp--; | ||
| 8625 | if (state.failed) return current; | ||
| 8626 | if ( state.backtracking==0 ) { | ||
| 8627 | |||
| 8628 | current = this_BoundedScopeDefinition_1; | ||
| 8629 | afterParserOrEnumRuleCall(); | ||
| 8630 | |||
| 8631 | } | ||
| 8632 | |||
| 8633 | } | ||
| 8634 | break; | ||
| 8635 | case 3 : | ||
| 8636 | // InternalSolverLanguage.g:2992:3: this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition | ||
| 8637 | { | ||
| 8638 | if ( state.backtracking==0 ) { | ||
| 8639 | |||
| 8640 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); | ||
| 8641 | |||
| 8642 | } | ||
| 8643 | pushFollow(FOLLOW_2); | ||
| 8644 | this_LowerBoundedScopeDefinition_2=ruleLowerBoundedScopeDefinition(); | ||
| 8645 | |||
| 8646 | state._fsp--; | ||
| 8647 | if (state.failed) return current; | ||
| 8648 | if ( state.backtracking==0 ) { | ||
| 8649 | |||
| 8650 | current = this_LowerBoundedScopeDefinition_2; | ||
| 8651 | afterParserOrEnumRuleCall(); | ||
| 8652 | |||
| 8653 | } | ||
| 8654 | |||
| 8655 | } | ||
| 8656 | break; | ||
| 5647 | 8657 | ||
| 5648 | } | 8658 | } |
| 5649 | 8659 | ||
| 8660 | |||
| 8661 | } | ||
| 8662 | |||
| 8663 | if ( state.backtracking==0 ) { | ||
| 8664 | |||
| 8665 | leaveRule(); | ||
| 8666 | |||
| 8667 | } | ||
| 5650 | } | 8668 | } |
| 5651 | 8669 | ||
| 5652 | catch (RecognitionException re) { | 8670 | catch (RecognitionException re) { |
| @@ -5657,63 +8675,138 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5657 | } | 8675 | } |
| 5658 | return current; | 8676 | return current; |
| 5659 | } | 8677 | } |
| 5660 | // $ANTLR end "entryRuleDefaultInterpretation" | 8678 | // $ANTLR end "ruleScopeDefinition" |
| 5661 | 8679 | ||
| 5662 | 8680 | ||
| 5663 | // $ANTLR start "ruleDefaultInterpretation" | 8681 | // $ANTLR start "entryRuleExactScopeDefinition" |
| 5664 | // InternalSolverLanguage.g:1935:1: ruleDefaultInterpretation returns [EObject current=null] : (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) ; | 8682 | // InternalSolverLanguage.g:3004:1: entryRuleExactScopeDefinition returns [EObject current=null] : iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF ; |
| 5665 | public final EObject ruleDefaultInterpretation() throws RecognitionException { | 8683 | public final EObject entryRuleExactScopeDefinition() throws RecognitionException { |
| 5666 | EObject current = null; | 8684 | EObject current = null; |
| 5667 | 8685 | ||
| 5668 | Token otherlv_0=null; | 8686 | EObject iv_ruleExactScopeDefinition = null; |
| 5669 | EObject lv_interpretation_1_0 = null; | 8687 | |
| 8688 | |||
| 8689 | try { | ||
| 8690 | // InternalSolverLanguage.g:3004:61: (iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF ) | ||
| 8691 | // InternalSolverLanguage.g:3005:2: iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF | ||
| 8692 | { | ||
| 8693 | if ( state.backtracking==0 ) { | ||
| 8694 | newCompositeNode(grammarAccess.getExactScopeDefinitionRule()); | ||
| 8695 | } | ||
| 8696 | pushFollow(FOLLOW_1); | ||
| 8697 | iv_ruleExactScopeDefinition=ruleExactScopeDefinition(); | ||
| 8698 | |||
| 8699 | state._fsp--; | ||
| 8700 | if (state.failed) return current; | ||
| 8701 | if ( state.backtracking==0 ) { | ||
| 8702 | current =iv_ruleExactScopeDefinition; | ||
| 8703 | } | ||
| 8704 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 8705 | |||
| 8706 | } | ||
| 5670 | 8707 | ||
| 8708 | } | ||
| 8709 | |||
| 8710 | catch (RecognitionException re) { | ||
| 8711 | recover(input,re); | ||
| 8712 | appendSkippedTokens(); | ||
| 8713 | } | ||
| 8714 | finally { | ||
| 8715 | } | ||
| 8716 | return current; | ||
| 8717 | } | ||
| 8718 | // $ANTLR end "entryRuleExactScopeDefinition" | ||
| 8719 | |||
| 8720 | |||
| 8721 | // $ANTLR start "ruleExactScopeDefinition" | ||
| 8722 | // InternalSolverLanguage.g:3011:1: ruleExactScopeDefinition returns [EObject current=null] : (otherlv_0= 'scope' ( ( ruleQualifiedName ) ) otherlv_2= '==' ( (lv_exactScope_3_0= RULE_INT ) ) ) ; | ||
| 8723 | public final EObject ruleExactScopeDefinition() throws RecognitionException { | ||
| 8724 | EObject current = null; | ||
| 8725 | |||
| 8726 | Token otherlv_0=null; | ||
| 8727 | Token otherlv_2=null; | ||
| 8728 | Token lv_exactScope_3_0=null; | ||
| 5671 | 8729 | ||
| 5672 | 8730 | ||
| 5673 | enterRule(); | 8731 | enterRule(); |
| 5674 | 8732 | ||
| 5675 | try { | 8733 | try { |
| 5676 | // InternalSolverLanguage.g:1941:2: ( (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) ) | 8734 | // InternalSolverLanguage.g:3017:2: ( (otherlv_0= 'scope' ( ( ruleQualifiedName ) ) otherlv_2= '==' ( (lv_exactScope_3_0= RULE_INT ) ) ) ) |
| 5677 | // InternalSolverLanguage.g:1942:2: (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) | 8735 | // InternalSolverLanguage.g:3018:2: (otherlv_0= 'scope' ( ( ruleQualifiedName ) ) otherlv_2= '==' ( (lv_exactScope_3_0= RULE_INT ) ) ) |
| 5678 | { | 8736 | { |
| 5679 | // InternalSolverLanguage.g:1942:2: (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) | 8737 | // InternalSolverLanguage.g:3018:2: (otherlv_0= 'scope' ( ( ruleQualifiedName ) ) otherlv_2= '==' ( (lv_exactScope_3_0= RULE_INT ) ) ) |
| 5680 | // InternalSolverLanguage.g:1943:3: otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) | 8738 | // InternalSolverLanguage.g:3019:3: otherlv_0= 'scope' ( ( ruleQualifiedName ) ) otherlv_2= '==' ( (lv_exactScope_3_0= RULE_INT ) ) |
| 5681 | { | 8739 | { |
| 5682 | otherlv_0=(Token)match(input,32,FOLLOW_21); | 8740 | otherlv_0=(Token)match(input,46,FOLLOW_35); if (state.failed) return current; |
| 8741 | if ( state.backtracking==0 ) { | ||
| 5683 | 8742 | ||
| 5684 | newLeafNode(otherlv_0, grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); | 8743 | newLeafNode(otherlv_0, grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); |
| 5685 | 8744 | ||
| 5686 | // InternalSolverLanguage.g:1947:3: ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) | 8745 | } |
| 5687 | // InternalSolverLanguage.g:1948:4: (lv_interpretation_1_0= ruleBasicInterpretation ) | 8746 | // InternalSolverLanguage.g:3023:3: ( ( ruleQualifiedName ) ) |
| 8747 | // InternalSolverLanguage.g:3024:4: ( ruleQualifiedName ) | ||
| 5688 | { | 8748 | { |
| 5689 | // InternalSolverLanguage.g:1948:4: (lv_interpretation_1_0= ruleBasicInterpretation ) | 8749 | // InternalSolverLanguage.g:3024:4: ( ruleQualifiedName ) |
| 5690 | // InternalSolverLanguage.g:1949:5: lv_interpretation_1_0= ruleBasicInterpretation | 8750 | // InternalSolverLanguage.g:3025:5: ruleQualifiedName |
| 5691 | { | 8751 | { |
| 8752 | if ( state.backtracking==0 ) { | ||
| 5692 | 8753 | ||
| 5693 | newCompositeNode(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); | 8754 | if (current==null) { |
| 5694 | 8755 | current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); | |
| 5695 | pushFollow(FOLLOW_2); | 8756 | } |
| 5696 | lv_interpretation_1_0=ruleBasicInterpretation(); | 8757 | |
| 8758 | } | ||
| 8759 | if ( state.backtracking==0 ) { | ||
| 8760 | |||
| 8761 | newCompositeNode(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | ||
| 8762 | |||
| 8763 | } | ||
| 8764 | pushFollow(FOLLOW_48); | ||
| 8765 | ruleQualifiedName(); | ||
| 5697 | 8766 | ||
| 5698 | state._fsp--; | 8767 | state._fsp--; |
| 8768 | if (state.failed) return current; | ||
| 8769 | if ( state.backtracking==0 ) { | ||
| 5699 | 8770 | ||
| 8771 | afterParserOrEnumRuleCall(); | ||
| 8772 | |||
| 8773 | } | ||
| 8774 | |||
| 8775 | } | ||
| 5700 | 8776 | ||
| 5701 | if (current==null) { | ||
| 5702 | current = createModelElementForParent(grammarAccess.getDefaultInterpretationRule()); | ||
| 5703 | } | ||
| 5704 | set( | ||
| 5705 | current, | ||
| 5706 | "interpretation", | ||
| 5707 | lv_interpretation_1_0, | ||
| 5708 | "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation"); | ||
| 5709 | afterParserOrEnumRuleCall(); | ||
| 5710 | |||
| 5711 | 8777 | ||
| 5712 | } | 8778 | } |
| 5713 | 8779 | ||
| 8780 | otherlv_2=(Token)match(input,47,FOLLOW_47); if (state.failed) return current; | ||
| 8781 | if ( state.backtracking==0 ) { | ||
| 5714 | 8782 | ||
| 8783 | newLeafNode(otherlv_2, grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); | ||
| 8784 | |||
| 5715 | } | 8785 | } |
| 8786 | // InternalSolverLanguage.g:3043:3: ( (lv_exactScope_3_0= RULE_INT ) ) | ||
| 8787 | // InternalSolverLanguage.g:3044:4: (lv_exactScope_3_0= RULE_INT ) | ||
| 8788 | { | ||
| 8789 | // InternalSolverLanguage.g:3044:4: (lv_exactScope_3_0= RULE_INT ) | ||
| 8790 | // InternalSolverLanguage.g:3045:5: lv_exactScope_3_0= RULE_INT | ||
| 8791 | { | ||
| 8792 | lv_exactScope_3_0=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current; | ||
| 8793 | if ( state.backtracking==0 ) { | ||
| 5716 | 8794 | ||
| 8795 | newLeafNode(lv_exactScope_3_0, grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); | ||
| 8796 | |||
| 8797 | } | ||
| 8798 | if ( state.backtracking==0 ) { | ||
| 8799 | |||
| 8800 | if (current==null) { | ||
| 8801 | current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); | ||
| 8802 | } | ||
| 8803 | setWithLastConsumed( | ||
| 8804 | current, | ||
| 8805 | "exactScope", | ||
| 8806 | lv_exactScope_3_0, | ||
| 8807 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 8808 | |||
| 8809 | } | ||
| 5717 | 8810 | ||
| 5718 | } | 8811 | } |
| 5719 | 8812 | ||
| @@ -5721,8 +8814,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5721 | } | 8814 | } |
| 5722 | 8815 | ||
| 5723 | 8816 | ||
| 5724 | leaveRule(); | 8817 | } |
| 8818 | |||
| 8819 | |||
| 8820 | } | ||
| 5725 | 8821 | ||
| 8822 | if ( state.backtracking==0 ) { | ||
| 8823 | |||
| 8824 | leaveRule(); | ||
| 8825 | |||
| 8826 | } | ||
| 5726 | } | 8827 | } |
| 5727 | 8828 | ||
| 5728 | catch (RecognitionException re) { | 8829 | catch (RecognitionException re) { |
| @@ -5733,29 +8834,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5733 | } | 8834 | } |
| 5734 | return current; | 8835 | return current; |
| 5735 | } | 8836 | } |
| 5736 | // $ANTLR end "ruleDefaultInterpretation" | 8837 | // $ANTLR end "ruleExactScopeDefinition" |
| 5737 | 8838 | ||
| 5738 | 8839 | ||
| 5739 | // $ANTLR start "entryRuleCDInterpretation" | 8840 | // $ANTLR start "entryRuleBoundedScopeDefinition" |
| 5740 | // InternalSolverLanguage.g:1970:1: entryRuleCDInterpretation returns [EObject current=null] : iv_ruleCDInterpretation= ruleCDInterpretation EOF ; | 8841 | // InternalSolverLanguage.g:3065:1: entryRuleBoundedScopeDefinition returns [EObject current=null] : iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF ; |
| 5741 | public final EObject entryRuleCDInterpretation() throws RecognitionException { | 8842 | public final EObject entryRuleBoundedScopeDefinition() throws RecognitionException { |
| 5742 | EObject current = null; | 8843 | EObject current = null; |
| 5743 | 8844 | ||
| 5744 | EObject iv_ruleCDInterpretation = null; | 8845 | EObject iv_ruleBoundedScopeDefinition = null; |
| 5745 | 8846 | ||
| 5746 | 8847 | ||
| 5747 | try { | 8848 | try { |
| 5748 | // InternalSolverLanguage.g:1970:57: (iv_ruleCDInterpretation= ruleCDInterpretation EOF ) | 8849 | // InternalSolverLanguage.g:3065:63: (iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF ) |
| 5749 | // InternalSolverLanguage.g:1971:2: iv_ruleCDInterpretation= ruleCDInterpretation EOF | 8850 | // InternalSolverLanguage.g:3066:2: iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF |
| 5750 | { | 8851 | { |
| 5751 | newCompositeNode(grammarAccess.getCDInterpretationRule()); | 8852 | if ( state.backtracking==0 ) { |
| 8853 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 8854 | } | ||
| 5752 | pushFollow(FOLLOW_1); | 8855 | pushFollow(FOLLOW_1); |
| 5753 | iv_ruleCDInterpretation=ruleCDInterpretation(); | 8856 | iv_ruleBoundedScopeDefinition=ruleBoundedScopeDefinition(); |
| 5754 | 8857 | ||
| 5755 | state._fsp--; | 8858 | state._fsp--; |
| 5756 | 8859 | if (state.failed) return current; | |
| 5757 | current =iv_ruleCDInterpretation; | 8860 | if ( state.backtracking==0 ) { |
| 5758 | match(input,EOF,FOLLOW_2); | 8861 | current =iv_ruleBoundedScopeDefinition; |
| 8862 | } | ||
| 8863 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 5759 | 8864 | ||
| 5760 | } | 8865 | } |
| 5761 | 8866 | ||
| @@ -5769,119 +8874,363 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5769 | } | 8874 | } |
| 5770 | return current; | 8875 | return current; |
| 5771 | } | 8876 | } |
| 5772 | // $ANTLR end "entryRuleCDInterpretation" | 8877 | // $ANTLR end "entryRuleBoundedScopeDefinition" |
| 5773 | 8878 | ||
| 5774 | 8879 | ||
| 5775 | // $ANTLR start "ruleCDInterpretation" | 8880 | // $ANTLR start "ruleBoundedScopeDefinition" |
| 5776 | // InternalSolverLanguage.g:1977:1: ruleCDInterpretation returns [EObject current=null] : (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) ; | 8881 | // InternalSolverLanguage.g:3072:1: ruleBoundedScopeDefinition returns [EObject current=null] : (otherlv_0= 'scope' ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) otherlv_11= '.' ) ; |
| 5777 | public final EObject ruleCDInterpretation() throws RecognitionException { | 8882 | public final EObject ruleBoundedScopeDefinition() throws RecognitionException { |
| 5778 | EObject current = null; | 8883 | EObject current = null; |
| 5779 | 8884 | ||
| 5780 | EObject this_ClassInterpretation_0 = null; | 8885 | Token otherlv_0=null; |
| 5781 | 8886 | Token lv_lowerBound_1_0=null; | |
| 5782 | EObject this_EnumInterpretation_1 = null; | 8887 | Token otherlv_2=null; |
| 5783 | 8888 | Token otherlv_4=null; | |
| 5784 | EObject this_GlobalRelationInterpretation_2 = null; | 8889 | Token lv_upperBound_5_0=null; |
| 5785 | 8890 | Token lv_upperBound_6_0=null; | |
| 8891 | Token otherlv_7=null; | ||
| 8892 | Token otherlv_9=null; | ||
| 8893 | Token lv_lowerBound_10_0=null; | ||
| 8894 | Token otherlv_11=null; | ||
| 5786 | 8895 | ||
| 5787 | 8896 | ||
| 5788 | enterRule(); | 8897 | enterRule(); |
| 5789 | 8898 | ||
| 5790 | try { | 8899 | try { |
| 5791 | // InternalSolverLanguage.g:1983:2: ( (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) ) | 8900 | // InternalSolverLanguage.g:3078:2: ( (otherlv_0= 'scope' ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) otherlv_11= '.' ) ) |
| 5792 | // InternalSolverLanguage.g:1984:2: (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) | 8901 | // InternalSolverLanguage.g:3079:2: (otherlv_0= 'scope' ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) otherlv_11= '.' ) |
| 5793 | { | 8902 | { |
| 5794 | // InternalSolverLanguage.g:1984:2: (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) | 8903 | // InternalSolverLanguage.g:3079:2: (otherlv_0= 'scope' ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) otherlv_11= '.' ) |
| 5795 | int alt36=3; | 8904 | // InternalSolverLanguage.g:3080:3: otherlv_0= 'scope' ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) otherlv_11= '.' |
| 5796 | switch ( input.LA(1) ) { | 8905 | { |
| 5797 | case 33: | 8906 | otherlv_0=(Token)match(input,46,FOLLOW_49); if (state.failed) return current; |
| 5798 | case 34: | 8907 | if ( state.backtracking==0 ) { |
| 5799 | { | 8908 | |
| 5800 | alt36=1; | 8909 | newLeafNode(otherlv_0, grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
| 8910 | |||
| 8911 | } | ||
| 8912 | // InternalSolverLanguage.g:3084:3: ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) | ||
| 8913 | int alt39=2; | ||
| 8914 | int LA39_0 = input.LA(1); | ||
| 8915 | |||
| 8916 | if ( (LA39_0==RULE_INT) ) { | ||
| 8917 | int LA39_1 = input.LA(2); | ||
| 8918 | |||
| 8919 | if ( (LA39_1==49) ) { | ||
| 8920 | alt39=2; | ||
| 5801 | } | 8921 | } |
| 5802 | break; | 8922 | else if ( (LA39_1==48) ) { |
| 5803 | case 38: | 8923 | alt39=1; |
| 5804 | { | ||
| 5805 | alt36=2; | ||
| 5806 | } | 8924 | } |
| 5807 | break; | 8925 | else { |
| 5808 | case 39: | 8926 | if (state.backtracking>0) {state.failed=true; return current;} |
| 5809 | case 40: | 8927 | NoViableAltException nvae = |
| 5810 | { | 8928 | new NoViableAltException("", 39, 1, input); |
| 5811 | alt36=3; | 8929 | |
| 8930 | throw nvae; | ||
| 5812 | } | 8931 | } |
| 5813 | break; | 8932 | } |
| 5814 | default: | 8933 | else if ( (LA39_0==RULE_ID||LA39_0==RULE_QUOTED_ID) ) { |
| 8934 | alt39=1; | ||
| 8935 | } | ||
| 8936 | else { | ||
| 8937 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 5815 | NoViableAltException nvae = | 8938 | NoViableAltException nvae = |
| 5816 | new NoViableAltException("", 36, 0, input); | 8939 | new NoViableAltException("", 39, 0, input); |
| 5817 | 8940 | ||
| 5818 | throw nvae; | 8941 | throw nvae; |
| 5819 | } | 8942 | } |
| 5820 | 8943 | switch (alt39) { | |
| 5821 | switch (alt36) { | ||
| 5822 | case 1 : | 8944 | case 1 : |
| 5823 | // InternalSolverLanguage.g:1985:3: this_ClassInterpretation_0= ruleClassInterpretation | 8945 | // InternalSolverLanguage.g:3085:4: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) |
| 8946 | { | ||
| 8947 | // InternalSolverLanguage.g:3085:4: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ||
| 8948 | // InternalSolverLanguage.g:3086:5: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) | ||
| 5824 | { | 8949 | { |
| 8950 | // InternalSolverLanguage.g:3086:5: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? | ||
| 8951 | int alt37=2; | ||
| 8952 | int LA37_0 = input.LA(1); | ||
| 5825 | 8953 | ||
| 5826 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); | 8954 | if ( (LA37_0==RULE_INT) ) { |
| 5827 | 8955 | alt37=1; | |
| 5828 | pushFollow(FOLLOW_2); | 8956 | } |
| 5829 | this_ClassInterpretation_0=ruleClassInterpretation(); | 8957 | switch (alt37) { |
| 8958 | case 1 : | ||
| 8959 | // InternalSolverLanguage.g:3087:6: ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' | ||
| 8960 | { | ||
| 8961 | // InternalSolverLanguage.g:3087:6: ( (lv_lowerBound_1_0= RULE_INT ) ) | ||
| 8962 | // InternalSolverLanguage.g:3088:7: (lv_lowerBound_1_0= RULE_INT ) | ||
| 8963 | { | ||
| 8964 | // InternalSolverLanguage.g:3088:7: (lv_lowerBound_1_0= RULE_INT ) | ||
| 8965 | // InternalSolverLanguage.g:3089:8: lv_lowerBound_1_0= RULE_INT | ||
| 8966 | { | ||
| 8967 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_50); if (state.failed) return current; | ||
| 8968 | if ( state.backtracking==0 ) { | ||
| 8969 | |||
| 8970 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); | ||
| 8971 | |||
| 8972 | } | ||
| 8973 | if ( state.backtracking==0 ) { | ||
| 8974 | |||
| 8975 | if (current==null) { | ||
| 8976 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 8977 | } | ||
| 8978 | setWithLastConsumed( | ||
| 8979 | current, | ||
| 8980 | "lowerBound", | ||
| 8981 | lv_lowerBound_1_0, | ||
| 8982 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 8983 | |||
| 8984 | } | ||
| 8985 | |||
| 8986 | } | ||
| 8987 | |||
| 8988 | |||
| 8989 | } | ||
| 8990 | |||
| 8991 | otherlv_2=(Token)match(input,48,FOLLOW_35); if (state.failed) return current; | ||
| 8992 | if ( state.backtracking==0 ) { | ||
| 8993 | |||
| 8994 | newLeafNode(otherlv_2, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); | ||
| 8995 | |||
| 8996 | } | ||
| 8997 | |||
| 8998 | } | ||
| 8999 | break; | ||
| 9000 | |||
| 9001 | } | ||
| 9002 | |||
| 9003 | // InternalSolverLanguage.g:3110:5: ( ( ruleQualifiedName ) ) | ||
| 9004 | // InternalSolverLanguage.g:3111:6: ( ruleQualifiedName ) | ||
| 9005 | { | ||
| 9006 | // InternalSolverLanguage.g:3111:6: ( ruleQualifiedName ) | ||
| 9007 | // InternalSolverLanguage.g:3112:7: ruleQualifiedName | ||
| 9008 | { | ||
| 9009 | if ( state.backtracking==0 ) { | ||
| 9010 | |||
| 9011 | if (current==null) { | ||
| 9012 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 9013 | } | ||
| 9014 | |||
| 9015 | } | ||
| 9016 | if ( state.backtracking==0 ) { | ||
| 9017 | |||
| 9018 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); | ||
| 9019 | |||
| 9020 | } | ||
| 9021 | pushFollow(FOLLOW_50); | ||
| 9022 | ruleQualifiedName(); | ||
| 5830 | 9023 | ||
| 5831 | state._fsp--; | 9024 | state._fsp--; |
| 9025 | if (state.failed) return current; | ||
| 9026 | if ( state.backtracking==0 ) { | ||
| 9027 | |||
| 9028 | afterParserOrEnumRuleCall(); | ||
| 9029 | |||
| 9030 | } | ||
| 9031 | |||
| 9032 | } | ||
| 9033 | |||
| 9034 | |||
| 9035 | } | ||
| 9036 | |||
| 9037 | otherlv_4=(Token)match(input,48,FOLLOW_47); if (state.failed) return current; | ||
| 9038 | if ( state.backtracking==0 ) { | ||
| 9039 | |||
| 9040 | newLeafNode(otherlv_4, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); | ||
| 9041 | |||
| 9042 | } | ||
| 9043 | // InternalSolverLanguage.g:3130:5: ( (lv_upperBound_5_0= RULE_INT ) ) | ||
| 9044 | // InternalSolverLanguage.g:3131:6: (lv_upperBound_5_0= RULE_INT ) | ||
| 9045 | { | ||
| 9046 | // InternalSolverLanguage.g:3131:6: (lv_upperBound_5_0= RULE_INT ) | ||
| 9047 | // InternalSolverLanguage.g:3132:7: lv_upperBound_5_0= RULE_INT | ||
| 9048 | { | ||
| 9049 | lv_upperBound_5_0=(Token)match(input,RULE_INT,FOLLOW_12); if (state.failed) return current; | ||
| 9050 | if ( state.backtracking==0 ) { | ||
| 5832 | 9051 | ||
| 9052 | newLeafNode(lv_upperBound_5_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); | ||
| 9053 | |||
| 9054 | } | ||
| 9055 | if ( state.backtracking==0 ) { | ||
| 9056 | |||
| 9057 | if (current==null) { | ||
| 9058 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 9059 | } | ||
| 9060 | setWithLastConsumed( | ||
| 9061 | current, | ||
| 9062 | "upperBound", | ||
| 9063 | lv_upperBound_5_0, | ||
| 9064 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 9065 | |||
| 9066 | } | ||
| 9067 | |||
| 9068 | } | ||
| 9069 | |||
| 9070 | |||
| 9071 | } | ||
| 9072 | |||
| 9073 | |||
| 9074 | } | ||
| 5833 | 9075 | ||
| 5834 | current = this_ClassInterpretation_0; | ||
| 5835 | afterParserOrEnumRuleCall(); | ||
| 5836 | |||
| 5837 | 9076 | ||
| 5838 | } | 9077 | } |
| 5839 | break; | 9078 | break; |
| 5840 | case 2 : | 9079 | case 2 : |
| 5841 | // InternalSolverLanguage.g:1994:3: this_EnumInterpretation_1= ruleEnumInterpretation | 9080 | // InternalSolverLanguage.g:3150:4: ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) |
| 9081 | { | ||
| 9082 | // InternalSolverLanguage.g:3150:4: ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) | ||
| 9083 | // InternalSolverLanguage.g:3151:5: ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? | ||
| 9084 | { | ||
| 9085 | // InternalSolverLanguage.g:3151:5: ( (lv_upperBound_6_0= RULE_INT ) ) | ||
| 9086 | // InternalSolverLanguage.g:3152:6: (lv_upperBound_6_0= RULE_INT ) | ||
| 5842 | { | 9087 | { |
| 9088 | // InternalSolverLanguage.g:3152:6: (lv_upperBound_6_0= RULE_INT ) | ||
| 9089 | // InternalSolverLanguage.g:3153:7: lv_upperBound_6_0= RULE_INT | ||
| 9090 | { | ||
| 9091 | lv_upperBound_6_0=(Token)match(input,RULE_INT,FOLLOW_51); if (state.failed) return current; | ||
| 9092 | if ( state.backtracking==0 ) { | ||
| 5843 | 9093 | ||
| 5844 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); | 9094 | newLeafNode(lv_upperBound_6_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); |
| 5845 | 9095 | ||
| 5846 | pushFollow(FOLLOW_2); | 9096 | } |
| 5847 | this_EnumInterpretation_1=ruleEnumInterpretation(); | 9097 | if ( state.backtracking==0 ) { |
| 9098 | |||
| 9099 | if (current==null) { | ||
| 9100 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 9101 | } | ||
| 9102 | setWithLastConsumed( | ||
| 9103 | current, | ||
| 9104 | "upperBound", | ||
| 9105 | lv_upperBound_6_0, | ||
| 9106 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 9107 | |||
| 9108 | } | ||
| 9109 | |||
| 9110 | } | ||
| 5848 | 9111 | ||
| 5849 | state._fsp--; | ||
| 5850 | 9112 | ||
| 9113 | } | ||
| 5851 | 9114 | ||
| 5852 | current = this_EnumInterpretation_1; | 9115 | otherlv_7=(Token)match(input,49,FOLLOW_35); if (state.failed) return current; |
| 5853 | afterParserOrEnumRuleCall(); | 9116 | if ( state.backtracking==0 ) { |
| 5854 | |||
| 5855 | 9117 | ||
| 9118 | newLeafNode(otherlv_7, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
| 9119 | |||
| 5856 | } | 9120 | } |
| 5857 | break; | 9121 | // InternalSolverLanguage.g:3173:5: ( ( ruleQualifiedName ) ) |
| 5858 | case 3 : | 9122 | // InternalSolverLanguage.g:3174:6: ( ruleQualifiedName ) |
| 5859 | // InternalSolverLanguage.g:2003:3: this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation | 9123 | { |
| 9124 | // InternalSolverLanguage.g:3174:6: ( ruleQualifiedName ) | ||
| 9125 | // InternalSolverLanguage.g:3175:7: ruleQualifiedName | ||
| 5860 | { | 9126 | { |
| 9127 | if ( state.backtracking==0 ) { | ||
| 5861 | 9128 | ||
| 5862 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); | 9129 | if (current==null) { |
| 5863 | 9130 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | |
| 5864 | pushFollow(FOLLOW_2); | 9131 | } |
| 5865 | this_GlobalRelationInterpretation_2=ruleGlobalRelationInterpretation(); | 9132 | |
| 9133 | } | ||
| 9134 | if ( state.backtracking==0 ) { | ||
| 9135 | |||
| 9136 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); | ||
| 9137 | |||
| 9138 | } | ||
| 9139 | pushFollow(FOLLOW_52); | ||
| 9140 | ruleQualifiedName(); | ||
| 5866 | 9141 | ||
| 5867 | state._fsp--; | 9142 | state._fsp--; |
| 9143 | if (state.failed) return current; | ||
| 9144 | if ( state.backtracking==0 ) { | ||
| 9145 | |||
| 9146 | afterParserOrEnumRuleCall(); | ||
| 9147 | |||
| 9148 | } | ||
| 9149 | |||
| 9150 | } | ||
| 9151 | |||
| 9152 | |||
| 9153 | } | ||
| 9154 | |||
| 9155 | // InternalSolverLanguage.g:3189:5: (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? | ||
| 9156 | int alt38=2; | ||
| 9157 | int LA38_0 = input.LA(1); | ||
| 9158 | |||
| 9159 | if ( (LA38_0==49) ) { | ||
| 9160 | alt38=1; | ||
| 9161 | } | ||
| 9162 | switch (alt38) { | ||
| 9163 | case 1 : | ||
| 9164 | // InternalSolverLanguage.g:3190:6: otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) | ||
| 9165 | { | ||
| 9166 | otherlv_9=(Token)match(input,49,FOLLOW_47); if (state.failed) return current; | ||
| 9167 | if ( state.backtracking==0 ) { | ||
| 9168 | |||
| 9169 | newLeafNode(otherlv_9, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); | ||
| 9170 | |||
| 9171 | } | ||
| 9172 | // InternalSolverLanguage.g:3194:6: ( (lv_lowerBound_10_0= RULE_INT ) ) | ||
| 9173 | // InternalSolverLanguage.g:3195:7: (lv_lowerBound_10_0= RULE_INT ) | ||
| 9174 | { | ||
| 9175 | // InternalSolverLanguage.g:3195:7: (lv_lowerBound_10_0= RULE_INT ) | ||
| 9176 | // InternalSolverLanguage.g:3196:8: lv_lowerBound_10_0= RULE_INT | ||
| 9177 | { | ||
| 9178 | lv_lowerBound_10_0=(Token)match(input,RULE_INT,FOLLOW_12); if (state.failed) return current; | ||
| 9179 | if ( state.backtracking==0 ) { | ||
| 9180 | |||
| 9181 | newLeafNode(lv_lowerBound_10_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); | ||
| 9182 | |||
| 9183 | } | ||
| 9184 | if ( state.backtracking==0 ) { | ||
| 9185 | |||
| 9186 | if (current==null) { | ||
| 9187 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 9188 | } | ||
| 9189 | setWithLastConsumed( | ||
| 9190 | current, | ||
| 9191 | "lowerBound", | ||
| 9192 | lv_lowerBound_10_0, | ||
| 9193 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 9194 | |||
| 9195 | } | ||
| 9196 | |||
| 9197 | } | ||
| 9198 | |||
| 9199 | |||
| 9200 | } | ||
| 9201 | |||
| 5868 | 9202 | ||
| 9203 | } | ||
| 9204 | break; | ||
| 9205 | |||
| 9206 | } | ||
| 9207 | |||
| 9208 | |||
| 9209 | } | ||
| 5869 | 9210 | ||
| 5870 | current = this_GlobalRelationInterpretation_2; | ||
| 5871 | afterParserOrEnumRuleCall(); | ||
| 5872 | |||
| 5873 | 9211 | ||
| 5874 | } | 9212 | } |
| 5875 | break; | 9213 | break; |
| 5876 | 9214 | ||
| 5877 | } | 9215 | } |
| 5878 | 9216 | ||
| 9217 | otherlv_11=(Token)match(input,22,FOLLOW_2); if (state.failed) return current; | ||
| 9218 | if ( state.backtracking==0 ) { | ||
| 5879 | 9219 | ||
| 9220 | newLeafNode(otherlv_11, grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
| 9221 | |||
| 5880 | } | 9222 | } |
| 5881 | 9223 | ||
| 9224 | } | ||
| 9225 | |||
| 9226 | |||
| 9227 | } | ||
| 5882 | 9228 | ||
| 5883 | leaveRule(); | 9229 | if ( state.backtracking==0 ) { |
| 5884 | 9230 | ||
| 9231 | leaveRule(); | ||
| 9232 | |||
| 9233 | } | ||
| 5885 | } | 9234 | } |
| 5886 | 9235 | ||
| 5887 | catch (RecognitionException re) { | 9236 | catch (RecognitionException re) { |
| @@ -5892,29 +9241,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5892 | } | 9241 | } |
| 5893 | return current; | 9242 | return current; |
| 5894 | } | 9243 | } |
| 5895 | // $ANTLR end "ruleCDInterpretation" | 9244 | // $ANTLR end "ruleBoundedScopeDefinition" |
| 5896 | 9245 | ||
| 5897 | 9246 | ||
| 5898 | // $ANTLR start "entryRuleClassInterpretation" | 9247 | // $ANTLR start "entryRuleLowerBoundedScopeDefinition" |
| 5899 | // InternalSolverLanguage.g:2015:1: entryRuleClassInterpretation returns [EObject current=null] : iv_ruleClassInterpretation= ruleClassInterpretation EOF ; | 9248 | // InternalSolverLanguage.g:3223:1: entryRuleLowerBoundedScopeDefinition returns [EObject current=null] : iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF ; |
| 5900 | public final EObject entryRuleClassInterpretation() throws RecognitionException { | 9249 | public final EObject entryRuleLowerBoundedScopeDefinition() throws RecognitionException { |
| 5901 | EObject current = null; | 9250 | EObject current = null; |
| 5902 | 9251 | ||
| 5903 | EObject iv_ruleClassInterpretation = null; | 9252 | EObject iv_ruleLowerBoundedScopeDefinition = null; |
| 5904 | 9253 | ||
| 5905 | 9254 | ||
| 5906 | try { | 9255 | try { |
| 5907 | // InternalSolverLanguage.g:2015:60: (iv_ruleClassInterpretation= ruleClassInterpretation EOF ) | 9256 | // InternalSolverLanguage.g:3223:68: (iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF ) |
| 5908 | // InternalSolverLanguage.g:2016:2: iv_ruleClassInterpretation= ruleClassInterpretation EOF | 9257 | // InternalSolverLanguage.g:3224:2: iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF |
| 5909 | { | 9258 | { |
| 5910 | newCompositeNode(grammarAccess.getClassInterpretationRule()); | 9259 | if ( state.backtracking==0 ) { |
| 9260 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
| 9261 | } | ||
| 5911 | pushFollow(FOLLOW_1); | 9262 | pushFollow(FOLLOW_1); |
| 5912 | iv_ruleClassInterpretation=ruleClassInterpretation(); | 9263 | iv_ruleLowerBoundedScopeDefinition=ruleLowerBoundedScopeDefinition(); |
| 5913 | 9264 | ||
| 5914 | state._fsp--; | 9265 | state._fsp--; |
| 5915 | 9266 | if (state.failed) return current; | |
| 5916 | current =iv_ruleClassInterpretation; | 9267 | if ( state.backtracking==0 ) { |
| 5917 | match(input,EOF,FOLLOW_2); | 9268 | current =iv_ruleLowerBoundedScopeDefinition; |
| 9269 | } | ||
| 9270 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 5918 | 9271 | ||
| 5919 | } | 9272 | } |
| 5920 | 9273 | ||
| @@ -5928,245 +9281,239 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5928 | } | 9281 | } |
| 5929 | return current; | 9282 | return current; |
| 5930 | } | 9283 | } |
| 5931 | // $ANTLR end "entryRuleClassInterpretation" | 9284 | // $ANTLR end "entryRuleLowerBoundedScopeDefinition" |
| 5932 | 9285 | ||
| 5933 | 9286 | ||
| 5934 | // $ANTLR start "ruleClassInterpretation" | 9287 | // $ANTLR start "ruleLowerBoundedScopeDefinition" |
| 5935 | // InternalSolverLanguage.g:2022: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= '}' ) ; | 9288 | // InternalSolverLanguage.g:3230:1: ruleLowerBoundedScopeDefinition returns [EObject current=null] : (otherlv_0= 'scope' ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) otherlv_7= '.' ) ; |
| 5936 | public final EObject ruleClassInterpretation() throws RecognitionException { | 9289 | public final EObject ruleLowerBoundedScopeDefinition() throws RecognitionException { |
| 5937 | EObject current = null; | 9290 | EObject current = null; |
| 5938 | 9291 | ||
| 5939 | Token lv_abstract_0_0=null; | 9292 | Token otherlv_0=null; |
| 5940 | Token otherlv_1=null; | 9293 | Token lv_lowerBound_1_0=null; |
| 5941 | Token otherlv_3=null; | 9294 | Token otherlv_2=null; |
| 5942 | Token otherlv_5=null; | 9295 | Token otherlv_5=null; |
| 9296 | Token lv_lowerBound_6_0=null; | ||
| 5943 | Token otherlv_7=null; | 9297 | Token otherlv_7=null; |
| 5944 | EObject lv_symbol_2_0 = null; | ||
| 5945 | |||
| 5946 | EObject lv_supertypes_4_0 = null; | ||
| 5947 | |||
| 5948 | EObject lv_fielt_6_0 = null; | ||
| 5949 | |||
| 5950 | 9298 | ||
| 5951 | 9299 | ||
| 5952 | enterRule(); | 9300 | enterRule(); |
| 5953 | 9301 | ||
| 5954 | try { | 9302 | try { |
| 5955 | // InternalSolverLanguage.g:2028: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= '}' ) ) | 9303 | // InternalSolverLanguage.g:3236:2: ( (otherlv_0= 'scope' ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) otherlv_7= '.' ) ) |
| 5956 | // InternalSolverLanguage.g:2029: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= '}' ) | 9304 | // InternalSolverLanguage.g:3237:2: (otherlv_0= 'scope' ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) otherlv_7= '.' ) |
| 5957 | { | 9305 | { |
| 5958 | // InternalSolverLanguage.g:2029: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= '}' ) | 9306 | // InternalSolverLanguage.g:3237:2: (otherlv_0= 'scope' ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) otherlv_7= '.' ) |
| 5959 | // InternalSolverLanguage.g:2030: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= '}' | 9307 | // InternalSolverLanguage.g:3238:3: otherlv_0= 'scope' ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) otherlv_7= '.' |
| 5960 | { | 9308 | { |
| 5961 | // InternalSolverLanguage.g:2030:3: ( (lv_abstract_0_0= 'abstract' ) )? | 9309 | otherlv_0=(Token)match(input,46,FOLLOW_49); if (state.failed) return current; |
| 5962 | int alt37=2; | 9310 | if ( state.backtracking==0 ) { |
| 5963 | int LA37_0 = input.LA(1); | 9311 | |
| 9312 | newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); | ||
| 9313 | |||
| 9314 | } | ||
| 9315 | // InternalSolverLanguage.g:3242:3: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) | ||
| 9316 | int alt40=2; | ||
| 9317 | int LA40_0 = input.LA(1); | ||
| 5964 | 9318 | ||
| 5965 | if ( (LA37_0==33) ) { | 9319 | if ( (LA40_0==RULE_INT) ) { |
| 5966 | alt37=1; | 9320 | alt40=1; |
| 5967 | } | 9321 | } |
| 5968 | switch (alt37) { | 9322 | else if ( (LA40_0==RULE_ID||LA40_0==RULE_QUOTED_ID) ) { |
| 9323 | alt40=2; | ||
| 9324 | } | ||
| 9325 | else { | ||
| 9326 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 9327 | NoViableAltException nvae = | ||
| 9328 | new NoViableAltException("", 40, 0, input); | ||
| 9329 | |||
| 9330 | throw nvae; | ||
| 9331 | } | ||
| 9332 | switch (alt40) { | ||
| 5969 | case 1 : | 9333 | case 1 : |
| 5970 | // InternalSolverLanguage.g:2031:4: (lv_abstract_0_0= 'abstract' ) | 9334 | // InternalSolverLanguage.g:3243:4: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) |
| 5971 | { | 9335 | { |
| 5972 | // InternalSolverLanguage.g:2031:4: (lv_abstract_0_0= 'abstract' ) | 9336 | // InternalSolverLanguage.g:3243:4: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) |
| 5973 | // InternalSolverLanguage.g:2032:5: lv_abstract_0_0= 'abstract' | 9337 | // InternalSolverLanguage.g:3244:5: ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) |
| 5974 | { | 9338 | { |
| 5975 | lv_abstract_0_0=(Token)match(input,33,FOLLOW_27); | 9339 | // InternalSolverLanguage.g:3244:5: ( (lv_lowerBound_1_0= RULE_INT ) ) |
| 5976 | 9340 | // InternalSolverLanguage.g:3245:6: (lv_lowerBound_1_0= RULE_INT ) | |
| 5977 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); | 9341 | { |
| 5978 | 9342 | // InternalSolverLanguage.g:3245:6: (lv_lowerBound_1_0= RULE_INT ) | |
| 5979 | 9343 | // InternalSolverLanguage.g:3246:7: lv_lowerBound_1_0= RULE_INT | |
| 5980 | if (current==null) { | 9344 | { |
| 5981 | current = createModelElement(grammarAccess.getClassInterpretationRule()); | 9345 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_50); if (state.failed) return current; |
| 5982 | } | 9346 | if ( state.backtracking==0 ) { |
| 5983 | setWithLastConsumed(current, "abstract", true, "abstract"); | ||
| 5984 | |||
| 5985 | 9347 | ||
| 9348 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); | ||
| 9349 | |||
| 5986 | } | 9350 | } |
| 5987 | 9351 | if ( state.backtracking==0 ) { | |
| 5988 | 9352 | ||
| 9353 | if (current==null) { | ||
| 9354 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
| 9355 | } | ||
| 9356 | setWithLastConsumed( | ||
| 9357 | current, | ||
| 9358 | "lowerBound", | ||
| 9359 | lv_lowerBound_1_0, | ||
| 9360 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 9361 | |||
| 5989 | } | 9362 | } |
| 5990 | break; | ||
| 5991 | |||
| 5992 | } | ||
| 5993 | |||
| 5994 | otherlv_1=(Token)match(input,34,FOLLOW_12); | ||
| 5995 | |||
| 5996 | newLeafNode(otherlv_1, grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); | ||
| 5997 | |||
| 5998 | // InternalSolverLanguage.g:2048:3: ( (lv_symbol_2_0= ruleModelSymbol ) ) | ||
| 5999 | // InternalSolverLanguage.g:2049:4: (lv_symbol_2_0= ruleModelSymbol ) | ||
| 6000 | { | ||
| 6001 | // InternalSolverLanguage.g:2049:4: (lv_symbol_2_0= ruleModelSymbol ) | ||
| 6002 | // InternalSolverLanguage.g:2050:5: lv_symbol_2_0= ruleModelSymbol | ||
| 6003 | { | ||
| 6004 | 9363 | ||
| 6005 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); | 9364 | } |
| 6006 | |||
| 6007 | pushFollow(FOLLOW_28); | ||
| 6008 | lv_symbol_2_0=ruleModelSymbol(); | ||
| 6009 | |||
| 6010 | state._fsp--; | ||
| 6011 | |||
| 6012 | |||
| 6013 | if (current==null) { | ||
| 6014 | current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 6015 | } | ||
| 6016 | set( | ||
| 6017 | current, | ||
| 6018 | "symbol", | ||
| 6019 | lv_symbol_2_0, | ||
| 6020 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 6021 | afterParserOrEnumRuleCall(); | ||
| 6022 | |||
| 6023 | |||
| 6024 | } | ||
| 6025 | 9365 | ||
| 6026 | 9366 | ||
| 6027 | } | 9367 | } |
| 6028 | 9368 | ||
| 6029 | // InternalSolverLanguage.g:2067:3: (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? | 9369 | otherlv_2=(Token)match(input,48,FOLLOW_35); if (state.failed) return current; |
| 6030 | int alt39=2; | 9370 | if ( state.backtracking==0 ) { |
| 6031 | int LA39_0 = input.LA(1); | ||
| 6032 | 9371 | ||
| 6033 | if ( (LA39_0==35) ) { | 9372 | newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); |
| 6034 | alt39=1; | 9373 | |
| 6035 | } | 9374 | } |
| 6036 | switch (alt39) { | 9375 | // InternalSolverLanguage.g:3266:5: ( ( ruleQualifiedName ) ) |
| 6037 | case 1 : | 9376 | // InternalSolverLanguage.g:3267:6: ( ruleQualifiedName ) |
| 6038 | // InternalSolverLanguage.g:2068:4: otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ | ||
| 6039 | { | 9377 | { |
| 6040 | otherlv_3=(Token)match(input,35,FOLLOW_12); | 9378 | // InternalSolverLanguage.g:3267:6: ( ruleQualifiedName ) |
| 9379 | // InternalSolverLanguage.g:3268:7: ruleQualifiedName | ||
| 9380 | { | ||
| 9381 | if ( state.backtracking==0 ) { | ||
| 6041 | 9382 | ||
| 6042 | newLeafNode(otherlv_3, grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); | 9383 | if (current==null) { |
| 6043 | 9384 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | |
| 6044 | // InternalSolverLanguage.g:2072:4: ( (lv_supertypes_4_0= ruleModelSymbol ) )+ | 9385 | } |
| 6045 | int cnt38=0; | 9386 | |
| 6046 | loop38: | 9387 | } |
| 6047 | do { | 9388 | if ( state.backtracking==0 ) { |
| 6048 | int alt38=2; | ||
| 6049 | int LA38_0 = input.LA(1); | ||
| 6050 | 9389 | ||
| 6051 | if ( (LA38_0==RULE_ID) ) { | 9390 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); |
| 6052 | alt38=1; | 9391 | |
| 6053 | } | 9392 | } |
| 9393 | pushFollow(FOLLOW_12); | ||
| 9394 | ruleQualifiedName(); | ||
| 6054 | 9395 | ||
| 9396 | state._fsp--; | ||
| 9397 | if (state.failed) return current; | ||
| 9398 | if ( state.backtracking==0 ) { | ||
| 6055 | 9399 | ||
| 6056 | switch (alt38) { | 9400 | afterParserOrEnumRuleCall(); |
| 6057 | case 1 : | 9401 | |
| 6058 | // InternalSolverLanguage.g:2073:5: (lv_supertypes_4_0= ruleModelSymbol ) | 9402 | } |
| 6059 | { | ||
| 6060 | // InternalSolverLanguage.g:2073:5: (lv_supertypes_4_0= ruleModelSymbol ) | ||
| 6061 | // InternalSolverLanguage.g:2074:6: lv_supertypes_4_0= ruleModelSymbol | ||
| 6062 | { | ||
| 6063 | 9403 | ||
| 6064 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); | 9404 | } |
| 6065 | |||
| 6066 | pushFollow(FOLLOW_29); | ||
| 6067 | lv_supertypes_4_0=ruleModelSymbol(); | ||
| 6068 | 9405 | ||
| 6069 | state._fsp--; | ||
| 6070 | 9406 | ||
| 9407 | } | ||
| 6071 | 9408 | ||
| 6072 | if (current==null) { | ||
| 6073 | current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 6074 | } | ||
| 6075 | add( | ||
| 6076 | current, | ||
| 6077 | "supertypes", | ||
| 6078 | lv_supertypes_4_0, | ||
| 6079 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 6080 | afterParserOrEnumRuleCall(); | ||
| 6081 | |||
| 6082 | 9409 | ||
| 6083 | } | 9410 | } |
| 6084 | 9411 | ||
| 6085 | 9412 | ||
| 6086 | } | 9413 | } |
| 6087 | break; | 9414 | break; |
| 9415 | case 2 : | ||
| 9416 | // InternalSolverLanguage.g:3284:4: ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) | ||
| 9417 | { | ||
| 9418 | // InternalSolverLanguage.g:3284:4: ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) | ||
| 9419 | // InternalSolverLanguage.g:3285:5: ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) | ||
| 9420 | { | ||
| 9421 | // InternalSolverLanguage.g:3285:5: ( ( ruleQualifiedName ) ) | ||
| 9422 | // InternalSolverLanguage.g:3286:6: ( ruleQualifiedName ) | ||
| 9423 | { | ||
| 9424 | // InternalSolverLanguage.g:3286:6: ( ruleQualifiedName ) | ||
| 9425 | // InternalSolverLanguage.g:3287:7: ruleQualifiedName | ||
| 9426 | { | ||
| 9427 | if ( state.backtracking==0 ) { | ||
| 6088 | 9428 | ||
| 6089 | default : | 9429 | if (current==null) { |
| 6090 | if ( cnt38 >= 1 ) break loop38; | 9430 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
| 6091 | EarlyExitException eee = | 9431 | } |
| 6092 | new EarlyExitException(38, input); | 9432 | |
| 6093 | throw eee; | 9433 | } |
| 6094 | } | 9434 | if ( state.backtracking==0 ) { |
| 6095 | cnt38++; | ||
| 6096 | } while (true); | ||
| 6097 | 9435 | ||
| 9436 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); | ||
| 9437 | |||
| 9438 | } | ||
| 9439 | pushFollow(FOLLOW_51); | ||
| 9440 | ruleQualifiedName(); | ||
| 6098 | 9441 | ||
| 9442 | state._fsp--; | ||
| 9443 | if (state.failed) return current; | ||
| 9444 | if ( state.backtracking==0 ) { | ||
| 9445 | |||
| 9446 | afterParserOrEnumRuleCall(); | ||
| 9447 | |||
| 6099 | } | 9448 | } |
| 6100 | break; | ||
| 6101 | 9449 | ||
| 6102 | } | 9450 | } |
| 6103 | 9451 | ||
| 6104 | otherlv_5=(Token)match(input,36,FOLLOW_30); | ||
| 6105 | 9452 | ||
| 6106 | newLeafNode(otherlv_5, grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); | 9453 | } |
| 6107 | |||
| 6108 | // InternalSolverLanguage.g:2096:3: ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* | ||
| 6109 | loop40: | ||
| 6110 | do { | ||
| 6111 | int alt40=2; | ||
| 6112 | int LA40_0 = input.LA(1); | ||
| 6113 | 9454 | ||
| 6114 | if ( (LA40_0==RULE_ID||LA40_0==39) ) { | 9455 | otherlv_5=(Token)match(input,49,FOLLOW_47); if (state.failed) return current; |
| 6115 | alt40=1; | 9456 | if ( state.backtracking==0 ) { |
| 6116 | } | ||
| 6117 | 9457 | ||
| 9458 | newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
| 9459 | |||
| 9460 | } | ||
| 9461 | // InternalSolverLanguage.g:3305:5: ( (lv_lowerBound_6_0= RULE_INT ) ) | ||
| 9462 | // InternalSolverLanguage.g:3306:6: (lv_lowerBound_6_0= RULE_INT ) | ||
| 9463 | { | ||
| 9464 | // InternalSolverLanguage.g:3306:6: (lv_lowerBound_6_0= RULE_INT ) | ||
| 9465 | // InternalSolverLanguage.g:3307:7: lv_lowerBound_6_0= RULE_INT | ||
| 9466 | { | ||
| 9467 | lv_lowerBound_6_0=(Token)match(input,RULE_INT,FOLLOW_12); if (state.failed) return current; | ||
| 9468 | if ( state.backtracking==0 ) { | ||
| 6118 | 9469 | ||
| 6119 | switch (alt40) { | 9470 | newLeafNode(lv_lowerBound_6_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); |
| 6120 | case 1 : | 9471 | |
| 6121 | // InternalSolverLanguage.g:2097:4: (lv_fielt_6_0= ruleFieldRelationInterpretation ) | 9472 | } |
| 6122 | { | 9473 | if ( state.backtracking==0 ) { |
| 6123 | // InternalSolverLanguage.g:2097:4: (lv_fielt_6_0= ruleFieldRelationInterpretation ) | 9474 | |
| 6124 | // InternalSolverLanguage.g:2098:5: lv_fielt_6_0= ruleFieldRelationInterpretation | 9475 | if (current==null) { |
| 6125 | { | 9476 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
| 9477 | } | ||
| 9478 | setWithLastConsumed( | ||
| 9479 | current, | ||
| 9480 | "lowerBound", | ||
| 9481 | lv_lowerBound_6_0, | ||
| 9482 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 9483 | |||
| 9484 | } | ||
| 6126 | 9485 | ||
| 6127 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); | 9486 | } |
| 6128 | |||
| 6129 | pushFollow(FOLLOW_30); | ||
| 6130 | lv_fielt_6_0=ruleFieldRelationInterpretation(); | ||
| 6131 | 9487 | ||
| 6132 | state._fsp--; | ||
| 6133 | 9488 | ||
| 9489 | } | ||
| 6134 | 9490 | ||
| 6135 | if (current==null) { | ||
| 6136 | current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 6137 | } | ||
| 6138 | add( | ||
| 6139 | current, | ||
| 6140 | "fielt", | ||
| 6141 | lv_fielt_6_0, | ||
| 6142 | "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation"); | ||
| 6143 | afterParserOrEnumRuleCall(); | ||
| 6144 | |||
| 6145 | 9491 | ||
| 6146 | } | 9492 | } |
| 6147 | 9493 | ||
| 6148 | 9494 | ||
| 6149 | } | 9495 | } |
| 6150 | break; | 9496 | break; |
| 6151 | 9497 | ||
| 6152 | default : | 9498 | } |
| 6153 | break loop40; | ||
| 6154 | } | ||
| 6155 | } while (true); | ||
| 6156 | 9499 | ||
| 6157 | otherlv_7=(Token)match(input,37,FOLLOW_2); | 9500 | otherlv_7=(Token)match(input,22,FOLLOW_2); if (state.failed) return current; |
| 9501 | if ( state.backtracking==0 ) { | ||
| 6158 | 9502 | ||
| 6159 | newLeafNode(otherlv_7, grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); | 9503 | newLeafNode(otherlv_7, grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2()); |
| 6160 | 9504 | ||
| 9505 | } | ||
| 6161 | 9506 | ||
| 6162 | } | 9507 | } |
| 6163 | 9508 | ||
| 6164 | 9509 | ||
| 6165 | } | 9510 | } |
| 6166 | 9511 | ||
| 9512 | if ( state.backtracking==0 ) { | ||
| 6167 | 9513 | ||
| 6168 | leaveRule(); | 9514 | leaveRule(); |
| 6169 | 9515 | ||
| 9516 | } | ||
| 6170 | } | 9517 | } |
| 6171 | 9518 | ||
| 6172 | catch (RecognitionException re) { | 9519 | catch (RecognitionException re) { |
| @@ -6177,29 +9524,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6177 | } | 9524 | } |
| 6178 | return current; | 9525 | return current; |
| 6179 | } | 9526 | } |
| 6180 | // $ANTLR end "ruleClassInterpretation" | 9527 | // $ANTLR end "ruleLowerBoundedScopeDefinition" |
| 6181 | 9528 | ||
| 6182 | 9529 | ||
| 6183 | // $ANTLR start "entryRuleEnumInterpretation" | 9530 | // $ANTLR start "entryRuleObjectiveDefinition" |
| 6184 | // InternalSolverLanguage.g:2123:1: entryRuleEnumInterpretation returns [EObject current=null] : iv_ruleEnumInterpretation= ruleEnumInterpretation EOF ; | 9531 | // InternalSolverLanguage.g:3333:1: entryRuleObjectiveDefinition returns [EObject current=null] : iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF ; |
| 6185 | public final EObject entryRuleEnumInterpretation() throws RecognitionException { | 9532 | public final EObject entryRuleObjectiveDefinition() throws RecognitionException { |
| 6186 | EObject current = null; | 9533 | EObject current = null; |
| 6187 | 9534 | ||
| 6188 | EObject iv_ruleEnumInterpretation = null; | 9535 | EObject iv_ruleObjectiveDefinition = null; |
| 6189 | 9536 | ||
| 6190 | 9537 | ||
| 6191 | try { | 9538 | try { |
| 6192 | // InternalSolverLanguage.g:2123:59: (iv_ruleEnumInterpretation= ruleEnumInterpretation EOF ) | 9539 | // InternalSolverLanguage.g:3333:60: (iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF ) |
| 6193 | // InternalSolverLanguage.g:2124:2: iv_ruleEnumInterpretation= ruleEnumInterpretation EOF | 9540 | // InternalSolverLanguage.g:3334:2: iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF |
| 6194 | { | 9541 | { |
| 6195 | newCompositeNode(grammarAccess.getEnumInterpretationRule()); | 9542 | if ( state.backtracking==0 ) { |
| 9543 | newCompositeNode(grammarAccess.getObjectiveDefinitionRule()); | ||
| 9544 | } | ||
| 6196 | pushFollow(FOLLOW_1); | 9545 | pushFollow(FOLLOW_1); |
| 6197 | iv_ruleEnumInterpretation=ruleEnumInterpretation(); | 9546 | iv_ruleObjectiveDefinition=ruleObjectiveDefinition(); |
| 6198 | 9547 | ||
| 6199 | state._fsp--; | 9548 | state._fsp--; |
| 6200 | 9549 | if (state.failed) return current; | |
| 6201 | current =iv_ruleEnumInterpretation; | 9550 | if ( state.backtracking==0 ) { |
| 6202 | match(input,EOF,FOLLOW_2); | 9551 | current =iv_ruleObjectiveDefinition; |
| 9552 | } | ||
| 9553 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 6203 | 9554 | ||
| 6204 | } | 9555 | } |
| 6205 | 9556 | ||
| @@ -6213,138 +9564,110 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6213 | } | 9564 | } |
| 6214 | return current; | 9565 | return current; |
| 6215 | } | 9566 | } |
| 6216 | // $ANTLR end "entryRuleEnumInterpretation" | 9567 | // $ANTLR end "entryRuleObjectiveDefinition" |
| 6217 | 9568 | ||
| 6218 | 9569 | ||
| 6219 | // $ANTLR start "ruleEnumInterpretation" | 9570 | // $ANTLR start "ruleObjectiveDefinition" |
| 6220 | // InternalSolverLanguage.g:2130:1: ruleEnumInterpretation returns [EObject current=null] : (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) ; | 9571 | // InternalSolverLanguage.g:3340:1: ruleObjectiveDefinition returns [EObject current=null] : ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) ; |
| 6221 | public final EObject ruleEnumInterpretation() throws RecognitionException { | 9572 | public final EObject ruleObjectiveDefinition() throws RecognitionException { |
| 6222 | EObject current = null; | 9573 | EObject current = null; |
| 6223 | 9574 | ||
| 6224 | Token otherlv_0=null; | 9575 | Enumerator lv_kind_0_0 = null; |
| 6225 | Token otherlv_2=null; | ||
| 6226 | Token otherlv_4=null; | ||
| 6227 | EObject lv_Symbol_1_0 = null; | ||
| 6228 | 9576 | ||
| 6229 | EObject lv_objects_3_0 = null; | 9577 | EObject lv_objective_1_0 = null; |
| 6230 | 9578 | ||
| 6231 | 9579 | ||
| 6232 | 9580 | ||
| 6233 | enterRule(); | 9581 | enterRule(); |
| 6234 | 9582 | ||
| 6235 | try { | 9583 | try { |
| 6236 | // InternalSolverLanguage.g:2136:2: ( (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) ) | 9584 | // InternalSolverLanguage.g:3346:2: ( ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) ) |
| 6237 | // InternalSolverLanguage.g:2137:2: (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) | 9585 | // InternalSolverLanguage.g:3347:2: ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) |
| 6238 | { | 9586 | { |
| 6239 | // InternalSolverLanguage.g:2137:2: (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) | 9587 | // InternalSolverLanguage.g:3347:2: ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) |
| 6240 | // InternalSolverLanguage.g:2138:3: otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' | 9588 | // InternalSolverLanguage.g:3348:3: ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) |
| 6241 | { | 9589 | { |
| 6242 | otherlv_0=(Token)match(input,38,FOLLOW_12); | 9590 | // InternalSolverLanguage.g:3348:3: ( (lv_kind_0_0= ruleObjectiveKind ) ) |
| 6243 | 9591 | // InternalSolverLanguage.g:3349:4: (lv_kind_0_0= ruleObjectiveKind ) | |
| 6244 | newLeafNode(otherlv_0, grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); | ||
| 6245 | |||
| 6246 | // InternalSolverLanguage.g:2142:3: ( (lv_Symbol_1_0= ruleModelSymbol ) ) | ||
| 6247 | // InternalSolverLanguage.g:2143:4: (lv_Symbol_1_0= ruleModelSymbol ) | ||
| 6248 | { | 9592 | { |
| 6249 | // InternalSolverLanguage.g:2143:4: (lv_Symbol_1_0= ruleModelSymbol ) | 9593 | // InternalSolverLanguage.g:3349:4: (lv_kind_0_0= ruleObjectiveKind ) |
| 6250 | // InternalSolverLanguage.g:2144:5: lv_Symbol_1_0= ruleModelSymbol | 9594 | // InternalSolverLanguage.g:3350:5: lv_kind_0_0= ruleObjectiveKind |
| 6251 | { | 9595 | { |
| 9596 | if ( state.backtracking==0 ) { | ||
| 6252 | 9597 | ||
| 6253 | newCompositeNode(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); | 9598 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); |
| 6254 | 9599 | ||
| 6255 | pushFollow(FOLLOW_31); | 9600 | } |
| 6256 | lv_Symbol_1_0=ruleModelSymbol(); | 9601 | pushFollow(FOLLOW_6); |
| 9602 | lv_kind_0_0=ruleObjectiveKind(); | ||
| 6257 | 9603 | ||
| 6258 | state._fsp--; | 9604 | state._fsp--; |
| 9605 | if (state.failed) return current; | ||
| 9606 | if ( state.backtracking==0 ) { | ||
| 6259 | 9607 | ||
| 6260 | 9608 | if (current==null) { | |
| 6261 | if (current==null) { | 9609 | current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); |
| 6262 | current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); | 9610 | } |
| 6263 | } | 9611 | set( |
| 6264 | set( | 9612 | current, |
| 6265 | current, | 9613 | "kind", |
| 6266 | "Symbol", | 9614 | lv_kind_0_0, |
| 6267 | lv_Symbol_1_0, | 9615 | "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind"); |
| 6268 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | 9616 | afterParserOrEnumRuleCall(); |
| 6269 | afterParserOrEnumRuleCall(); | 9617 | |
| 6270 | |||
| 6271 | |||
| 6272 | } | 9618 | } |
| 6273 | 9619 | ||
| 6274 | |||
| 6275 | } | 9620 | } |
| 6276 | 9621 | ||
| 6277 | otherlv_2=(Token)match(input,36,FOLLOW_13); | ||
| 6278 | |||
| 6279 | newLeafNode(otherlv_2, grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); | ||
| 6280 | |||
| 6281 | // InternalSolverLanguage.g:2165:3: ( (lv_objects_3_0= ruleNamedObject ) )+ | ||
| 6282 | int cnt41=0; | ||
| 6283 | loop41: | ||
| 6284 | do { | ||
| 6285 | int alt41=2; | ||
| 6286 | int LA41_0 = input.LA(1); | ||
| 6287 | |||
| 6288 | if ( (LA41_0==27) ) { | ||
| 6289 | alt41=1; | ||
| 6290 | } | ||
| 6291 | |||
| 6292 | |||
| 6293 | switch (alt41) { | ||
| 6294 | case 1 : | ||
| 6295 | // InternalSolverLanguage.g:2166:4: (lv_objects_3_0= ruleNamedObject ) | ||
| 6296 | { | ||
| 6297 | // InternalSolverLanguage.g:2166:4: (lv_objects_3_0= ruleNamedObject ) | ||
| 6298 | // InternalSolverLanguage.g:2167:5: lv_objects_3_0= ruleNamedObject | ||
| 6299 | { | ||
| 6300 | |||
| 6301 | newCompositeNode(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); | ||
| 6302 | |||
| 6303 | pushFollow(FOLLOW_32); | ||
| 6304 | lv_objects_3_0=ruleNamedObject(); | ||
| 6305 | 9622 | ||
| 6306 | state._fsp--; | 9623 | } |
| 6307 | 9624 | ||
| 9625 | // InternalSolverLanguage.g:3367:3: ( (lv_objective_1_0= ruleExpression ) ) | ||
| 9626 | // InternalSolverLanguage.g:3368:4: (lv_objective_1_0= ruleExpression ) | ||
| 9627 | { | ||
| 9628 | // InternalSolverLanguage.g:3368:4: (lv_objective_1_0= ruleExpression ) | ||
| 9629 | // InternalSolverLanguage.g:3369:5: lv_objective_1_0= ruleExpression | ||
| 9630 | { | ||
| 9631 | if ( state.backtracking==0 ) { | ||
| 6308 | 9632 | ||
| 6309 | if (current==null) { | 9633 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); |
| 6310 | current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); | 9634 | |
| 6311 | } | 9635 | } |
| 6312 | add( | 9636 | pushFollow(FOLLOW_2); |
| 6313 | current, | 9637 | lv_objective_1_0=ruleExpression(); |
| 6314 | "objects", | ||
| 6315 | lv_objects_3_0, | ||
| 6316 | "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject"); | ||
| 6317 | afterParserOrEnumRuleCall(); | ||
| 6318 | |||
| 6319 | 9638 | ||
| 6320 | } | 9639 | state._fsp--; |
| 9640 | if (state.failed) return current; | ||
| 9641 | if ( state.backtracking==0 ) { | ||
| 6321 | 9642 | ||
| 9643 | if (current==null) { | ||
| 9644 | current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); | ||
| 9645 | } | ||
| 9646 | set( | ||
| 9647 | current, | ||
| 9648 | "objective", | ||
| 9649 | lv_objective_1_0, | ||
| 9650 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 9651 | afterParserOrEnumRuleCall(); | ||
| 9652 | |||
| 9653 | } | ||
| 6322 | 9654 | ||
| 6323 | } | 9655 | } |
| 6324 | break; | ||
| 6325 | 9656 | ||
| 6326 | default : | ||
| 6327 | if ( cnt41 >= 1 ) break loop41; | ||
| 6328 | EarlyExitException eee = | ||
| 6329 | new EarlyExitException(41, input); | ||
| 6330 | throw eee; | ||
| 6331 | } | ||
| 6332 | cnt41++; | ||
| 6333 | } while (true); | ||
| 6334 | 9657 | ||
| 6335 | otherlv_4=(Token)match(input,37,FOLLOW_2); | 9658 | } |
| 6336 | 9659 | ||
| 6337 | newLeafNode(otherlv_4, grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); | ||
| 6338 | |||
| 6339 | 9660 | ||
| 6340 | } | 9661 | } |
| 6341 | 9662 | ||
| 6342 | 9663 | ||
| 6343 | } | 9664 | } |
| 6344 | 9665 | ||
| 9666 | if ( state.backtracking==0 ) { | ||
| 6345 | 9667 | ||
| 6346 | leaveRule(); | 9668 | leaveRule(); |
| 6347 | 9669 | ||
| 9670 | } | ||
| 6348 | } | 9671 | } |
| 6349 | 9672 | ||
| 6350 | catch (RecognitionException re) { | 9673 | catch (RecognitionException re) { |
| @@ -6355,29 +9678,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6355 | } | 9678 | } |
| 6356 | return current; | 9679 | return current; |
| 6357 | } | 9680 | } |
| 6358 | // $ANTLR end "ruleEnumInterpretation" | 9681 | // $ANTLR end "ruleObjectiveDefinition" |
| 6359 | 9682 | ||
| 6360 | 9683 | ||
| 6361 | // $ANTLR start "entryRuleFieldRelationInterpretation" | 9684 | // $ANTLR start "entryRuleUpperMultiplicty" |
| 6362 | // InternalSolverLanguage.g:2192:1: entryRuleFieldRelationInterpretation returns [EObject current=null] : iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF ; | 9685 | // InternalSolverLanguage.g:3390:1: entryRuleUpperMultiplicty returns [String current=null] : iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF ; |
| 6363 | public final EObject entryRuleFieldRelationInterpretation() throws RecognitionException { | 9686 | public final String entryRuleUpperMultiplicty() throws RecognitionException { |
| 6364 | EObject current = null; | 9687 | String current = null; |
| 6365 | 9688 | ||
| 6366 | EObject iv_ruleFieldRelationInterpretation = null; | 9689 | AntlrDatatypeRuleToken iv_ruleUpperMultiplicty = null; |
| 6367 | 9690 | ||
| 6368 | 9691 | ||
| 6369 | try { | 9692 | try { |
| 6370 | // InternalSolverLanguage.g:2192:68: (iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF ) | 9693 | // InternalSolverLanguage.g:3390:56: (iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF ) |
| 6371 | // InternalSolverLanguage.g:2193:2: iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF | 9694 | // InternalSolverLanguage.g:3391:2: iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF |
| 6372 | { | 9695 | { |
| 6373 | newCompositeNode(grammarAccess.getFieldRelationInterpretationRule()); | 9696 | if ( state.backtracking==0 ) { |
| 9697 | newCompositeNode(grammarAccess.getUpperMultiplictyRule()); | ||
| 9698 | } | ||
| 6374 | pushFollow(FOLLOW_1); | 9699 | pushFollow(FOLLOW_1); |
| 6375 | iv_ruleFieldRelationInterpretation=ruleFieldRelationInterpretation(); | 9700 | iv_ruleUpperMultiplicty=ruleUpperMultiplicty(); |
| 6376 | 9701 | ||
| 6377 | state._fsp--; | 9702 | state._fsp--; |
| 6378 | 9703 | if (state.failed) return current; | |
| 6379 | current =iv_ruleFieldRelationInterpretation; | 9704 | if ( state.backtracking==0 ) { |
| 6380 | match(input,EOF,FOLLOW_2); | 9705 | current =iv_ruleUpperMultiplicty.getText(); |
| 9706 | } | ||
| 9707 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 6381 | 9708 | ||
| 6382 | } | 9709 | } |
| 6383 | 9710 | ||
| @@ -6391,171 +9718,205 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6391 | } | 9718 | } |
| 6392 | return current; | 9719 | return current; |
| 6393 | } | 9720 | } |
| 6394 | // $ANTLR end "entryRuleFieldRelationInterpretation" | 9721 | // $ANTLR end "entryRuleUpperMultiplicty" |
| 6395 | |||
| 6396 | 9722 | ||
| 6397 | // $ANTLR start "ruleFieldRelationInterpretation" | ||
| 6398 | // InternalSolverLanguage.g:2199: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 ) ) ) ; | ||
| 6399 | public final EObject ruleFieldRelationInterpretation() throws RecognitionException { | ||
| 6400 | EObject current = null; | ||
| 6401 | 9723 | ||
| 6402 | Token lv_containment_0_0=null; | 9724 | // $ANTLR start "ruleUpperMultiplicty" |
| 6403 | Token otherlv_2=null; | 9725 | // InternalSolverLanguage.g:3397:1: ruleUpperMultiplicty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT | kw= '*' ) ; |
| 6404 | EObject lv_symbol_1_0 = null; | 9726 | public final AntlrDatatypeRuleToken ruleUpperMultiplicty() throws RecognitionException { |
| 6405 | 9727 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | |
| 6406 | EObject lv_multiplicity_3_0 = null; | ||
| 6407 | |||
| 6408 | EObject lv_target_4_0 = null; | ||
| 6409 | 9728 | ||
| 9729 | Token this_INT_0=null; | ||
| 9730 | Token kw=null; | ||
| 6410 | 9731 | ||
| 6411 | 9732 | ||
| 6412 | enterRule(); | 9733 | enterRule(); |
| 6413 | 9734 | ||
| 6414 | try { | 9735 | try { |
| 6415 | // InternalSolverLanguage.g:2205:2: ( ( ( (lv_containment_0_0= 'containment' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) ) | 9736 | // InternalSolverLanguage.g:3403:2: ( (this_INT_0= RULE_INT | kw= '*' ) ) |
| 6416 | // InternalSolverLanguage.g:2206:2: ( ( (lv_containment_0_0= 'containment' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) | 9737 | // InternalSolverLanguage.g:3404:2: (this_INT_0= RULE_INT | kw= '*' ) |
| 6417 | { | 9738 | { |
| 6418 | // InternalSolverLanguage.g:2206:2: ( ( (lv_containment_0_0= 'containment' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) | 9739 | // InternalSolverLanguage.g:3404:2: (this_INT_0= RULE_INT | kw= '*' ) |
| 6419 | // InternalSolverLanguage.g:2207:3: ( (lv_containment_0_0= 'containment' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) | 9740 | int alt41=2; |
| 6420 | { | 9741 | int LA41_0 = input.LA(1); |
| 6421 | // InternalSolverLanguage.g:2207:3: ( (lv_containment_0_0= 'containment' ) )? | ||
| 6422 | int alt42=2; | ||
| 6423 | int LA42_0 = input.LA(1); | ||
| 6424 | 9742 | ||
| 6425 | if ( (LA42_0==39) ) { | 9743 | if ( (LA41_0==RULE_INT) ) { |
| 6426 | alt42=1; | 9744 | alt41=1; |
| 6427 | } | 9745 | } |
| 6428 | switch (alt42) { | 9746 | else if ( (LA41_0==35) ) { |
| 9747 | alt41=2; | ||
| 9748 | } | ||
| 9749 | else { | ||
| 9750 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 9751 | NoViableAltException nvae = | ||
| 9752 | new NoViableAltException("", 41, 0, input); | ||
| 9753 | |||
| 9754 | throw nvae; | ||
| 9755 | } | ||
| 9756 | switch (alt41) { | ||
| 6429 | case 1 : | 9757 | case 1 : |
| 6430 | // InternalSolverLanguage.g:2208:4: (lv_containment_0_0= 'containment' ) | 9758 | // InternalSolverLanguage.g:3405:3: this_INT_0= RULE_INT |
| 6431 | { | 9759 | { |
| 6432 | // InternalSolverLanguage.g:2208:4: (lv_containment_0_0= 'containment' ) | 9760 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current; |
| 6433 | // InternalSolverLanguage.g:2209:5: lv_containment_0_0= 'containment' | 9761 | if ( state.backtracking==0 ) { |
| 6434 | { | ||
| 6435 | lv_containment_0_0=(Token)match(input,39,FOLLOW_12); | ||
| 6436 | 9762 | ||
| 6437 | newLeafNode(lv_containment_0_0, grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); | 9763 | current.merge(this_INT_0); |
| 6438 | 9764 | ||
| 9765 | } | ||
| 9766 | if ( state.backtracking==0 ) { | ||
| 6439 | 9767 | ||
| 6440 | if (current==null) { | 9768 | newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); |
| 6441 | current = createModelElement(grammarAccess.getFieldRelationInterpretationRule()); | 9769 | |
| 6442 | } | 9770 | } |
| 6443 | setWithLastConsumed(current, "containment", true, "containment"); | ||
| 6444 | |||
| 6445 | 9771 | ||
| 6446 | } | 9772 | } |
| 9773 | break; | ||
| 9774 | case 2 : | ||
| 9775 | // InternalSolverLanguage.g:3413:3: kw= '*' | ||
| 9776 | { | ||
| 9777 | kw=(Token)match(input,35,FOLLOW_2); if (state.failed) return current; | ||
| 9778 | if ( state.backtracking==0 ) { | ||
| 6447 | 9779 | ||
| 9780 | current.merge(kw); | ||
| 9781 | newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); | ||
| 9782 | |||
| 9783 | } | ||
| 6448 | 9784 | ||
| 6449 | } | 9785 | } |
| 6450 | break; | 9786 | break; |
| 6451 | 9787 | ||
| 6452 | } | 9788 | } |
| 6453 | 9789 | ||
| 6454 | // InternalSolverLanguage.g:2221:3: ( (lv_symbol_1_0= ruleModelSymbol ) ) | ||
| 6455 | // InternalSolverLanguage.g:2222:4: (lv_symbol_1_0= ruleModelSymbol ) | ||
| 6456 | { | ||
| 6457 | // InternalSolverLanguage.g:2222:4: (lv_symbol_1_0= ruleModelSymbol ) | ||
| 6458 | // InternalSolverLanguage.g:2223:5: lv_symbol_1_0= ruleModelSymbol | ||
| 6459 | { | ||
| 6460 | 9790 | ||
| 6461 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); | 9791 | } |
| 6462 | |||
| 6463 | pushFollow(FOLLOW_10); | ||
| 6464 | lv_symbol_1_0=ruleModelSymbol(); | ||
| 6465 | 9792 | ||
| 6466 | state._fsp--; | 9793 | if ( state.backtracking==0 ) { |
| 6467 | 9794 | ||
| 9795 | leaveRule(); | ||
| 6468 | 9796 | ||
| 6469 | if (current==null) { | 9797 | } |
| 6470 | current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | 9798 | } |
| 6471 | } | ||
| 6472 | set( | ||
| 6473 | current, | ||
| 6474 | "symbol", | ||
| 6475 | lv_symbol_1_0, | ||
| 6476 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 6477 | afterParserOrEnumRuleCall(); | ||
| 6478 | |||
| 6479 | 9799 | ||
| 9800 | catch (RecognitionException re) { | ||
| 9801 | recover(input,re); | ||
| 9802 | appendSkippedTokens(); | ||
| 6480 | } | 9803 | } |
| 9804 | finally { | ||
| 9805 | } | ||
| 9806 | return current; | ||
| 9807 | } | ||
| 9808 | // $ANTLR end "ruleUpperMultiplicty" | ||
| 6481 | 9809 | ||
| 6482 | 9810 | ||
| 6483 | } | 9811 | // $ANTLR start "entryRuleReal" |
| 9812 | // InternalSolverLanguage.g:3422:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ; | ||
| 9813 | public final String entryRuleReal() throws RecognitionException { | ||
| 9814 | String current = null; | ||
| 9815 | |||
| 9816 | AntlrDatatypeRuleToken iv_ruleReal = null; | ||
| 6484 | 9817 | ||
| 6485 | otherlv_2=(Token)match(input,20,FOLLOW_33); | ||
| 6486 | 9818 | ||
| 6487 | newLeafNode(otherlv_2, grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); | ||
| 6488 | |||
| 6489 | // InternalSolverLanguage.g:2244:3: ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? | ||
| 6490 | int alt43=2; | ||
| 6491 | int LA43_0 = input.LA(1); | ||
| 6492 | 9819 | ||
| 6493 | if ( (LA43_0==RULE_INT) ) { | 9820 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
| 6494 | alt43=1; | 9821 | |
| 9822 | try { | ||
| 9823 | // InternalSolverLanguage.g:3424:2: (iv_ruleReal= ruleReal EOF ) | ||
| 9824 | // InternalSolverLanguage.g:3425:2: iv_ruleReal= ruleReal EOF | ||
| 9825 | { | ||
| 9826 | if ( state.backtracking==0 ) { | ||
| 9827 | newCompositeNode(grammarAccess.getRealRule()); | ||
| 6495 | } | 9828 | } |
| 6496 | switch (alt43) { | 9829 | pushFollow(FOLLOW_1); |
| 6497 | case 1 : | 9830 | iv_ruleReal=ruleReal(); |
| 6498 | // InternalSolverLanguage.g:2245:4: (lv_multiplicity_3_0= ruleMultiplicityDefinition ) | ||
| 6499 | { | ||
| 6500 | // InternalSolverLanguage.g:2245:4: (lv_multiplicity_3_0= ruleMultiplicityDefinition ) | ||
| 6501 | // InternalSolverLanguage.g:2246:5: lv_multiplicity_3_0= ruleMultiplicityDefinition | ||
| 6502 | { | ||
| 6503 | 9831 | ||
| 6504 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); | 9832 | state._fsp--; |
| 6505 | 9833 | if (state.failed) return current; | |
| 6506 | pushFollow(FOLLOW_21); | 9834 | if ( state.backtracking==0 ) { |
| 6507 | lv_multiplicity_3_0=ruleMultiplicityDefinition(); | 9835 | current =iv_ruleReal.getText(); |
| 9836 | } | ||
| 9837 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 6508 | 9838 | ||
| 6509 | state._fsp--; | 9839 | } |
| 9840 | |||
| 9841 | } | ||
| 6510 | 9842 | ||
| 9843 | catch (RecognitionException re) { | ||
| 9844 | recover(input,re); | ||
| 9845 | appendSkippedTokens(); | ||
| 9846 | } | ||
| 9847 | finally { | ||
| 6511 | 9848 | ||
| 6512 | if (current==null) { | 9849 | myHiddenTokenState.restore(); |
| 6513 | current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 6514 | } | ||
| 6515 | set( | ||
| 6516 | current, | ||
| 6517 | "multiplicity", | ||
| 6518 | lv_multiplicity_3_0, | ||
| 6519 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 6520 | afterParserOrEnumRuleCall(); | ||
| 6521 | |||
| 6522 | 9850 | ||
| 6523 | } | 9851 | } |
| 9852 | return current; | ||
| 9853 | } | ||
| 9854 | // $ANTLR end "entryRuleReal" | ||
| 6524 | 9855 | ||
| 6525 | 9856 | ||
| 6526 | } | 9857 | // $ANTLR start "ruleReal" |
| 6527 | break; | 9858 | // InternalSolverLanguage.g:3434:1: ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT (kw= '.' this_INT_2= RULE_INT )? ) ; |
| 9859 | public final AntlrDatatypeRuleToken ruleReal() throws RecognitionException { | ||
| 9860 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | ||
| 6528 | 9861 | ||
| 6529 | } | 9862 | Token this_INT_0=null; |
| 9863 | Token kw=null; | ||
| 9864 | Token this_INT_2=null; | ||
| 6530 | 9865 | ||
| 6531 | // InternalSolverLanguage.g:2263:3: ( (lv_target_4_0= ruleSymbol ) ) | 9866 | |
| 6532 | // InternalSolverLanguage.g:2264:4: (lv_target_4_0= ruleSymbol ) | 9867 | enterRule(); |
| 9868 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 9869 | |||
| 9870 | try { | ||
| 9871 | // InternalSolverLanguage.g:3441:2: ( (this_INT_0= RULE_INT (kw= '.' this_INT_2= RULE_INT )? ) ) | ||
| 9872 | // InternalSolverLanguage.g:3442:2: (this_INT_0= RULE_INT (kw= '.' this_INT_2= RULE_INT )? ) | ||
| 6533 | { | 9873 | { |
| 6534 | // InternalSolverLanguage.g:2264:4: (lv_target_4_0= ruleSymbol ) | 9874 | // InternalSolverLanguage.g:3442:2: (this_INT_0= RULE_INT (kw= '.' this_INT_2= RULE_INT )? ) |
| 6535 | // InternalSolverLanguage.g:2265:5: lv_target_4_0= ruleSymbol | 9875 | // InternalSolverLanguage.g:3443:3: this_INT_0= RULE_INT (kw= '.' this_INT_2= RULE_INT )? |
| 6536 | { | 9876 | { |
| 9877 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_53); if (state.failed) return current; | ||
| 9878 | if ( state.backtracking==0 ) { | ||
| 6537 | 9879 | ||
| 6538 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); | 9880 | current.merge(this_INT_0); |
| 6539 | 9881 | ||
| 6540 | pushFollow(FOLLOW_2); | 9882 | } |
| 6541 | lv_target_4_0=ruleSymbol(); | 9883 | if ( state.backtracking==0 ) { |
| 6542 | 9884 | ||
| 6543 | state._fsp--; | 9885 | newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); |
| 9886 | |||
| 9887 | } | ||
| 9888 | // InternalSolverLanguage.g:3450:3: (kw= '.' this_INT_2= RULE_INT )? | ||
| 9889 | int alt42=2; | ||
| 9890 | int LA42_0 = input.LA(1); | ||
| 6544 | 9891 | ||
| 9892 | if ( (LA42_0==22) ) { | ||
| 9893 | alt42=1; | ||
| 9894 | } | ||
| 9895 | switch (alt42) { | ||
| 9896 | case 1 : | ||
| 9897 | // InternalSolverLanguage.g:3451:4: kw= '.' this_INT_2= RULE_INT | ||
| 9898 | { | ||
| 9899 | kw=(Token)match(input,22,FOLLOW_47); if (state.failed) return current; | ||
| 9900 | if ( state.backtracking==0 ) { | ||
| 6545 | 9901 | ||
| 6546 | if (current==null) { | 9902 | current.merge(kw); |
| 6547 | current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | 9903 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1_0()); |
| 6548 | } | 9904 | |
| 6549 | set( | 9905 | } |
| 6550 | current, | 9906 | this_INT_2=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current; |
| 6551 | "target", | 9907 | if ( state.backtracking==0 ) { |
| 6552 | lv_target_4_0, | ||
| 6553 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 6554 | afterParserOrEnumRuleCall(); | ||
| 6555 | |||
| 6556 | 9908 | ||
| 6557 | } | 9909 | current.merge(this_INT_2); |
| 9910 | |||
| 9911 | } | ||
| 9912 | if ( state.backtracking==0 ) { | ||
| 6558 | 9913 | ||
| 9914 | newLeafNode(this_INT_2, grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); | ||
| 9915 | |||
| 9916 | } | ||
| 9917 | |||
| 9918 | } | ||
| 9919 | break; | ||
| 6559 | 9920 | ||
| 6560 | } | 9921 | } |
| 6561 | 9922 | ||
| @@ -6565,9 +9926,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6565 | 9926 | ||
| 6566 | } | 9927 | } |
| 6567 | 9928 | ||
| 9929 | if ( state.backtracking==0 ) { | ||
| 6568 | 9930 | ||
| 6569 | leaveRule(); | 9931 | leaveRule(); |
| 6570 | 9932 | ||
| 9933 | } | ||
| 6571 | } | 9934 | } |
| 6572 | 9935 | ||
| 6573 | catch (RecognitionException re) { | 9936 | catch (RecognitionException re) { |
| @@ -6575,32 +9938,42 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6575 | appendSkippedTokens(); | 9938 | appendSkippedTokens(); |
| 6576 | } | 9939 | } |
| 6577 | finally { | 9940 | finally { |
| 9941 | |||
| 9942 | myHiddenTokenState.restore(); | ||
| 9943 | |||
| 6578 | } | 9944 | } |
| 6579 | return current; | 9945 | return current; |
| 6580 | } | 9946 | } |
| 6581 | // $ANTLR end "ruleFieldRelationInterpretation" | 9947 | // $ANTLR end "ruleReal" |
| 6582 | 9948 | ||
| 6583 | 9949 | ||
| 6584 | // $ANTLR start "entryRuleGlobalRelationInterpretation" | 9950 | // $ANTLR start "entryRuleQualifiedName" |
| 6585 | // InternalSolverLanguage.g:2286:1: entryRuleGlobalRelationInterpretation returns [EObject current=null] : iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF ; | 9951 | // InternalSolverLanguage.g:3471:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; |
| 6586 | public final EObject entryRuleGlobalRelationInterpretation() throws RecognitionException { | 9952 | public final String entryRuleQualifiedName() throws RecognitionException { |
| 6587 | EObject current = null; | 9953 | String current = null; |
| 9954 | |||
| 9955 | AntlrDatatypeRuleToken iv_ruleQualifiedName = null; | ||
| 6588 | 9956 | ||
| 6589 | EObject iv_ruleGlobalRelationInterpretation = null; | ||
| 6590 | 9957 | ||
| 6591 | 9958 | ||
| 9959 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 9960 | |||
| 6592 | try { | 9961 | try { |
| 6593 | // InternalSolverLanguage.g:2286:69: (iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF ) | 9962 | // InternalSolverLanguage.g:3473:2: (iv_ruleQualifiedName= ruleQualifiedName EOF ) |
| 6594 | // InternalSolverLanguage.g:2287:2: iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF | 9963 | // InternalSolverLanguage.g:3474:2: iv_ruleQualifiedName= ruleQualifiedName EOF |
| 6595 | { | 9964 | { |
| 6596 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationRule()); | 9965 | if ( state.backtracking==0 ) { |
| 9966 | newCompositeNode(grammarAccess.getQualifiedNameRule()); | ||
| 9967 | } | ||
| 6597 | pushFollow(FOLLOW_1); | 9968 | pushFollow(FOLLOW_1); |
| 6598 | iv_ruleGlobalRelationInterpretation=ruleGlobalRelationInterpretation(); | 9969 | iv_ruleQualifiedName=ruleQualifiedName(); |
| 6599 | 9970 | ||
| 6600 | state._fsp--; | 9971 | state._fsp--; |
| 6601 | 9972 | if (state.failed) return current; | |
| 6602 | current =iv_ruleGlobalRelationInterpretation; | 9973 | if ( state.backtracking==0 ) { |
| 6603 | match(input,EOF,FOLLOW_2); | 9974 | current =iv_ruleQualifiedName.getText(); |
| 9975 | } | ||
| 9976 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
| 6604 | 9977 | ||
| 6605 | } | 9978 | } |
| 6606 | 9979 | ||
| @@ -6611,146 +9984,231 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6611 | appendSkippedTokens(); | 9984 | appendSkippedTokens(); |
| 6612 | } | 9985 | } |
| 6613 | finally { | 9986 | finally { |
| 9987 | |||
| 9988 | myHiddenTokenState.restore(); | ||
| 9989 | |||
| 6614 | } | 9990 | } |
| 6615 | return current; | 9991 | return current; |
| 6616 | } | 9992 | } |
| 6617 | // $ANTLR end "entryRuleGlobalRelationInterpretation" | 9993 | // $ANTLR end "entryRuleQualifiedName" |
| 6618 | |||
| 6619 | |||
| 6620 | // $ANTLR start "ruleGlobalRelationInterpretation" | ||
| 6621 | // InternalSolverLanguage.g:2293: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 ) ) ) ; | ||
| 6622 | public final EObject ruleGlobalRelationInterpretation() throws RecognitionException { | ||
| 6623 | EObject current = null; | ||
| 6624 | 9994 | ||
| 6625 | Token lv_containment_0_0=null; | ||
| 6626 | Token otherlv_1=null; | ||
| 6627 | Token otherlv_3=null; | ||
| 6628 | EObject lv_symbol_2_0 = null; | ||
| 6629 | |||
| 6630 | EObject lv_sourceMultiplicity_4_0 = null; | ||
| 6631 | 9995 | ||
| 6632 | EObject lv_source_5_0 = null; | 9996 | // $ANTLR start "ruleQualifiedName" |
| 6633 | 9997 | // InternalSolverLanguage.g:3483:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) ; | |
| 6634 | EObject lv_targetMultiplicity_6_0 = null; | 9998 | public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { |
| 6635 | 9999 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | |
| 6636 | EObject lv_target_7_0 = null; | ||
| 6637 | 10000 | ||
| 10001 | Token this_ID_0=null; | ||
| 10002 | Token kw=null; | ||
| 10003 | Token this_ID_2=null; | ||
| 10004 | Token this_QUOTED_ID_3=null; | ||
| 6638 | 10005 | ||
| 6639 | 10006 | ||
| 6640 | enterRule(); | 10007 | enterRule(); |
| 10008 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 6641 | 10009 | ||
| 6642 | try { | 10010 | try { |
| 6643 | // InternalSolverLanguage.g:2299: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 ) ) ) ) | 10011 | // InternalSolverLanguage.g:3490:2: ( ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) ) |
| 6644 | // InternalSolverLanguage.g:2300: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 ) ) ) | 10012 | // InternalSolverLanguage.g:3491:2: ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) |
| 6645 | { | 10013 | { |
| 6646 | // InternalSolverLanguage.g:2300: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 ) ) ) | 10014 | // InternalSolverLanguage.g:3491:2: ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) |
| 6647 | // InternalSolverLanguage.g:2301: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 ) ) | ||
| 6648 | { | ||
| 6649 | // InternalSolverLanguage.g:2301:3: ( (lv_containment_0_0= 'containment' ) )? | ||
| 6650 | int alt44=2; | 10015 | int alt44=2; |
| 6651 | int LA44_0 = input.LA(1); | 10016 | int LA44_0 = input.LA(1); |
| 6652 | 10017 | ||
| 6653 | if ( (LA44_0==39) ) { | 10018 | if ( (LA44_0==RULE_ID) ) { |
| 6654 | alt44=1; | 10019 | alt44=1; |
| 6655 | } | 10020 | } |
| 10021 | else if ( (LA44_0==RULE_QUOTED_ID) ) { | ||
| 10022 | alt44=2; | ||
| 10023 | } | ||
| 10024 | else { | ||
| 10025 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 10026 | NoViableAltException nvae = | ||
| 10027 | new NoViableAltException("", 44, 0, input); | ||
| 10028 | |||
| 10029 | throw nvae; | ||
| 10030 | } | ||
| 6656 | switch (alt44) { | 10031 | switch (alt44) { |
| 6657 | case 1 : | 10032 | case 1 : |
| 6658 | // InternalSolverLanguage.g:2302:4: (lv_containment_0_0= 'containment' ) | 10033 | // InternalSolverLanguage.g:3492:3: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) |
| 6659 | { | 10034 | { |
| 6660 | // InternalSolverLanguage.g:2302:4: (lv_containment_0_0= 'containment' ) | 10035 | // InternalSolverLanguage.g:3492:3: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) |
| 6661 | // InternalSolverLanguage.g:2303:5: lv_containment_0_0= 'containment' | 10036 | // InternalSolverLanguage.g:3493:4: this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* |
| 6662 | { | 10037 | { |
| 6663 | lv_containment_0_0=(Token)match(input,39,FOLLOW_34); | 10038 | this_ID_0=(Token)match(input,RULE_ID,FOLLOW_53); if (state.failed) return current; |
| 10039 | if ( state.backtracking==0 ) { | ||
| 6664 | 10040 | ||
| 6665 | newLeafNode(lv_containment_0_0, grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); | 10041 | current.merge(this_ID_0); |
| 6666 | 10042 | ||
| 10043 | } | ||
| 10044 | if ( state.backtracking==0 ) { | ||
| 10045 | |||
| 10046 | newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); | ||
| 10047 | |||
| 10048 | } | ||
| 10049 | // InternalSolverLanguage.g:3500:4: (kw= '.' this_ID_2= RULE_ID )* | ||
| 10050 | loop43: | ||
| 10051 | do { | ||
| 10052 | int alt43=2; | ||
| 10053 | int LA43_0 = input.LA(1); | ||
| 10054 | |||
| 10055 | if ( (LA43_0==22) ) { | ||
| 10056 | int LA43_2 = input.LA(2); | ||
| 10057 | |||
| 10058 | if ( (LA43_2==RULE_ID) ) { | ||
| 10059 | alt43=1; | ||
| 10060 | } | ||
| 10061 | |||
| 10062 | |||
| 10063 | } | ||
| 10064 | |||
| 10065 | |||
| 10066 | switch (alt43) { | ||
| 10067 | case 1 : | ||
| 10068 | // InternalSolverLanguage.g:3501:5: kw= '.' this_ID_2= RULE_ID | ||
| 10069 | { | ||
| 10070 | kw=(Token)match(input,22,FOLLOW_40); if (state.failed) return current; | ||
| 10071 | if ( state.backtracking==0 ) { | ||
| 10072 | |||
| 10073 | current.merge(kw); | ||
| 10074 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); | ||
| 10075 | |||
| 10076 | } | ||
| 10077 | this_ID_2=(Token)match(input,RULE_ID,FOLLOW_53); if (state.failed) return current; | ||
| 10078 | if ( state.backtracking==0 ) { | ||
| 10079 | |||
| 10080 | current.merge(this_ID_2); | ||
| 10081 | |||
| 10082 | } | ||
| 10083 | if ( state.backtracking==0 ) { | ||
| 10084 | |||
| 10085 | newLeafNode(this_ID_2, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); | ||
| 10086 | |||
| 10087 | } | ||
| 10088 | |||
| 10089 | } | ||
| 10090 | break; | ||
| 10091 | |||
| 10092 | default : | ||
| 10093 | break loop43; | ||
| 10094 | } | ||
| 10095 | } while (true); | ||
| 6667 | 10096 | ||
| 6668 | if (current==null) { | ||
| 6669 | current = createModelElement(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 6670 | } | ||
| 6671 | setWithLastConsumed(current, "containment", true, "containment"); | ||
| 6672 | |||
| 6673 | 10097 | ||
| 6674 | } | 10098 | } |
| 6675 | 10099 | ||
| 6676 | 10100 | ||
| 6677 | } | 10101 | } |
| 6678 | break; | 10102 | break; |
| 10103 | case 2 : | ||
| 10104 | // InternalSolverLanguage.g:3516:3: this_QUOTED_ID_3= RULE_QUOTED_ID | ||
| 10105 | { | ||
| 10106 | this_QUOTED_ID_3=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); if (state.failed) return current; | ||
| 10107 | if ( state.backtracking==0 ) { | ||
| 6679 | 10108 | ||
| 6680 | } | 10109 | current.merge(this_QUOTED_ID_3); |
| 10110 | |||
| 10111 | } | ||
| 10112 | if ( state.backtracking==0 ) { | ||
| 6681 | 10113 | ||
| 6682 | otherlv_1=(Token)match(input,40,FOLLOW_12); | 10114 | newLeafNode(this_QUOTED_ID_3, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); |
| 10115 | |||
| 10116 | } | ||
| 6683 | 10117 | ||
| 6684 | newLeafNode(otherlv_1, grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); | 10118 | } |
| 6685 | 10119 | break; | |
| 6686 | // InternalSolverLanguage.g:2319:3: ( (lv_symbol_2_0= ruleModelSymbol ) ) | ||
| 6687 | // InternalSolverLanguage.g:2320:4: (lv_symbol_2_0= ruleModelSymbol ) | ||
| 6688 | { | ||
| 6689 | // InternalSolverLanguage.g:2320:4: (lv_symbol_2_0= ruleModelSymbol ) | ||
| 6690 | // InternalSolverLanguage.g:2321:5: lv_symbol_2_0= ruleModelSymbol | ||
| 6691 | { | ||
| 6692 | 10120 | ||
| 6693 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); | 10121 | } |
| 6694 | |||
| 6695 | pushFollow(FOLLOW_10); | ||
| 6696 | lv_symbol_2_0=ruleModelSymbol(); | ||
| 6697 | 10122 | ||
| 6698 | state._fsp--; | ||
| 6699 | 10123 | ||
| 10124 | } | ||
| 6700 | 10125 | ||
| 6701 | if (current==null) { | 10126 | if ( state.backtracking==0 ) { |
| 6702 | current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 6703 | } | ||
| 6704 | set( | ||
| 6705 | current, | ||
| 6706 | "symbol", | ||
| 6707 | lv_symbol_2_0, | ||
| 6708 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 6709 | afterParserOrEnumRuleCall(); | ||
| 6710 | |||
| 6711 | 10127 | ||
| 6712 | } | 10128 | leaveRule(); |
| 6713 | 10129 | ||
| 10130 | } | ||
| 10131 | } | ||
| 6714 | 10132 | ||
| 10133 | catch (RecognitionException re) { | ||
| 10134 | recover(input,re); | ||
| 10135 | appendSkippedTokens(); | ||
| 6715 | } | 10136 | } |
| 10137 | finally { | ||
| 10138 | |||
| 10139 | myHiddenTokenState.restore(); | ||
| 10140 | |||
| 10141 | } | ||
| 10142 | return current; | ||
| 10143 | } | ||
| 10144 | // $ANTLR end "ruleQualifiedName" | ||
| 10145 | |||
| 6716 | 10146 | ||
| 6717 | otherlv_3=(Token)match(input,20,FOLLOW_33); | 10147 | // $ANTLR start "ruleMetricType" |
| 10148 | // InternalSolverLanguage.g:3530:1: ruleMetricType returns [Enumerator current=null] : ( (enumLiteral_0= 'int' ) | (enumLiteral_1= 'real' ) ) ; | ||
| 10149 | public final Enumerator ruleMetricType() throws RecognitionException { | ||
| 10150 | Enumerator current = null; | ||
| 6718 | 10151 | ||
| 6719 | newLeafNode(otherlv_3, grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); | 10152 | Token enumLiteral_0=null; |
| 6720 | 10153 | Token enumLiteral_1=null; | |
| 6721 | // InternalSolverLanguage.g:2342:3: ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? | 10154 | |
| 10155 | |||
| 10156 | enterRule(); | ||
| 10157 | |||
| 10158 | try { | ||
| 10159 | // InternalSolverLanguage.g:3536:2: ( ( (enumLiteral_0= 'int' ) | (enumLiteral_1= 'real' ) ) ) | ||
| 10160 | // InternalSolverLanguage.g:3537:2: ( (enumLiteral_0= 'int' ) | (enumLiteral_1= 'real' ) ) | ||
| 10161 | { | ||
| 10162 | // InternalSolverLanguage.g:3537:2: ( (enumLiteral_0= 'int' ) | (enumLiteral_1= 'real' ) ) | ||
| 6722 | int alt45=2; | 10163 | int alt45=2; |
| 6723 | int LA45_0 = input.LA(1); | 10164 | int LA45_0 = input.LA(1); |
| 6724 | 10165 | ||
| 6725 | if ( (LA45_0==RULE_INT) ) { | 10166 | if ( (LA45_0==50) ) { |
| 6726 | alt45=1; | 10167 | alt45=1; |
| 6727 | } | 10168 | } |
| 10169 | else if ( (LA45_0==51) ) { | ||
| 10170 | alt45=2; | ||
| 10171 | } | ||
| 10172 | else { | ||
| 10173 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 10174 | NoViableAltException nvae = | ||
| 10175 | new NoViableAltException("", 45, 0, input); | ||
| 10176 | |||
| 10177 | throw nvae; | ||
| 10178 | } | ||
| 6728 | switch (alt45) { | 10179 | switch (alt45) { |
| 6729 | case 1 : | 10180 | case 1 : |
| 6730 | // InternalSolverLanguage.g:2343:4: (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) | 10181 | // InternalSolverLanguage.g:3538:3: (enumLiteral_0= 'int' ) |
| 6731 | { | 10182 | { |
| 6732 | // InternalSolverLanguage.g:2343:4: (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) | 10183 | // InternalSolverLanguage.g:3538:3: (enumLiteral_0= 'int' ) |
| 6733 | // InternalSolverLanguage.g:2344:5: lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition | 10184 | // InternalSolverLanguage.g:3539:4: enumLiteral_0= 'int' |
| 6734 | { | 10185 | { |
| 10186 | enumLiteral_0=(Token)match(input,50,FOLLOW_2); if (state.failed) return current; | ||
| 10187 | if ( state.backtracking==0 ) { | ||
| 6735 | 10188 | ||
| 6736 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); | 10189 | current = grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 6737 | 10190 | newLeafNode(enumLiteral_0, grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); | |
| 6738 | pushFollow(FOLLOW_21); | 10191 | |
| 6739 | lv_sourceMultiplicity_4_0=ruleMultiplicityDefinition(); | 10192 | } |
| 6740 | 10193 | ||
| 6741 | state._fsp--; | 10194 | } |
| 6742 | 10195 | ||
| 6743 | 10196 | ||
| 6744 | if (current==null) { | 10197 | } |
| 6745 | current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | 10198 | break; |
| 6746 | } | 10199 | case 2 : |
| 6747 | set( | 10200 | // InternalSolverLanguage.g:3546:3: (enumLiteral_1= 'real' ) |
| 6748 | current, | 10201 | { |
| 6749 | "sourceMultiplicity", | 10202 | // InternalSolverLanguage.g:3546:3: (enumLiteral_1= 'real' ) |
| 6750 | lv_sourceMultiplicity_4_0, | 10203 | // InternalSolverLanguage.g:3547:4: enumLiteral_1= 'real' |
| 6751 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | 10204 | { |
| 6752 | afterParserOrEnumRuleCall(); | 10205 | enumLiteral_1=(Token)match(input,51,FOLLOW_2); if (state.failed) return current; |
| 6753 | 10206 | if ( state.backtracking==0 ) { | |
| 10207 | |||
| 10208 | current = grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 10209 | newLeafNode(enumLiteral_1, grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); | ||
| 10210 | |||
| 10211 | } | ||
| 6754 | 10212 | ||
| 6755 | } | 10213 | } |
| 6756 | 10214 | ||
| @@ -6760,70 +10218,221 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6760 | 10218 | ||
| 6761 | } | 10219 | } |
| 6762 | 10220 | ||
| 6763 | // InternalSolverLanguage.g:2361:3: ( (lv_source_5_0= ruleSymbol ) ) | ||
| 6764 | // InternalSolverLanguage.g:2362:4: (lv_source_5_0= ruleSymbol ) | ||
| 6765 | { | ||
| 6766 | // InternalSolverLanguage.g:2362:4: (lv_source_5_0= ruleSymbol ) | ||
| 6767 | // InternalSolverLanguage.g:2363:5: lv_source_5_0= ruleSymbol | ||
| 6768 | { | ||
| 6769 | 10221 | ||
| 6770 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); | 10222 | } |
| 6771 | |||
| 6772 | pushFollow(FOLLOW_33); | ||
| 6773 | lv_source_5_0=ruleSymbol(); | ||
| 6774 | 10223 | ||
| 6775 | state._fsp--; | 10224 | if ( state.backtracking==0 ) { |
| 6776 | 10225 | ||
| 10226 | leaveRule(); | ||
| 6777 | 10227 | ||
| 6778 | if (current==null) { | 10228 | } |
| 6779 | current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | 10229 | } |
| 6780 | } | ||
| 6781 | set( | ||
| 6782 | current, | ||
| 6783 | "source", | ||
| 6784 | lv_source_5_0, | ||
| 6785 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 6786 | afterParserOrEnumRuleCall(); | ||
| 6787 | |||
| 6788 | 10230 | ||
| 10231 | catch (RecognitionException re) { | ||
| 10232 | recover(input,re); | ||
| 10233 | appendSkippedTokens(); | ||
| 6789 | } | 10234 | } |
| 10235 | finally { | ||
| 10236 | } | ||
| 10237 | return current; | ||
| 10238 | } | ||
| 10239 | // $ANTLR end "ruleMetricType" | ||
| 6790 | 10240 | ||
| 6791 | 10241 | ||
| 6792 | } | 10242 | // $ANTLR start "ruleComparisonOperator" |
| 10243 | // InternalSolverLanguage.g:3557:1: ruleComparisonOperator returns [Enumerator current=null] : ( (enumLiteral_0= '==' ) | (enumLiteral_1= '!=' ) | (enumLiteral_2= '<' ) | (enumLiteral_3= '<=' ) | (enumLiteral_4= '>' ) | (enumLiteral_5= '>=' ) | (enumLiteral_6= 'in' ) ) ; | ||
| 10244 | public final Enumerator ruleComparisonOperator() throws RecognitionException { | ||
| 10245 | Enumerator current = null; | ||
| 10246 | |||
| 10247 | Token enumLiteral_0=null; | ||
| 10248 | Token enumLiteral_1=null; | ||
| 10249 | Token enumLiteral_2=null; | ||
| 10250 | Token enumLiteral_3=null; | ||
| 10251 | Token enumLiteral_4=null; | ||
| 10252 | Token enumLiteral_5=null; | ||
| 10253 | Token enumLiteral_6=null; | ||
| 6793 | 10254 | ||
| 6794 | // InternalSolverLanguage.g:2380:3: ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? | ||
| 6795 | int alt46=2; | ||
| 6796 | int LA46_0 = input.LA(1); | ||
| 6797 | 10255 | ||
| 6798 | if ( (LA46_0==RULE_INT) ) { | 10256 | enterRule(); |
| 10257 | |||
| 10258 | try { | ||
| 10259 | // InternalSolverLanguage.g:3563:2: ( ( (enumLiteral_0= '==' ) | (enumLiteral_1= '!=' ) | (enumLiteral_2= '<' ) | (enumLiteral_3= '<=' ) | (enumLiteral_4= '>' ) | (enumLiteral_5= '>=' ) | (enumLiteral_6= 'in' ) ) ) | ||
| 10260 | // InternalSolverLanguage.g:3564:2: ( (enumLiteral_0= '==' ) | (enumLiteral_1= '!=' ) | (enumLiteral_2= '<' ) | (enumLiteral_3= '<=' ) | (enumLiteral_4= '>' ) | (enumLiteral_5= '>=' ) | (enumLiteral_6= 'in' ) ) | ||
| 10261 | { | ||
| 10262 | // InternalSolverLanguage.g:3564:2: ( (enumLiteral_0= '==' ) | (enumLiteral_1= '!=' ) | (enumLiteral_2= '<' ) | (enumLiteral_3= '<=' ) | (enumLiteral_4= '>' ) | (enumLiteral_5= '>=' ) | (enumLiteral_6= 'in' ) ) | ||
| 10263 | int alt46=7; | ||
| 10264 | switch ( input.LA(1) ) { | ||
| 10265 | case 47: | ||
| 10266 | { | ||
| 6799 | alt46=1; | 10267 | alt46=1; |
| 10268 | } | ||
| 10269 | break; | ||
| 10270 | case 52: | ||
| 10271 | { | ||
| 10272 | alt46=2; | ||
| 10273 | } | ||
| 10274 | break; | ||
| 10275 | case 53: | ||
| 10276 | { | ||
| 10277 | alt46=3; | ||
| 10278 | } | ||
| 10279 | break; | ||
| 10280 | case 48: | ||
| 10281 | { | ||
| 10282 | alt46=4; | ||
| 10283 | } | ||
| 10284 | break; | ||
| 10285 | case 54: | ||
| 10286 | { | ||
| 10287 | alt46=5; | ||
| 10288 | } | ||
| 10289 | break; | ||
| 10290 | case 49: | ||
| 10291 | { | ||
| 10292 | alt46=6; | ||
| 10293 | } | ||
| 10294 | break; | ||
| 10295 | case 55: | ||
| 10296 | { | ||
| 10297 | alt46=7; | ||
| 10298 | } | ||
| 10299 | break; | ||
| 10300 | default: | ||
| 10301 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 10302 | NoViableAltException nvae = | ||
| 10303 | new NoViableAltException("", 46, 0, input); | ||
| 10304 | |||
| 10305 | throw nvae; | ||
| 6800 | } | 10306 | } |
| 10307 | |||
| 6801 | switch (alt46) { | 10308 | switch (alt46) { |
| 6802 | case 1 : | 10309 | case 1 : |
| 6803 | // InternalSolverLanguage.g:2381:4: (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) | 10310 | // InternalSolverLanguage.g:3565:3: (enumLiteral_0= '==' ) |
| 6804 | { | 10311 | { |
| 6805 | // InternalSolverLanguage.g:2381:4: (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) | 10312 | // InternalSolverLanguage.g:3565:3: (enumLiteral_0= '==' ) |
| 6806 | // InternalSolverLanguage.g:2382:5: lv_targetMultiplicity_6_0= ruleMultiplicityDefinition | 10313 | // InternalSolverLanguage.g:3566:4: enumLiteral_0= '==' |
| 6807 | { | 10314 | { |
| 10315 | enumLiteral_0=(Token)match(input,47,FOLLOW_2); if (state.failed) return current; | ||
| 10316 | if ( state.backtracking==0 ) { | ||
| 6808 | 10317 | ||
| 6809 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); | 10318 | current = grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 6810 | 10319 | newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); | |
| 6811 | pushFollow(FOLLOW_21); | 10320 | |
| 6812 | lv_targetMultiplicity_6_0=ruleMultiplicityDefinition(); | 10321 | } |
| 6813 | 10322 | ||
| 6814 | state._fsp--; | 10323 | } |
| 10324 | |||
| 10325 | |||
| 10326 | } | ||
| 10327 | break; | ||
| 10328 | case 2 : | ||
| 10329 | // InternalSolverLanguage.g:3573:3: (enumLiteral_1= '!=' ) | ||
| 10330 | { | ||
| 10331 | // InternalSolverLanguage.g:3573:3: (enumLiteral_1= '!=' ) | ||
| 10332 | // InternalSolverLanguage.g:3574:4: enumLiteral_1= '!=' | ||
| 10333 | { | ||
| 10334 | enumLiteral_1=(Token)match(input,52,FOLLOW_2); if (state.failed) return current; | ||
| 10335 | if ( state.backtracking==0 ) { | ||
| 10336 | |||
| 10337 | current = grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 10338 | newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); | ||
| 10339 | |||
| 10340 | } | ||
| 10341 | |||
| 10342 | } | ||
| 6815 | 10343 | ||
| 6816 | 10344 | ||
| 6817 | if (current==null) { | 10345 | } |
| 6818 | current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | 10346 | break; |
| 6819 | } | 10347 | case 3 : |
| 6820 | set( | 10348 | // InternalSolverLanguage.g:3581:3: (enumLiteral_2= '<' ) |
| 6821 | current, | 10349 | { |
| 6822 | "targetMultiplicity", | 10350 | // InternalSolverLanguage.g:3581:3: (enumLiteral_2= '<' ) |
| 6823 | lv_targetMultiplicity_6_0, | 10351 | // InternalSolverLanguage.g:3582:4: enumLiteral_2= '<' |
| 6824 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | 10352 | { |
| 6825 | afterParserOrEnumRuleCall(); | 10353 | enumLiteral_2=(Token)match(input,53,FOLLOW_2); if (state.failed) return current; |
| 6826 | 10354 | if ( state.backtracking==0 ) { | |
| 10355 | |||
| 10356 | current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 10357 | newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); | ||
| 10358 | |||
| 10359 | } | ||
| 10360 | |||
| 10361 | } | ||
| 10362 | |||
| 10363 | |||
| 10364 | } | ||
| 10365 | break; | ||
| 10366 | case 4 : | ||
| 10367 | // InternalSolverLanguage.g:3589:3: (enumLiteral_3= '<=' ) | ||
| 10368 | { | ||
| 10369 | // InternalSolverLanguage.g:3589:3: (enumLiteral_3= '<=' ) | ||
| 10370 | // InternalSolverLanguage.g:3590:4: enumLiteral_3= '<=' | ||
| 10371 | { | ||
| 10372 | enumLiteral_3=(Token)match(input,48,FOLLOW_2); if (state.failed) return current; | ||
| 10373 | if ( state.backtracking==0 ) { | ||
| 10374 | |||
| 10375 | current = grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 10376 | newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); | ||
| 10377 | |||
| 10378 | } | ||
| 10379 | |||
| 10380 | } | ||
| 10381 | |||
| 10382 | |||
| 10383 | } | ||
| 10384 | break; | ||
| 10385 | case 5 : | ||
| 10386 | // InternalSolverLanguage.g:3597:3: (enumLiteral_4= '>' ) | ||
| 10387 | { | ||
| 10388 | // InternalSolverLanguage.g:3597:3: (enumLiteral_4= '>' ) | ||
| 10389 | // InternalSolverLanguage.g:3598:4: enumLiteral_4= '>' | ||
| 10390 | { | ||
| 10391 | enumLiteral_4=(Token)match(input,54,FOLLOW_2); if (state.failed) return current; | ||
| 10392 | if ( state.backtracking==0 ) { | ||
| 10393 | |||
| 10394 | current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
| 10395 | newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); | ||
| 10396 | |||
| 10397 | } | ||
| 10398 | |||
| 10399 | } | ||
| 10400 | |||
| 10401 | |||
| 10402 | } | ||
| 10403 | break; | ||
| 10404 | case 6 : | ||
| 10405 | // InternalSolverLanguage.g:3605:3: (enumLiteral_5= '>=' ) | ||
| 10406 | { | ||
| 10407 | // InternalSolverLanguage.g:3605:3: (enumLiteral_5= '>=' ) | ||
| 10408 | // InternalSolverLanguage.g:3606:4: enumLiteral_5= '>=' | ||
| 10409 | { | ||
| 10410 | enumLiteral_5=(Token)match(input,49,FOLLOW_2); if (state.failed) return current; | ||
| 10411 | if ( state.backtracking==0 ) { | ||
| 10412 | |||
| 10413 | current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 10414 | newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); | ||
| 10415 | |||
| 10416 | } | ||
| 10417 | |||
| 10418 | } | ||
| 10419 | |||
| 10420 | |||
| 10421 | } | ||
| 10422 | break; | ||
| 10423 | case 7 : | ||
| 10424 | // InternalSolverLanguage.g:3613:3: (enumLiteral_6= 'in' ) | ||
| 10425 | { | ||
| 10426 | // InternalSolverLanguage.g:3613:3: (enumLiteral_6= 'in' ) | ||
| 10427 | // InternalSolverLanguage.g:3614:4: enumLiteral_6= 'in' | ||
| 10428 | { | ||
| 10429 | enumLiteral_6=(Token)match(input,55,FOLLOW_2); if (state.failed) return current; | ||
| 10430 | if ( state.backtracking==0 ) { | ||
| 10431 | |||
| 10432 | current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance(); | ||
| 10433 | newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); | ||
| 10434 | |||
| 10435 | } | ||
| 6827 | 10436 | ||
| 6828 | } | 10437 | } |
| 6829 | 10438 | ||
| @@ -6833,46 +10442,109 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6833 | 10442 | ||
| 6834 | } | 10443 | } |
| 6835 | 10444 | ||
| 6836 | // InternalSolverLanguage.g:2399:3: ( (lv_target_7_0= ruleSymbol ) ) | ||
| 6837 | // InternalSolverLanguage.g:2400:4: (lv_target_7_0= ruleSymbol ) | ||
| 6838 | { | ||
| 6839 | // InternalSolverLanguage.g:2400:4: (lv_target_7_0= ruleSymbol ) | ||
| 6840 | // InternalSolverLanguage.g:2401:5: lv_target_7_0= ruleSymbol | ||
| 6841 | { | ||
| 6842 | 10445 | ||
| 6843 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); | 10446 | } |
| 6844 | |||
| 6845 | pushFollow(FOLLOW_2); | ||
| 6846 | lv_target_7_0=ruleSymbol(); | ||
| 6847 | 10447 | ||
| 6848 | state._fsp--; | 10448 | if ( state.backtracking==0 ) { |
| 6849 | 10449 | ||
| 10450 | leaveRule(); | ||
| 6850 | 10451 | ||
| 6851 | if (current==null) { | 10452 | } |
| 6852 | current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | 10453 | } |
| 6853 | } | ||
| 6854 | set( | ||
| 6855 | current, | ||
| 6856 | "target", | ||
| 6857 | lv_target_7_0, | ||
| 6858 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 6859 | afterParserOrEnumRuleCall(); | ||
| 6860 | |||
| 6861 | 10454 | ||
| 10455 | catch (RecognitionException re) { | ||
| 10456 | recover(input,re); | ||
| 10457 | appendSkippedTokens(); | ||
| 6862 | } | 10458 | } |
| 10459 | finally { | ||
| 10460 | } | ||
| 10461 | return current; | ||
| 10462 | } | ||
| 10463 | // $ANTLR end "ruleComparisonOperator" | ||
| 10464 | |||
| 6863 | 10465 | ||
| 10466 | // $ANTLR start "ruleAdditiveBinaryOperator" | ||
| 10467 | // InternalSolverLanguage.g:3624:1: ruleAdditiveBinaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= '+' ) | (enumLiteral_1= '-' ) ) ; | ||
| 10468 | public final Enumerator ruleAdditiveBinaryOperator() throws RecognitionException { | ||
| 10469 | Enumerator current = null; | ||
| 10470 | |||
| 10471 | Token enumLiteral_0=null; | ||
| 10472 | Token enumLiteral_1=null; | ||
| 10473 | |||
| 10474 | |||
| 10475 | enterRule(); | ||
| 10476 | |||
| 10477 | try { | ||
| 10478 | // InternalSolverLanguage.g:3630:2: ( ( (enumLiteral_0= '+' ) | (enumLiteral_1= '-' ) ) ) | ||
| 10479 | // InternalSolverLanguage.g:3631:2: ( (enumLiteral_0= '+' ) | (enumLiteral_1= '-' ) ) | ||
| 10480 | { | ||
| 10481 | // InternalSolverLanguage.g:3631:2: ( (enumLiteral_0= '+' ) | (enumLiteral_1= '-' ) ) | ||
| 10482 | int alt47=2; | ||
| 10483 | int LA47_0 = input.LA(1); | ||
| 10484 | |||
| 10485 | if ( (LA47_0==56) ) { | ||
| 10486 | alt47=1; | ||
| 10487 | } | ||
| 10488 | else if ( (LA47_0==57) ) { | ||
| 10489 | alt47=2; | ||
| 10490 | } | ||
| 10491 | else { | ||
| 10492 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 10493 | NoViableAltException nvae = | ||
| 10494 | new NoViableAltException("", 47, 0, input); | ||
| 6864 | 10495 | ||
| 10496 | throw nvae; | ||
| 6865 | } | 10497 | } |
| 10498 | switch (alt47) { | ||
| 10499 | case 1 : | ||
| 10500 | // InternalSolverLanguage.g:3632:3: (enumLiteral_0= '+' ) | ||
| 10501 | { | ||
| 10502 | // InternalSolverLanguage.g:3632:3: (enumLiteral_0= '+' ) | ||
| 10503 | // InternalSolverLanguage.g:3633:4: enumLiteral_0= '+' | ||
| 10504 | { | ||
| 10505 | enumLiteral_0=(Token)match(input,56,FOLLOW_2); if (state.failed) return current; | ||
| 10506 | if ( state.backtracking==0 ) { | ||
| 10507 | |||
| 10508 | current = grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 10509 | newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); | ||
| 10510 | |||
| 10511 | } | ||
| 10512 | |||
| 10513 | } | ||
| 6866 | 10514 | ||
| 6867 | 10515 | ||
| 10516 | } | ||
| 10517 | break; | ||
| 10518 | case 2 : | ||
| 10519 | // InternalSolverLanguage.g:3640:3: (enumLiteral_1= '-' ) | ||
| 10520 | { | ||
| 10521 | // InternalSolverLanguage.g:3640:3: (enumLiteral_1= '-' ) | ||
| 10522 | // InternalSolverLanguage.g:3641:4: enumLiteral_1= '-' | ||
| 10523 | { | ||
| 10524 | enumLiteral_1=(Token)match(input,57,FOLLOW_2); if (state.failed) return current; | ||
| 10525 | if ( state.backtracking==0 ) { | ||
| 10526 | |||
| 10527 | current = grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 10528 | newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); | ||
| 10529 | |||
| 10530 | } | ||
| 10531 | |||
| 10532 | } | ||
| 10533 | |||
| 10534 | |||
| 10535 | } | ||
| 10536 | break; | ||
| 10537 | |||
| 6868 | } | 10538 | } |
| 6869 | 10539 | ||
| 6870 | 10540 | ||
| 6871 | } | 10541 | } |
| 6872 | 10542 | ||
| 10543 | if ( state.backtracking==0 ) { | ||
| 6873 | 10544 | ||
| 6874 | leaveRule(); | 10545 | leaveRule(); |
| 6875 | 10546 | ||
| 10547 | } | ||
| 6876 | } | 10548 | } |
| 6877 | 10549 | ||
| 6878 | catch (RecognitionException re) { | 10550 | catch (RecognitionException re) { |
| @@ -6883,32 +10555,91 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6883 | } | 10555 | } |
| 6884 | return current; | 10556 | return current; |
| 6885 | } | 10557 | } |
| 6886 | // $ANTLR end "ruleGlobalRelationInterpretation" | 10558 | // $ANTLR end "ruleAdditiveBinaryOperator" |
| 6887 | 10559 | ||
| 6888 | 10560 | ||
| 6889 | // $ANTLR start "entryRuleMultiplicityDefinition" | 10561 | // $ANTLR start "ruleMultiplicativeBinaryOperator" |
| 6890 | // InternalSolverLanguage.g:2422:1: entryRuleMultiplicityDefinition returns [EObject current=null] : iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF ; | 10562 | // InternalSolverLanguage.g:3651:1: ruleMultiplicativeBinaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= '*' ) | (enumLiteral_1= '/' ) ) ; |
| 6891 | public final EObject entryRuleMultiplicityDefinition() throws RecognitionException { | 10563 | public final Enumerator ruleMultiplicativeBinaryOperator() throws RecognitionException { |
| 6892 | EObject current = null; | 10564 | Enumerator current = null; |
| 10565 | |||
| 10566 | Token enumLiteral_0=null; | ||
| 10567 | Token enumLiteral_1=null; | ||
| 6893 | 10568 | ||
| 6894 | EObject iv_ruleMultiplicityDefinition = null; | ||
| 6895 | 10569 | ||
| 10570 | enterRule(); | ||
| 6896 | 10571 | ||
| 6897 | try { | 10572 | try { |
| 6898 | // InternalSolverLanguage.g:2422:63: (iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF ) | 10573 | // InternalSolverLanguage.g:3657:2: ( ( (enumLiteral_0= '*' ) | (enumLiteral_1= '/' ) ) ) |
| 6899 | // InternalSolverLanguage.g:2423:2: iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF | 10574 | // InternalSolverLanguage.g:3658:2: ( (enumLiteral_0= '*' ) | (enumLiteral_1= '/' ) ) |
| 6900 | { | 10575 | { |
| 6901 | newCompositeNode(grammarAccess.getMultiplicityDefinitionRule()); | 10576 | // InternalSolverLanguage.g:3658:2: ( (enumLiteral_0= '*' ) | (enumLiteral_1= '/' ) ) |
| 6902 | pushFollow(FOLLOW_1); | 10577 | int alt48=2; |
| 6903 | iv_ruleMultiplicityDefinition=ruleMultiplicityDefinition(); | 10578 | int LA48_0 = input.LA(1); |
| 6904 | 10579 | ||
| 6905 | state._fsp--; | 10580 | if ( (LA48_0==35) ) { |
| 10581 | alt48=1; | ||
| 10582 | } | ||
| 10583 | else if ( (LA48_0==58) ) { | ||
| 10584 | alt48=2; | ||
| 10585 | } | ||
| 10586 | else { | ||
| 10587 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 10588 | NoViableAltException nvae = | ||
| 10589 | new NoViableAltException("", 48, 0, input); | ||
| 10590 | |||
| 10591 | throw nvae; | ||
| 10592 | } | ||
| 10593 | switch (alt48) { | ||
| 10594 | case 1 : | ||
| 10595 | // InternalSolverLanguage.g:3659:3: (enumLiteral_0= '*' ) | ||
| 10596 | { | ||
| 10597 | // InternalSolverLanguage.g:3659:3: (enumLiteral_0= '*' ) | ||
| 10598 | // InternalSolverLanguage.g:3660:4: enumLiteral_0= '*' | ||
| 10599 | { | ||
| 10600 | enumLiteral_0=(Token)match(input,35,FOLLOW_2); if (state.failed) return current; | ||
| 10601 | if ( state.backtracking==0 ) { | ||
| 10602 | |||
| 10603 | current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 10604 | newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); | ||
| 10605 | |||
| 10606 | } | ||
| 10607 | |||
| 10608 | } | ||
| 10609 | |||
| 10610 | |||
| 10611 | } | ||
| 10612 | break; | ||
| 10613 | case 2 : | ||
| 10614 | // InternalSolverLanguage.g:3667:3: (enumLiteral_1= '/' ) | ||
| 10615 | { | ||
| 10616 | // InternalSolverLanguage.g:3667:3: (enumLiteral_1= '/' ) | ||
| 10617 | // InternalSolverLanguage.g:3668:4: enumLiteral_1= '/' | ||
| 10618 | { | ||
| 10619 | enumLiteral_1=(Token)match(input,58,FOLLOW_2); if (state.failed) return current; | ||
| 10620 | if ( state.backtracking==0 ) { | ||
| 10621 | |||
| 10622 | current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 10623 | newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); | ||
| 10624 | |||
| 10625 | } | ||
| 10626 | |||
| 10627 | } | ||
| 10628 | |||
| 10629 | |||
| 10630 | } | ||
| 10631 | break; | ||
| 10632 | |||
| 10633 | } | ||
| 6906 | 10634 | ||
| 6907 | current =iv_ruleMultiplicityDefinition; | ||
| 6908 | match(input,EOF,FOLLOW_2); | ||
| 6909 | 10635 | ||
| 6910 | } | 10636 | } |
| 6911 | 10637 | ||
| 10638 | if ( state.backtracking==0 ) { | ||
| 10639 | |||
| 10640 | leaveRule(); | ||
| 10641 | |||
| 10642 | } | ||
| 6912 | } | 10643 | } |
| 6913 | 10644 | ||
| 6914 | catch (RecognitionException re) { | 10645 | catch (RecognitionException re) { |
| @@ -6919,102 +10650,517 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6919 | } | 10650 | } |
| 6920 | return current; | 10651 | return current; |
| 6921 | } | 10652 | } |
| 6922 | // $ANTLR end "entryRuleMultiplicityDefinition" | 10653 | // $ANTLR end "ruleMultiplicativeBinaryOperator" |
| 6923 | 10654 | ||
| 6924 | 10655 | ||
| 6925 | // $ANTLR start "ruleMultiplicityDefinition" | 10656 | // $ANTLR start "ruleExponentialOp" |
| 6926 | // InternalSolverLanguage.g:2429:1: ruleMultiplicityDefinition returns [EObject current=null] : ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) ; | 10657 | // InternalSolverLanguage.g:3678:1: ruleExponentialOp returns [Enumerator current=null] : (enumLiteral_0= '^' ) ; |
| 6927 | public final EObject ruleMultiplicityDefinition() throws RecognitionException { | 10658 | public final Enumerator ruleExponentialOp() throws RecognitionException { |
| 6928 | EObject current = null; | 10659 | Enumerator current = null; |
| 6929 | 10660 | ||
| 6930 | Token lv_lower_0_0=null; | 10661 | Token enumLiteral_0=null; |
| 6931 | Token otherlv_1=null; | ||
| 6932 | Token lv_upper_2_0=null; | ||
| 6933 | Token lv_unlimitedUpper_3_0=null; | ||
| 6934 | 10662 | ||
| 6935 | 10663 | ||
| 6936 | enterRule(); | 10664 | enterRule(); |
| 6937 | 10665 | ||
| 6938 | try { | 10666 | try { |
| 6939 | // InternalSolverLanguage.g:2435:2: ( ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) ) | 10667 | // InternalSolverLanguage.g:3684:2: ( (enumLiteral_0= '^' ) ) |
| 6940 | // InternalSolverLanguage.g:2436:2: ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) | 10668 | // InternalSolverLanguage.g:3685:2: (enumLiteral_0= '^' ) |
| 6941 | { | ||
| 6942 | // InternalSolverLanguage.g:2436:2: ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) | ||
| 6943 | // InternalSolverLanguage.g:2437:3: ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) | ||
| 6944 | { | 10669 | { |
| 6945 | // InternalSolverLanguage.g:2437:3: ( (lv_lower_0_0= RULE_INT ) ) | 10670 | // InternalSolverLanguage.g:3685:2: (enumLiteral_0= '^' ) |
| 6946 | // InternalSolverLanguage.g:2438:4: (lv_lower_0_0= RULE_INT ) | 10671 | // InternalSolverLanguage.g:3686:3: enumLiteral_0= '^' |
| 6947 | { | 10672 | { |
| 6948 | // InternalSolverLanguage.g:2438:4: (lv_lower_0_0= RULE_INT ) | 10673 | enumLiteral_0=(Token)match(input,59,FOLLOW_2); if (state.failed) return current; |
| 6949 | // InternalSolverLanguage.g:2439:5: lv_lower_0_0= RULE_INT | 10674 | if ( state.backtracking==0 ) { |
| 10675 | |||
| 10676 | current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance(); | ||
| 10677 | newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); | ||
| 10678 | |||
| 10679 | } | ||
| 10680 | |||
| 10681 | } | ||
| 10682 | |||
| 10683 | |||
| 10684 | } | ||
| 10685 | |||
| 10686 | if ( state.backtracking==0 ) { | ||
| 10687 | |||
| 10688 | leaveRule(); | ||
| 10689 | |||
| 10690 | } | ||
| 10691 | } | ||
| 10692 | |||
| 10693 | catch (RecognitionException re) { | ||
| 10694 | recover(input,re); | ||
| 10695 | appendSkippedTokens(); | ||
| 10696 | } | ||
| 10697 | finally { | ||
| 10698 | } | ||
| 10699 | return current; | ||
| 10700 | } | ||
| 10701 | // $ANTLR end "ruleExponentialOp" | ||
| 10702 | |||
| 10703 | |||
| 10704 | // $ANTLR start "ruleUnaryOp" | ||
| 10705 | // InternalSolverLanguage.g:3695:1: ruleUnaryOp returns [Enumerator current=null] : ( (enumLiteral_0= '!' ) | (enumLiteral_1= '+' ) | (enumLiteral_2= '-' ) | (enumLiteral_3= 'may' ) | (enumLiteral_4= 'must' ) | (enumLiteral_5= 'current' ) ) ; | ||
| 10706 | public final Enumerator ruleUnaryOp() throws RecognitionException { | ||
| 10707 | Enumerator current = null; | ||
| 10708 | |||
| 10709 | Token enumLiteral_0=null; | ||
| 10710 | Token enumLiteral_1=null; | ||
| 10711 | Token enumLiteral_2=null; | ||
| 10712 | Token enumLiteral_3=null; | ||
| 10713 | Token enumLiteral_4=null; | ||
| 10714 | Token enumLiteral_5=null; | ||
| 10715 | |||
| 10716 | |||
| 10717 | enterRule(); | ||
| 10718 | |||
| 10719 | try { | ||
| 10720 | // InternalSolverLanguage.g:3701:2: ( ( (enumLiteral_0= '!' ) | (enumLiteral_1= '+' ) | (enumLiteral_2= '-' ) | (enumLiteral_3= 'may' ) | (enumLiteral_4= 'must' ) | (enumLiteral_5= 'current' ) ) ) | ||
| 10721 | // InternalSolverLanguage.g:3702:2: ( (enumLiteral_0= '!' ) | (enumLiteral_1= '+' ) | (enumLiteral_2= '-' ) | (enumLiteral_3= 'may' ) | (enumLiteral_4= 'must' ) | (enumLiteral_5= 'current' ) ) | ||
| 6950 | { | 10722 | { |
| 6951 | lv_lower_0_0=(Token)match(input,RULE_INT,FOLLOW_35); | 10723 | // InternalSolverLanguage.g:3702:2: ( (enumLiteral_0= '!' ) | (enumLiteral_1= '+' ) | (enumLiteral_2= '-' ) | (enumLiteral_3= 'may' ) | (enumLiteral_4= 'must' ) | (enumLiteral_5= 'current' ) ) |
| 10724 | int alt49=6; | ||
| 10725 | switch ( input.LA(1) ) { | ||
| 10726 | case 60: | ||
| 10727 | { | ||
| 10728 | alt49=1; | ||
| 10729 | } | ||
| 10730 | break; | ||
| 10731 | case 56: | ||
| 10732 | { | ||
| 10733 | alt49=2; | ||
| 10734 | } | ||
| 10735 | break; | ||
| 10736 | case 57: | ||
| 10737 | { | ||
| 10738 | alt49=3; | ||
| 10739 | } | ||
| 10740 | break; | ||
| 10741 | case 61: | ||
| 10742 | { | ||
| 10743 | alt49=4; | ||
| 10744 | } | ||
| 10745 | break; | ||
| 10746 | case 62: | ||
| 10747 | { | ||
| 10748 | alt49=5; | ||
| 10749 | } | ||
| 10750 | break; | ||
| 10751 | case 63: | ||
| 10752 | { | ||
| 10753 | alt49=6; | ||
| 10754 | } | ||
| 10755 | break; | ||
| 10756 | default: | ||
| 10757 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 10758 | NoViableAltException nvae = | ||
| 10759 | new NoViableAltException("", 49, 0, input); | ||
| 10760 | |||
| 10761 | throw nvae; | ||
| 10762 | } | ||
| 10763 | |||
| 10764 | switch (alt49) { | ||
| 10765 | case 1 : | ||
| 10766 | // InternalSolverLanguage.g:3703:3: (enumLiteral_0= '!' ) | ||
| 10767 | { | ||
| 10768 | // InternalSolverLanguage.g:3703:3: (enumLiteral_0= '!' ) | ||
| 10769 | // InternalSolverLanguage.g:3704:4: enumLiteral_0= '!' | ||
| 10770 | { | ||
| 10771 | enumLiteral_0=(Token)match(input,60,FOLLOW_2); if (state.failed) return current; | ||
| 10772 | if ( state.backtracking==0 ) { | ||
| 10773 | |||
| 10774 | current = grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 10775 | newLeafNode(enumLiteral_0, grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); | ||
| 10776 | |||
| 10777 | } | ||
| 10778 | |||
| 10779 | } | ||
| 10780 | |||
| 6952 | 10781 | ||
| 6953 | newLeafNode(lv_lower_0_0, grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); | 10782 | } |
| 6954 | 10783 | break; | |
| 10784 | case 2 : | ||
| 10785 | // InternalSolverLanguage.g:3711:3: (enumLiteral_1= '+' ) | ||
| 10786 | { | ||
| 10787 | // InternalSolverLanguage.g:3711:3: (enumLiteral_1= '+' ) | ||
| 10788 | // InternalSolverLanguage.g:3712:4: enumLiteral_1= '+' | ||
| 10789 | { | ||
| 10790 | enumLiteral_1=(Token)match(input,56,FOLLOW_2); if (state.failed) return current; | ||
| 10791 | if ( state.backtracking==0 ) { | ||
| 10792 | |||
| 10793 | current = grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 10794 | newLeafNode(enumLiteral_1, grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); | ||
| 10795 | |||
| 10796 | } | ||
| 6955 | 10797 | ||
| 6956 | if (current==null) { | 10798 | } |
| 6957 | current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | 10799 | |
| 6958 | } | 10800 | |
| 6959 | setWithLastConsumed( | 10801 | } |
| 6960 | current, | 10802 | break; |
| 6961 | "lower", | 10803 | case 3 : |
| 6962 | lv_lower_0_0, | 10804 | // InternalSolverLanguage.g:3719:3: (enumLiteral_2= '-' ) |
| 6963 | "org.eclipse.xtext.common.Terminals.INT"); | 10805 | { |
| 6964 | 10806 | // InternalSolverLanguage.g:3719:3: (enumLiteral_2= '-' ) | |
| 10807 | // InternalSolverLanguage.g:3720:4: enumLiteral_2= '-' | ||
| 10808 | { | ||
| 10809 | enumLiteral_2=(Token)match(input,57,FOLLOW_2); if (state.failed) return current; | ||
| 10810 | if ( state.backtracking==0 ) { | ||
| 10811 | |||
| 10812 | current = grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 10813 | newLeafNode(enumLiteral_2, grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); | ||
| 10814 | |||
| 10815 | } | ||
| 10816 | |||
| 10817 | } | ||
| 10818 | |||
| 10819 | |||
| 10820 | } | ||
| 10821 | break; | ||
| 10822 | case 4 : | ||
| 10823 | // InternalSolverLanguage.g:3727:3: (enumLiteral_3= 'may' ) | ||
| 10824 | { | ||
| 10825 | // InternalSolverLanguage.g:3727:3: (enumLiteral_3= 'may' ) | ||
| 10826 | // InternalSolverLanguage.g:3728:4: enumLiteral_3= 'may' | ||
| 10827 | { | ||
| 10828 | enumLiteral_3=(Token)match(input,61,FOLLOW_2); if (state.failed) return current; | ||
| 10829 | if ( state.backtracking==0 ) { | ||
| 10830 | |||
| 10831 | current = grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 10832 | newLeafNode(enumLiteral_3, grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); | ||
| 10833 | |||
| 10834 | } | ||
| 10835 | |||
| 10836 | } | ||
| 10837 | |||
| 10838 | |||
| 10839 | } | ||
| 10840 | break; | ||
| 10841 | case 5 : | ||
| 10842 | // InternalSolverLanguage.g:3735:3: (enumLiteral_4= 'must' ) | ||
| 10843 | { | ||
| 10844 | // InternalSolverLanguage.g:3735:3: (enumLiteral_4= 'must' ) | ||
| 10845 | // InternalSolverLanguage.g:3736:4: enumLiteral_4= 'must' | ||
| 10846 | { | ||
| 10847 | enumLiteral_4=(Token)match(input,62,FOLLOW_2); if (state.failed) return current; | ||
| 10848 | if ( state.backtracking==0 ) { | ||
| 10849 | |||
| 10850 | current = grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
| 10851 | newLeafNode(enumLiteral_4, grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); | ||
| 10852 | |||
| 10853 | } | ||
| 10854 | |||
| 10855 | } | ||
| 10856 | |||
| 10857 | |||
| 10858 | } | ||
| 10859 | break; | ||
| 10860 | case 6 : | ||
| 10861 | // InternalSolverLanguage.g:3743:3: (enumLiteral_5= 'current' ) | ||
| 10862 | { | ||
| 10863 | // InternalSolverLanguage.g:3743:3: (enumLiteral_5= 'current' ) | ||
| 10864 | // InternalSolverLanguage.g:3744:4: enumLiteral_5= 'current' | ||
| 10865 | { | ||
| 10866 | enumLiteral_5=(Token)match(input,63,FOLLOW_2); if (state.failed) return current; | ||
| 10867 | if ( state.backtracking==0 ) { | ||
| 10868 | |||
| 10869 | current = grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 10870 | newLeafNode(enumLiteral_5, grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); | ||
| 10871 | |||
| 10872 | } | ||
| 10873 | |||
| 10874 | } | ||
| 10875 | |||
| 10876 | |||
| 10877 | } | ||
| 10878 | break; | ||
| 6965 | 10879 | ||
| 6966 | } | 10880 | } |
| 6967 | 10881 | ||
| 6968 | 10882 | ||
| 6969 | } | 10883 | } |
| 6970 | 10884 | ||
| 6971 | otherlv_1=(Token)match(input,41,FOLLOW_36); | 10885 | if ( state.backtracking==0 ) { |
| 6972 | 10886 | ||
| 6973 | newLeafNode(otherlv_1, grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); | 10887 | leaveRule(); |
| 6974 | |||
| 6975 | // InternalSolverLanguage.g:2459:3: ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) | ||
| 6976 | int alt47=2; | ||
| 6977 | int LA47_0 = input.LA(1); | ||
| 6978 | 10888 | ||
| 6979 | if ( (LA47_0==RULE_INT) ) { | ||
| 6980 | alt47=1; | ||
| 6981 | } | 10889 | } |
| 6982 | else if ( (LA47_0==31) ) { | 10890 | } |
| 6983 | alt47=2; | 10891 | |
| 10892 | catch (RecognitionException re) { | ||
| 10893 | recover(input,re); | ||
| 10894 | appendSkippedTokens(); | ||
| 6984 | } | 10895 | } |
| 6985 | else { | 10896 | finally { |
| 10897 | } | ||
| 10898 | return current; | ||
| 10899 | } | ||
| 10900 | // $ANTLR end "ruleUnaryOp" | ||
| 10901 | |||
| 10902 | |||
| 10903 | // $ANTLR start "ruleAggregationOp" | ||
| 10904 | // InternalSolverLanguage.g:3754:1: ruleAggregationOp returns [Enumerator current=null] : ( (enumLiteral_0= 'only' ) | (enumLiteral_1= 'sum' ) | (enumLiteral_2= 'prod' ) | (enumLiteral_3= 'avg' ) | (enumLiteral_4= 'min' ) | (enumLiteral_5= 'max' ) ) ; | ||
| 10905 | public final Enumerator ruleAggregationOp() throws RecognitionException { | ||
| 10906 | Enumerator current = null; | ||
| 10907 | |||
| 10908 | Token enumLiteral_0=null; | ||
| 10909 | Token enumLiteral_1=null; | ||
| 10910 | Token enumLiteral_2=null; | ||
| 10911 | Token enumLiteral_3=null; | ||
| 10912 | Token enumLiteral_4=null; | ||
| 10913 | Token enumLiteral_5=null; | ||
| 10914 | |||
| 10915 | |||
| 10916 | enterRule(); | ||
| 10917 | |||
| 10918 | try { | ||
| 10919 | // InternalSolverLanguage.g:3760:2: ( ( (enumLiteral_0= 'only' ) | (enumLiteral_1= 'sum' ) | (enumLiteral_2= 'prod' ) | (enumLiteral_3= 'avg' ) | (enumLiteral_4= 'min' ) | (enumLiteral_5= 'max' ) ) ) | ||
| 10920 | // InternalSolverLanguage.g:3761:2: ( (enumLiteral_0= 'only' ) | (enumLiteral_1= 'sum' ) | (enumLiteral_2= 'prod' ) | (enumLiteral_3= 'avg' ) | (enumLiteral_4= 'min' ) | (enumLiteral_5= 'max' ) ) | ||
| 10921 | { | ||
| 10922 | // InternalSolverLanguage.g:3761:2: ( (enumLiteral_0= 'only' ) | (enumLiteral_1= 'sum' ) | (enumLiteral_2= 'prod' ) | (enumLiteral_3= 'avg' ) | (enumLiteral_4= 'min' ) | (enumLiteral_5= 'max' ) ) | ||
| 10923 | int alt50=6; | ||
| 10924 | switch ( input.LA(1) ) { | ||
| 10925 | case 64: | ||
| 10926 | { | ||
| 10927 | alt50=1; | ||
| 10928 | } | ||
| 10929 | break; | ||
| 10930 | case 65: | ||
| 10931 | { | ||
| 10932 | alt50=2; | ||
| 10933 | } | ||
| 10934 | break; | ||
| 10935 | case 66: | ||
| 10936 | { | ||
| 10937 | alt50=3; | ||
| 10938 | } | ||
| 10939 | break; | ||
| 10940 | case 67: | ||
| 10941 | { | ||
| 10942 | alt50=4; | ||
| 10943 | } | ||
| 10944 | break; | ||
| 10945 | case 68: | ||
| 10946 | { | ||
| 10947 | alt50=5; | ||
| 10948 | } | ||
| 10949 | break; | ||
| 10950 | case 69: | ||
| 10951 | { | ||
| 10952 | alt50=6; | ||
| 10953 | } | ||
| 10954 | break; | ||
| 10955 | default: | ||
| 10956 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 6986 | NoViableAltException nvae = | 10957 | NoViableAltException nvae = |
| 6987 | new NoViableAltException("", 47, 0, input); | 10958 | new NoViableAltException("", 50, 0, input); |
| 6988 | 10959 | ||
| 6989 | throw nvae; | 10960 | throw nvae; |
| 6990 | } | 10961 | } |
| 6991 | switch (alt47) { | 10962 | |
| 10963 | switch (alt50) { | ||
| 6992 | case 1 : | 10964 | case 1 : |
| 6993 | // InternalSolverLanguage.g:2460:4: ( (lv_upper_2_0= RULE_INT ) ) | 10965 | // InternalSolverLanguage.g:3762:3: (enumLiteral_0= 'only' ) |
| 10966 | { | ||
| 10967 | // InternalSolverLanguage.g:3762:3: (enumLiteral_0= 'only' ) | ||
| 10968 | // InternalSolverLanguage.g:3763:4: enumLiteral_0= 'only' | ||
| 10969 | { | ||
| 10970 | enumLiteral_0=(Token)match(input,64,FOLLOW_2); if (state.failed) return current; | ||
| 10971 | if ( state.backtracking==0 ) { | ||
| 10972 | |||
| 10973 | current = grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 10974 | newLeafNode(enumLiteral_0, grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); | ||
| 10975 | |||
| 10976 | } | ||
| 10977 | |||
| 10978 | } | ||
| 10979 | |||
| 10980 | |||
| 10981 | } | ||
| 10982 | break; | ||
| 10983 | case 2 : | ||
| 10984 | // InternalSolverLanguage.g:3770:3: (enumLiteral_1= 'sum' ) | ||
| 10985 | { | ||
| 10986 | // InternalSolverLanguage.g:3770:3: (enumLiteral_1= 'sum' ) | ||
| 10987 | // InternalSolverLanguage.g:3771:4: enumLiteral_1= 'sum' | ||
| 6994 | { | 10988 | { |
| 6995 | // InternalSolverLanguage.g:2460:4: ( (lv_upper_2_0= RULE_INT ) ) | 10989 | enumLiteral_1=(Token)match(input,65,FOLLOW_2); if (state.failed) return current; |
| 6996 | // InternalSolverLanguage.g:2461:5: (lv_upper_2_0= RULE_INT ) | 10990 | if ( state.backtracking==0 ) { |
| 10991 | |||
| 10992 | current = grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 10993 | newLeafNode(enumLiteral_1, grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); | ||
| 10994 | |||
| 10995 | } | ||
| 10996 | |||
| 10997 | } | ||
| 10998 | |||
| 10999 | |||
| 11000 | } | ||
| 11001 | break; | ||
| 11002 | case 3 : | ||
| 11003 | // InternalSolverLanguage.g:3778:3: (enumLiteral_2= 'prod' ) | ||
| 6997 | { | 11004 | { |
| 6998 | // InternalSolverLanguage.g:2461:5: (lv_upper_2_0= RULE_INT ) | 11005 | // InternalSolverLanguage.g:3778:3: (enumLiteral_2= 'prod' ) |
| 6999 | // InternalSolverLanguage.g:2462:6: lv_upper_2_0= RULE_INT | 11006 | // InternalSolverLanguage.g:3779:4: enumLiteral_2= 'prod' |
| 7000 | { | 11007 | { |
| 7001 | lv_upper_2_0=(Token)match(input,RULE_INT,FOLLOW_2); | 11008 | enumLiteral_2=(Token)match(input,66,FOLLOW_2); if (state.failed) return current; |
| 11009 | if ( state.backtracking==0 ) { | ||
| 11010 | |||
| 11011 | current = grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 11012 | newLeafNode(enumLiteral_2, grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); | ||
| 11013 | |||
| 11014 | } | ||
| 7002 | 11015 | ||
| 7003 | newLeafNode(lv_upper_2_0, grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); | 11016 | } |
| 7004 | |||
| 7005 | 11017 | ||
| 7006 | if (current==null) { | ||
| 7007 | current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 7008 | } | ||
| 7009 | setWithLastConsumed( | ||
| 7010 | current, | ||
| 7011 | "upper", | ||
| 7012 | lv_upper_2_0, | ||
| 7013 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 7014 | |||
| 7015 | 11018 | ||
| 7016 | } | 11019 | } |
| 11020 | break; | ||
| 11021 | case 4 : | ||
| 11022 | // InternalSolverLanguage.g:3786:3: (enumLiteral_3= 'avg' ) | ||
| 11023 | { | ||
| 11024 | // InternalSolverLanguage.g:3786:3: (enumLiteral_3= 'avg' ) | ||
| 11025 | // InternalSolverLanguage.g:3787:4: enumLiteral_3= 'avg' | ||
| 11026 | { | ||
| 11027 | enumLiteral_3=(Token)match(input,67,FOLLOW_2); if (state.failed) return current; | ||
| 11028 | if ( state.backtracking==0 ) { | ||
| 11029 | |||
| 11030 | current = grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 11031 | newLeafNode(enumLiteral_3, grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); | ||
| 11032 | |||
| 11033 | } | ||
| 11034 | |||
| 11035 | } | ||
| 11036 | |||
| 11037 | |||
| 11038 | } | ||
| 11039 | break; | ||
| 11040 | case 5 : | ||
| 11041 | // InternalSolverLanguage.g:3794:3: (enumLiteral_4= 'min' ) | ||
| 11042 | { | ||
| 11043 | // InternalSolverLanguage.g:3794:3: (enumLiteral_4= 'min' ) | ||
| 11044 | // InternalSolverLanguage.g:3795:4: enumLiteral_4= 'min' | ||
| 11045 | { | ||
| 11046 | enumLiteral_4=(Token)match(input,68,FOLLOW_2); if (state.failed) return current; | ||
| 11047 | if ( state.backtracking==0 ) { | ||
| 11048 | |||
| 11049 | current = grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
| 11050 | newLeafNode(enumLiteral_4, grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); | ||
| 11051 | |||
| 11052 | } | ||
| 11053 | |||
| 11054 | } | ||
| 11055 | |||
| 11056 | |||
| 11057 | } | ||
| 11058 | break; | ||
| 11059 | case 6 : | ||
| 11060 | // InternalSolverLanguage.g:3802:3: (enumLiteral_5= 'max' ) | ||
| 11061 | { | ||
| 11062 | // InternalSolverLanguage.g:3802:3: (enumLiteral_5= 'max' ) | ||
| 11063 | // InternalSolverLanguage.g:3803:4: enumLiteral_5= 'max' | ||
| 11064 | { | ||
| 11065 | enumLiteral_5=(Token)match(input,69,FOLLOW_2); if (state.failed) return current; | ||
| 11066 | if ( state.backtracking==0 ) { | ||
| 11067 | |||
| 11068 | current = grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 11069 | newLeafNode(enumLiteral_5, grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); | ||
| 11070 | |||
| 11071 | } | ||
| 11072 | |||
| 11073 | } | ||
| 11074 | |||
| 11075 | |||
| 11076 | } | ||
| 11077 | break; | ||
| 11078 | |||
| 11079 | } | ||
| 11080 | |||
| 11081 | |||
| 11082 | } | ||
| 11083 | |||
| 11084 | if ( state.backtracking==0 ) { | ||
| 11085 | |||
| 11086 | leaveRule(); | ||
| 11087 | |||
| 11088 | } | ||
| 11089 | } | ||
| 11090 | |||
| 11091 | catch (RecognitionException re) { | ||
| 11092 | recover(input,re); | ||
| 11093 | appendSkippedTokens(); | ||
| 11094 | } | ||
| 11095 | finally { | ||
| 11096 | } | ||
| 11097 | return current; | ||
| 11098 | } | ||
| 11099 | // $ANTLR end "ruleAggregationOp" | ||
| 11100 | |||
| 11101 | |||
| 11102 | // $ANTLR start "ruleLogicValue" | ||
| 11103 | // InternalSolverLanguage.g:3813:1: ruleLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) | (enumLiteral_3= 'error' ) ) ; | ||
| 11104 | public final Enumerator ruleLogicValue() throws RecognitionException { | ||
| 11105 | Enumerator current = null; | ||
| 11106 | |||
| 11107 | Token enumLiteral_0=null; | ||
| 11108 | Token enumLiteral_1=null; | ||
| 11109 | Token enumLiteral_2=null; | ||
| 11110 | Token enumLiteral_3=null; | ||
| 11111 | |||
| 11112 | |||
| 11113 | enterRule(); | ||
| 11114 | |||
| 11115 | try { | ||
| 11116 | // InternalSolverLanguage.g:3819:2: ( ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) | (enumLiteral_3= 'error' ) ) ) | ||
| 11117 | // InternalSolverLanguage.g:3820:2: ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) | (enumLiteral_3= 'error' ) ) | ||
| 11118 | { | ||
| 11119 | // InternalSolverLanguage.g:3820:2: ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) | (enumLiteral_3= 'error' ) ) | ||
| 11120 | int alt51=4; | ||
| 11121 | switch ( input.LA(1) ) { | ||
| 11122 | case 70: | ||
| 11123 | { | ||
| 11124 | alt51=1; | ||
| 11125 | } | ||
| 11126 | break; | ||
| 11127 | case 71: | ||
| 11128 | { | ||
| 11129 | alt51=2; | ||
| 11130 | } | ||
| 11131 | break; | ||
| 11132 | case 72: | ||
| 11133 | { | ||
| 11134 | alt51=3; | ||
| 11135 | } | ||
| 11136 | break; | ||
| 11137 | case 19: | ||
| 11138 | { | ||
| 11139 | alt51=4; | ||
| 11140 | } | ||
| 11141 | break; | ||
| 11142 | default: | ||
| 11143 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 11144 | NoViableAltException nvae = | ||
| 11145 | new NoViableAltException("", 51, 0, input); | ||
| 7017 | 11146 | ||
| 11147 | throw nvae; | ||
| 11148 | } | ||
| 11149 | |||
| 11150 | switch (alt51) { | ||
| 11151 | case 1 : | ||
| 11152 | // InternalSolverLanguage.g:3821:3: (enumLiteral_0= 'true' ) | ||
| 11153 | { | ||
| 11154 | // InternalSolverLanguage.g:3821:3: (enumLiteral_0= 'true' ) | ||
| 11155 | // InternalSolverLanguage.g:3822:4: enumLiteral_0= 'true' | ||
| 11156 | { | ||
| 11157 | enumLiteral_0=(Token)match(input,70,FOLLOW_2); if (state.failed) return current; | ||
| 11158 | if ( state.backtracking==0 ) { | ||
| 11159 | |||
| 11160 | current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 11161 | newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | ||
| 11162 | |||
| 11163 | } | ||
| 7018 | 11164 | ||
| 7019 | } | 11165 | } |
| 7020 | 11166 | ||
| @@ -7022,27 +11168,56 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 7022 | } | 11168 | } |
| 7023 | break; | 11169 | break; |
| 7024 | case 2 : | 11170 | case 2 : |
| 7025 | // InternalSolverLanguage.g:2479:4: ( (lv_unlimitedUpper_3_0= '*' ) ) | 11171 | // InternalSolverLanguage.g:3829:3: (enumLiteral_1= 'false' ) |
| 11172 | { | ||
| 11173 | // InternalSolverLanguage.g:3829:3: (enumLiteral_1= 'false' ) | ||
| 11174 | // InternalSolverLanguage.g:3830:4: enumLiteral_1= 'false' | ||
| 7026 | { | 11175 | { |
| 7027 | // InternalSolverLanguage.g:2479:4: ( (lv_unlimitedUpper_3_0= '*' ) ) | 11176 | enumLiteral_1=(Token)match(input,71,FOLLOW_2); if (state.failed) return current; |
| 7028 | // InternalSolverLanguage.g:2480:5: (lv_unlimitedUpper_3_0= '*' ) | 11177 | if ( state.backtracking==0 ) { |
| 11178 | |||
| 11179 | current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 11180 | newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | ||
| 11181 | |||
| 11182 | } | ||
| 11183 | |||
| 11184 | } | ||
| 11185 | |||
| 11186 | |||
| 11187 | } | ||
| 11188 | break; | ||
| 11189 | case 3 : | ||
| 11190 | // InternalSolverLanguage.g:3837:3: (enumLiteral_2= 'unknown' ) | ||
| 7029 | { | 11191 | { |
| 7030 | // InternalSolverLanguage.g:2480:5: (lv_unlimitedUpper_3_0= '*' ) | 11192 | // InternalSolverLanguage.g:3837:3: (enumLiteral_2= 'unknown' ) |
| 7031 | // InternalSolverLanguage.g:2481:6: lv_unlimitedUpper_3_0= '*' | 11193 | // InternalSolverLanguage.g:3838:4: enumLiteral_2= 'unknown' |
| 7032 | { | 11194 | { |
| 7033 | lv_unlimitedUpper_3_0=(Token)match(input,31,FOLLOW_2); | 11195 | enumLiteral_2=(Token)match(input,72,FOLLOW_2); if (state.failed) return current; |
| 11196 | if ( state.backtracking==0 ) { | ||
| 11197 | |||
| 11198 | current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 11199 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | ||
| 11200 | |||
| 11201 | } | ||
| 7034 | 11202 | ||
| 7035 | newLeafNode(lv_unlimitedUpper_3_0, grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); | 11203 | } |
| 7036 | |||
| 7037 | 11204 | ||
| 7038 | if (current==null) { | ||
| 7039 | current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 7040 | } | ||
| 7041 | setWithLastConsumed(current, "unlimitedUpper", true, "*"); | ||
| 7042 | |||
| 7043 | 11205 | ||
| 7044 | } | 11206 | } |
| 11207 | break; | ||
| 11208 | case 4 : | ||
| 11209 | // InternalSolverLanguage.g:3845:3: (enumLiteral_3= 'error' ) | ||
| 11210 | { | ||
| 11211 | // InternalSolverLanguage.g:3845:3: (enumLiteral_3= 'error' ) | ||
| 11212 | // InternalSolverLanguage.g:3846:4: enumLiteral_3= 'error' | ||
| 11213 | { | ||
| 11214 | enumLiteral_3=(Token)match(input,19,FOLLOW_2); if (state.failed) return current; | ||
| 11215 | if ( state.backtracking==0 ) { | ||
| 7045 | 11216 | ||
| 11217 | current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 11218 | newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); | ||
| 11219 | |||
| 11220 | } | ||
| 7046 | 11221 | ||
| 7047 | } | 11222 | } |
| 7048 | 11223 | ||
| @@ -7055,12 +11230,106 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 7055 | 11230 | ||
| 7056 | } | 11231 | } |
| 7057 | 11232 | ||
| 11233 | if ( state.backtracking==0 ) { | ||
| 11234 | |||
| 11235 | leaveRule(); | ||
| 7058 | 11236 | ||
| 7059 | } | 11237 | } |
| 11238 | } | ||
| 11239 | |||
| 11240 | catch (RecognitionException re) { | ||
| 11241 | recover(input,re); | ||
| 11242 | appendSkippedTokens(); | ||
| 11243 | } | ||
| 11244 | finally { | ||
| 11245 | } | ||
| 11246 | return current; | ||
| 11247 | } | ||
| 11248 | // $ANTLR end "ruleLogicValue" | ||
| 11249 | |||
| 11250 | |||
| 11251 | // $ANTLR start "ruleObjectiveKind" | ||
| 11252 | // InternalSolverLanguage.g:3856:1: ruleObjectiveKind returns [Enumerator current=null] : ( (enumLiteral_0= 'minimize' ) | (enumLiteral_1= 'maximize' ) ) ; | ||
| 11253 | public final Enumerator ruleObjectiveKind() throws RecognitionException { | ||
| 11254 | Enumerator current = null; | ||
| 7060 | 11255 | ||
| 11256 | Token enumLiteral_0=null; | ||
| 11257 | Token enumLiteral_1=null; | ||
| 7061 | 11258 | ||
| 7062 | leaveRule(); | ||
| 7063 | 11259 | ||
| 11260 | enterRule(); | ||
| 11261 | |||
| 11262 | try { | ||
| 11263 | // InternalSolverLanguage.g:3862:2: ( ( (enumLiteral_0= 'minimize' ) | (enumLiteral_1= 'maximize' ) ) ) | ||
| 11264 | // InternalSolverLanguage.g:3863:2: ( (enumLiteral_0= 'minimize' ) | (enumLiteral_1= 'maximize' ) ) | ||
| 11265 | { | ||
| 11266 | // InternalSolverLanguage.g:3863:2: ( (enumLiteral_0= 'minimize' ) | (enumLiteral_1= 'maximize' ) ) | ||
| 11267 | int alt52=2; | ||
| 11268 | int LA52_0 = input.LA(1); | ||
| 11269 | |||
| 11270 | if ( (LA52_0==73) ) { | ||
| 11271 | alt52=1; | ||
| 11272 | } | ||
| 11273 | else if ( (LA52_0==74) ) { | ||
| 11274 | alt52=2; | ||
| 11275 | } | ||
| 11276 | else { | ||
| 11277 | if (state.backtracking>0) {state.failed=true; return current;} | ||
| 11278 | NoViableAltException nvae = | ||
| 11279 | new NoViableAltException("", 52, 0, input); | ||
| 11280 | |||
| 11281 | throw nvae; | ||
| 11282 | } | ||
| 11283 | switch (alt52) { | ||
| 11284 | case 1 : | ||
| 11285 | // InternalSolverLanguage.g:3864:3: (enumLiteral_0= 'minimize' ) | ||
| 11286 | { | ||
| 11287 | // InternalSolverLanguage.g:3864:3: (enumLiteral_0= 'minimize' ) | ||
| 11288 | // InternalSolverLanguage.g:3865:4: enumLiteral_0= 'minimize' | ||
| 11289 | { | ||
| 11290 | enumLiteral_0=(Token)match(input,73,FOLLOW_2); if (state.failed) return current; | ||
| 11291 | if ( state.backtracking==0 ) { | ||
| 11292 | |||
| 11293 | current = grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 11294 | newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); | ||
| 11295 | |||
| 11296 | } | ||
| 11297 | |||
| 11298 | } | ||
| 11299 | |||
| 11300 | |||
| 11301 | } | ||
| 11302 | break; | ||
| 11303 | case 2 : | ||
| 11304 | // InternalSolverLanguage.g:3872:3: (enumLiteral_1= 'maximize' ) | ||
| 11305 | { | ||
| 11306 | // InternalSolverLanguage.g:3872:3: (enumLiteral_1= 'maximize' ) | ||
| 11307 | // InternalSolverLanguage.g:3873:4: enumLiteral_1= 'maximize' | ||
| 11308 | { | ||
| 11309 | enumLiteral_1=(Token)match(input,74,FOLLOW_2); if (state.failed) return current; | ||
| 11310 | if ( state.backtracking==0 ) { | ||
| 11311 | |||
| 11312 | current = grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 11313 | newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); | ||
| 11314 | |||
| 11315 | } | ||
| 11316 | |||
| 11317 | } | ||
| 11318 | |||
| 11319 | |||
| 11320 | } | ||
| 11321 | break; | ||
| 11322 | |||
| 11323 | } | ||
| 11324 | |||
| 11325 | |||
| 11326 | } | ||
| 11327 | |||
| 11328 | if ( state.backtracking==0 ) { | ||
| 11329 | |||
| 11330 | leaveRule(); | ||
| 11331 | |||
| 11332 | } | ||
| 7064 | } | 11333 | } |
| 7065 | 11334 | ||
| 7066 | catch (RecognitionException re) { | 11335 | catch (RecognitionException re) { |
| @@ -7071,27 +11340,33 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 7071 | } | 11340 | } |
| 7072 | return current; | 11341 | return current; |
| 7073 | } | 11342 | } |
| 7074 | // $ANTLR end "ruleMultiplicityDefinition" | 11343 | // $ANTLR end "ruleObjectiveKind" |
| 7075 | 11344 | ||
| 7076 | // Delegated rules | 11345 | // Delegated rules |
| 7077 | 11346 | ||
| 7078 | 11347 | ||
| 7079 | protected DFA2 dfa2 = new DFA2(this); | 11348 | protected DFA2 dfa2 = new DFA2(this); |
| 7080 | static final String dfa_1s = "\11\uffff"; | 11349 | protected DFA25 dfa25 = new DFA25(this); |
| 7081 | static final String dfa_2s = "\1\5\1\21\2\uffff\1\4\1\22\1\24\1\4\1\22"; | 11350 | protected DFA36 dfa36 = new DFA36(this); |
| 7082 | static final String dfa_3s = "\1\50\1\34\2\uffff\1\37\1\24\1\34\1\37\1\24"; | 11351 | static final String dfa_1s = "\15\uffff"; |
| 7083 | static final String dfa_4s = "\2\uffff\1\1\1\2\5\uffff"; | 11352 | static final String dfa_2s = "\1\7\1\uffff\1\4\2\uffff\1\10\7\uffff"; |
| 7084 | static final String dfa_5s = "\11\uffff}>"; | 11353 | static final String dfa_3s = "\1\112\1\uffff\1\73\2\uffff\1\63\7\uffff"; |
| 11354 | static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\2\1\4\1\uffff\1\6\1\10\1\11\1\12\1\3\1\7\1\5"; | ||
| 11355 | static final String dfa_5s = "\15\uffff}>"; | ||
| 7085 | static final String[] dfa_6s = { | 11356 | static final String[] dfa_6s = { |
| 7086 | "\1\1\12\uffff\1\3\4\uffff\6\2\5\uffff\3\2\3\uffff\3\2", | 11357 | "\4\1\7\uffff\1\3\1\2\1\4\1\5\1\uffff\1\1\5\uffff\1\1\3\uffff\1\1\2\uffff\1\1\2\uffff\2\1\2\7\3\uffff\1\10\3\uffff\2\6\4\uffff\2\1\2\uffff\15\1\2\11", |
| 7087 | "\1\4\2\uffff\1\2\7\uffff\1\3", | 11358 | "", |
| 11359 | "\1\1\3\uffff\1\3\1\uffff\1\3\4\uffff\3\1\1\3\7\uffff\3\1\4\uffff\1\12\1\uffff\1\1\13\uffff\3\1\2\uffff\10\1", | ||
| 11360 | "", | ||
| 7088 | "", | 11361 | "", |
| 11362 | "\1\14\1\uffff\1\14\47\uffff\2\13", | ||
| 7089 | "", | 11363 | "", |
| 7090 | "\1\2\1\5\1\2\4\uffff\1\2\1\uffff\2\2\4\uffff\1\6\1\2\6\uffff\1\2\3\uffff\1\2", | 11364 | "", |
| 7091 | "\1\7\1\6\1\3", | 11365 | "", |
| 7092 | "\1\2\7\uffff\1\3", | 11366 | "", |
| 7093 | "\1\2\1\10\1\2\4\uffff\1\2\1\uffff\2\2\5\uffff\1\2\6\uffff\1\2\3\uffff\1\2", | 11367 | "", |
| 7094 | "\1\7\1\6\1\3" | 11368 | "", |
| 11369 | "" | ||
| 7095 | }; | 11370 | }; |
| 7096 | 11371 | ||
| 7097 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); | 11372 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); |
| @@ -7115,46 +11390,156 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 7115 | this.transition = dfa_6; | 11390 | this.transition = dfa_6; |
| 7116 | } | 11391 | } |
| 7117 | public String getDescription() { | 11392 | public String getDescription() { |
| 7118 | return "114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate )"; | 11393 | return "116:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition )"; |
| 11394 | } | ||
| 11395 | } | ||
| 11396 | static final String dfa_7s = "\12\uffff"; | ||
| 11397 | static final String dfa_8s = "\1\uffff\2\3\4\uffff\1\11\1\3\1\uffff"; | ||
| 11398 | static final String dfa_9s = "\1\7\2\10\2\uffff\1\10\1\uffff\1\7\1\10\1\uffff"; | ||
| 11399 | static final String dfa_10s = "\1\110\2\73\2\uffff\1\10\1\uffff\1\110\1\73\1\uffff"; | ||
| 11400 | static final String dfa_11s = "\3\uffff\1\1\1\2\1\uffff\1\3\2\uffff\1\4"; | ||
| 11401 | static final String dfa_12s = "\12\uffff}>"; | ||
| 11402 | static final String[] dfa_13s = { | ||
| 11403 | "\1\3\1\1\1\3\1\2\10\uffff\1\3\11\uffff\1\3\3\uffff\1\3\1\uffff\1\4\1\3\2\uffff\2\3\17\uffff\2\3\2\uffff\15\3", | ||
| 11404 | "\1\6\1\uffff\1\6\13\uffff\1\5\5\uffff\1\3\4\uffff\2\3\1\7\13\uffff\3\3\2\uffff\10\3", | ||
| 11405 | "\1\6\1\uffff\1\6\21\uffff\1\3\4\uffff\2\3\1\7\13\uffff\3\3\2\uffff\10\3", | ||
| 11406 | "", | ||
| 11407 | "", | ||
| 11408 | "\1\10", | ||
| 11409 | "", | ||
| 11410 | "\4\3\10\uffff\1\3\10\uffff\1\11\1\3\3\uffff\1\3\1\11\1\uffff\1\3\2\uffff\2\3\17\uffff\2\3\2\uffff\15\3", | ||
| 11411 | "\1\6\1\uffff\1\6\13\uffff\1\5\5\uffff\1\3\4\uffff\2\3\1\7\13\uffff\3\3\2\uffff\10\3", | ||
| 11412 | "" | ||
| 11413 | }; | ||
| 11414 | |||
| 11415 | static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); | ||
| 11416 | static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s); | ||
| 11417 | static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); | ||
| 11418 | static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s); | ||
| 11419 | static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); | ||
| 11420 | static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); | ||
| 11421 | static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s); | ||
| 11422 | |||
| 11423 | class DFA25 extends DFA { | ||
| 11424 | |||
| 11425 | public DFA25(BaseRecognizer recognizer) { | ||
| 11426 | this.recognizer = recognizer; | ||
| 11427 | this.decisionNumber = 25; | ||
| 11428 | this.eot = dfa_7; | ||
| 11429 | this.eof = dfa_8; | ||
| 11430 | this.min = dfa_9; | ||
| 11431 | this.max = dfa_10; | ||
| 11432 | this.accept = dfa_11; | ||
| 11433 | this.special = dfa_12; | ||
| 11434 | this.transition = dfa_13; | ||
| 11435 | } | ||
| 11436 | public String getDescription() { | ||
| 11437 | return "1998:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument )"; | ||
| 11438 | } | ||
| 11439 | } | ||
| 11440 | static final String dfa_14s = "\17\uffff"; | ||
| 11441 | static final String dfa_15s = "\15\uffff\1\11\1\uffff"; | ||
| 11442 | static final String dfa_16s = "\1\56\1\10\1\60\1\26\1\57\1\10\1\uffff\1\10\2\uffff\3\26\1\4\1\26"; | ||
| 11443 | static final String dfa_17s = "\1\56\1\12\3\61\1\12\1\uffff\1\10\2\uffff\2\60\1\61\1\10\1\60"; | ||
| 11444 | static final String dfa_18s = "\6\uffff\1\2\1\uffff\1\1\1\3\5\uffff"; | ||
| 11445 | static final String dfa_19s = "\17\uffff}>"; | ||
| 11446 | static final String[] dfa_20s = { | ||
| 11447 | "\1\1", | ||
| 11448 | "\1\3\1\2\1\4", | ||
| 11449 | "\1\5\1\6", | ||
| 11450 | "\1\7\30\uffff\1\10\1\6\1\11", | ||
| 11451 | "\1\10\1\6\1\11", | ||
| 11452 | "\1\12\1\uffff\1\13", | ||
| 11453 | "", | ||
| 11454 | "\1\14", | ||
| 11455 | "", | ||
| 11456 | "", | ||
| 11457 | "\1\15\31\uffff\1\6", | ||
| 11458 | "\1\11\31\uffff\1\6", | ||
| 11459 | "\1\7\30\uffff\1\10\1\6\1\11", | ||
| 11460 | "\1\11\3\uffff\1\16", | ||
| 11461 | "\1\15\31\uffff\1\6" | ||
| 11462 | }; | ||
| 11463 | |||
| 11464 | static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); | ||
| 11465 | static final short[] dfa_15 = DFA.unpackEncodedString(dfa_15s); | ||
| 11466 | static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); | ||
| 11467 | static final char[] dfa_17 = DFA.unpackEncodedStringToUnsignedChars(dfa_17s); | ||
| 11468 | static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s); | ||
| 11469 | static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s); | ||
| 11470 | static final short[][] dfa_20 = unpackEncodedStringArray(dfa_20s); | ||
| 11471 | |||
| 11472 | class DFA36 extends DFA { | ||
| 11473 | |||
| 11474 | public DFA36(BaseRecognizer recognizer) { | ||
| 11475 | this.recognizer = recognizer; | ||
| 11476 | this.decisionNumber = 36; | ||
| 11477 | this.eot = dfa_14; | ||
| 11478 | this.eof = dfa_15; | ||
| 11479 | this.min = dfa_16; | ||
| 11480 | this.max = dfa_17; | ||
| 11481 | this.accept = dfa_18; | ||
| 11482 | this.special = dfa_19; | ||
| 11483 | this.transition = dfa_20; | ||
| 11484 | } | ||
| 11485 | public String getDescription() { | ||
| 11486 | return "2973:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition )"; | ||
| 7119 | } | 11487 | } |
| 7120 | } | 11488 | } |
| 7121 | 11489 | ||
| 7122 | 11490 | ||
| 7123 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); | 11491 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); |
| 7124 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); | 11492 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); |
| 7125 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x000001C707E10022L}); | 11493 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0xF30C479220BC0782L,0x00000000000007FFL}); |
| 7126 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L}); | 11494 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L}); |
| 7127 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000001000L}); | 11495 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000038002L}); |
| 7128 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000120000L}); | 11496 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0xF300019220880780L,0x00000000000001FFL}); |
| 7129 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000088186870L}); | 11497 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000080500L}); |
| 7130 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x00000000000C0000L}); | 11498 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x00000000000C0500L}); |
| 7131 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000088106870L}); | 11499 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000010000L}); |
| 7132 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000100000L}); | 11500 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000200000000L}); |
| 7133 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x000000000001E000L}); | 11501 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000008000L}); |
| 7134 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000020L}); | 11502 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000400000L}); |
| 7135 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000008000000L}); | 11503 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000020000L}); |
| 7136 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000010020000L}); | 11504 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x000C000000000000L}); |
| 7137 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000080020L}); | 11505 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000001000000L}); |
| 7138 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000010000000L}); | 11506 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000002000000L}); |
| 7139 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x00000000E0007820L}); | 11507 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x000000000C000002L}); |
| 7140 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000020001000L}); | 11508 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000004000002L}); |
| 7141 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x00000000E0003820L}); | 11509 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000008000000L}); |
| 7142 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000100002L}); | 11510 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000010000002L}); |
| 7143 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000007E00020L}); | 11511 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x00F3800000000002L}); |
| 7144 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x00000000C0000822L}); | 11512 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0300000000000002L}); |
| 7145 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000020002L}); | 11513 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0400000800000002L}); |
| 7146 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x00000000080C6870L}); | 11514 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0800000000000002L}); |
| 7147 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000008006870L}); | 11515 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000019220080780L,0x00000000000001FFL}); |
| 7148 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000020000L}); | 11516 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000040000000L}); |
| 7149 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000400000000L}); | 11517 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000080000000L}); |
| 7150 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000001800000000L}); | 11518 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000100000000L}); |
| 7151 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000001000000020L}); | 11519 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000200000002L}); |
| 7152 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x000000A000000020L}); | 11520 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000400000000L}); |
| 7153 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000001000000000L}); | 11521 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000200000060L}); |
| 7154 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000002008000000L}); | 11522 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0xF300019E20880780L,0x00000000000001FFL}); |
| 7155 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000007E00030L}); | 11523 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000410000000L}); |
| 7156 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000010000000000L}); | 11524 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0xF300019A20880780L,0x00000000000001FFL}); |
| 7157 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000020000000000L}); | 11525 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000500L}); |
| 7158 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000080000010L}); | 11526 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000800000000L}); |
| 11527 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000002000000000L}); | ||
| 11528 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000004000000000L}); | ||
| 11529 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000040000000000L}); | ||
| 11530 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000100L}); | ||
| 11531 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000080040000000L}); | ||
| 11532 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000050000000L}); | ||
| 11533 | public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000100080000500L}); | ||
| 11534 | public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000001000000100L}); | ||
| 11535 | public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000200004000002L}); | ||
| 11536 | public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000800000200L}); | ||
| 11537 | public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000200L}); | ||
| 11538 | public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000800000000000L}); | ||
| 11539 | public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000700L}); | ||
| 11540 | public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0001000000000000L}); | ||
| 11541 | public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0002000000000000L}); | ||
| 11542 | public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0002000000400000L}); | ||
| 11543 | public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000400002L}); | ||
| 7159 | 11544 | ||
| 7160 | } \ No newline at end of file | 11545 | } \ No newline at end of file |