diff options
author | Kristóf Marussy <kristof@marussy.com> | 2021-06-27 23:21:42 +0200 |
---|---|---|
committer | Kristóf Marussy <kristof@marussy.com> | 2021-06-27 23:30:25 +0200 |
commit | 7febe0b4781c5bb0fab34895ad642040ae143a8b (patch) | |
tree | 5bc49f9195b18a938382f2527ee4ab273527a07a /language-ide/src/main | |
parent | Electric semicolons (diff) | |
download | refinery-7febe0b4781c5bb0fab34895ad642040ae143a8b.tar.gz refinery-7febe0b4781c5bb0fab34895ad642040ae143a8b.tar.zst refinery-7febe0b4781c5bb0fab34895ad642040ae143a8b.zip |
Add data constant support
Diffstat (limited to 'language-ide/src/main')
5 files changed, 7135 insertions, 2637 deletions
diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/ProblemParser.java b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/ProblemParser.java index e4142d9f..093342ad 100644 --- a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/ProblemParser.java +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/ProblemParser.java | |||
@@ -38,7 +38,10 @@ public class ProblemParser extends AbstractContentAssistParser { | |||
38 | builder.put(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0(), "rule__ReferenceDeclaration__Alternatives_0"); | 38 | builder.put(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0(), "rule__ReferenceDeclaration__Alternatives_0"); |
39 | builder.put(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0(), "rule__PredicateDefinition__Alternatives_0"); | 39 | builder.put(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0(), "rule__PredicateDefinition__Alternatives_0"); |
40 | builder.put(grammarAccess.getLiteralAccess().getAlternatives(), "rule__Literal__Alternatives"); | 40 | builder.put(grammarAccess.getLiteralAccess().getAlternatives(), "rule__Literal__Alternatives"); |
41 | builder.put(grammarAccess.getArgumentAccess().getAlternatives(), "rule__Argument__Alternatives"); | ||
41 | builder.put(grammarAccess.getAssertionAccess().getAlternatives_0(), "rule__Assertion__Alternatives_0"); | 42 | builder.put(grammarAccess.getAssertionAccess().getAlternatives_0(), "rule__Assertion__Alternatives_0"); |
43 | builder.put(grammarAccess.getAssertionArgumentAccess().getAlternatives(), "rule__AssertionArgument__Alternatives"); | ||
44 | builder.put(grammarAccess.getConstantAccess().getAlternatives(), "rule__Constant__Alternatives"); | ||
42 | builder.put(grammarAccess.getTypeScopeAccess().getAlternatives_1(), "rule__TypeScope__Alternatives_1"); | 45 | builder.put(grammarAccess.getTypeScopeAccess().getAlternatives_1(), "rule__TypeScope__Alternatives_1"); |
43 | builder.put(grammarAccess.getMultiplicityAccess().getAlternatives(), "rule__Multiplicity__Alternatives"); | 46 | builder.put(grammarAccess.getMultiplicityAccess().getAlternatives(), "rule__Multiplicity__Alternatives"); |
44 | builder.put(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives(), "rule__DefiniteMultiplicity__Alternatives"); | 47 | builder.put(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives(), "rule__DefiniteMultiplicity__Alternatives"); |
@@ -46,6 +49,9 @@ public class ProblemParser extends AbstractContentAssistParser { | |||
46 | builder.put(grammarAccess.getQuotedOrUnquotedIdAccess().getAlternatives(), "rule__QuotedOrUnquotedId__Alternatives"); | 49 | builder.put(grammarAccess.getQuotedOrUnquotedIdAccess().getAlternatives(), "rule__QuotedOrUnquotedId__Alternatives"); |
47 | builder.put(grammarAccess.getQualifiedNameAccess().getAlternatives(), "rule__QualifiedName__Alternatives"); | 50 | builder.put(grammarAccess.getQualifiedNameAccess().getAlternatives(), "rule__QualifiedName__Alternatives"); |
48 | builder.put(grammarAccess.getIdentifierAccess().getAlternatives(), "rule__Identifier__Alternatives"); | 51 | builder.put(grammarAccess.getIdentifierAccess().getAlternatives(), "rule__Identifier__Alternatives"); |
52 | builder.put(grammarAccess.getRealAccess().getAlternatives_2(), "rule__Real__Alternatives_2"); | ||
53 | builder.put(grammarAccess.getRealAccess().getAlternatives_2_1_1(), "rule__Real__Alternatives_2_1_1"); | ||
54 | builder.put(grammarAccess.getRealAccess().getAlternatives_2_1_2(), "rule__Real__Alternatives_2_1_2"); | ||
49 | builder.put(grammarAccess.getLogicValueAccess().getAlternatives(), "rule__LogicValue__Alternatives"); | 55 | builder.put(grammarAccess.getLogicValueAccess().getAlternatives(), "rule__LogicValue__Alternatives"); |
50 | builder.put(grammarAccess.getShortLogicValueAccess().getAlternatives(), "rule__ShortLogicValue__Alternatives"); | 56 | builder.put(grammarAccess.getShortLogicValueAccess().getAlternatives(), "rule__ShortLogicValue__Alternatives"); |
51 | builder.put(grammarAccess.getProblemAccess().getGroup(), "rule__Problem__Group__0"); | 57 | builder.put(grammarAccess.getProblemAccess().getGroup(), "rule__Problem__Group__0"); |
@@ -82,6 +88,7 @@ public class ProblemParser extends AbstractContentAssistParser { | |||
82 | builder.put(grammarAccess.getAssertionAccess().getGroup_0_1(), "rule__Assertion__Group_0_1__0"); | 88 | builder.put(grammarAccess.getAssertionAccess().getGroup_0_1(), "rule__Assertion__Group_0_1__0"); |
83 | builder.put(grammarAccess.getAssertionAccess().getGroup_0_1_3(), "rule__Assertion__Group_0_1_3__0"); | 89 | builder.put(grammarAccess.getAssertionAccess().getGroup_0_1_3(), "rule__Assertion__Group_0_1_3__0"); |
84 | builder.put(grammarAccess.getAssertionAccess().getGroup_0_1_3_1(), "rule__Assertion__Group_0_1_3_1__0"); | 90 | builder.put(grammarAccess.getAssertionAccess().getGroup_0_1_3_1(), "rule__Assertion__Group_0_1_3_1__0"); |
91 | builder.put(grammarAccess.getNodeValueAssertionAccess().getGroup(), "rule__NodeValueAssertion__Group__0"); | ||
85 | builder.put(grammarAccess.getScopeDeclarationAccess().getGroup(), "rule__ScopeDeclaration__Group__0"); | 92 | builder.put(grammarAccess.getScopeDeclarationAccess().getGroup(), "rule__ScopeDeclaration__Group__0"); |
86 | builder.put(grammarAccess.getScopeDeclarationAccess().getGroup_2(), "rule__ScopeDeclaration__Group_2__0"); | 93 | builder.put(grammarAccess.getScopeDeclarationAccess().getGroup_2(), "rule__ScopeDeclaration__Group_2__0"); |
87 | builder.put(grammarAccess.getTypeScopeAccess().getGroup(), "rule__TypeScope__Group__0"); | 94 | builder.put(grammarAccess.getTypeScopeAccess().getGroup(), "rule__TypeScope__Group__0"); |
@@ -89,6 +96,11 @@ public class ProblemParser extends AbstractContentAssistParser { | |||
89 | builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1(), "rule__QualifiedName__Group_1__0"); | 96 | builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1(), "rule__QualifiedName__Group_1__0"); |
90 | builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1_1(), "rule__QualifiedName__Group_1_1__0"); | 97 | builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1_1(), "rule__QualifiedName__Group_1_1__0"); |
91 | builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1_2(), "rule__QualifiedName__Group_1_2__0"); | 98 | builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1_2(), "rule__QualifiedName__Group_1_2__0"); |
99 | builder.put(grammarAccess.getIntegerAccess().getGroup(), "rule__Integer__Group__0"); | ||
100 | builder.put(grammarAccess.getRealAccess().getGroup(), "rule__Real__Group__0"); | ||
101 | builder.put(grammarAccess.getRealAccess().getGroup_2_0(), "rule__Real__Group_2_0__0"); | ||
102 | builder.put(grammarAccess.getRealAccess().getGroup_2_1(), "rule__Real__Group_2_1__0"); | ||
103 | builder.put(grammarAccess.getRealAccess().getGroup_2_1_0(), "rule__Real__Group_2_1_0__0"); | ||
92 | builder.put(grammarAccess.getProblemAccess().getNameAssignment_0_1(), "rule__Problem__NameAssignment_0_1"); | 104 | builder.put(grammarAccess.getProblemAccess().getNameAssignment_0_1(), "rule__Problem__NameAssignment_0_1"); |
93 | builder.put(grammarAccess.getProblemAccess().getStatementsAssignment_1(), "rule__Problem__StatementsAssignment_1"); | 105 | builder.put(grammarAccess.getProblemAccess().getStatementsAssignment_1(), "rule__Problem__StatementsAssignment_1"); |
94 | builder.put(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0(), "rule__ClassDeclaration__AbstractAssignment_0"); | 106 | builder.put(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0(), "rule__ClassDeclaration__AbstractAssignment_0"); |
@@ -120,7 +132,8 @@ public class ProblemParser extends AbstractContentAssistParser { | |||
120 | builder.put(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1(), "rule__Atom__TransitiveClosureAssignment_1"); | 132 | builder.put(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1(), "rule__Atom__TransitiveClosureAssignment_1"); |
121 | builder.put(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0(), "rule__Atom__ArgumentsAssignment_3_0"); | 133 | builder.put(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0(), "rule__Atom__ArgumentsAssignment_3_0"); |
122 | builder.put(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1(), "rule__Atom__ArgumentsAssignment_3_1_1"); | 134 | builder.put(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1(), "rule__Atom__ArgumentsAssignment_3_1_1"); |
123 | builder.put(grammarAccess.getArgumentAccess().getVariableOrNodeAssignment(), "rule__Argument__VariableOrNodeAssignment"); | 135 | builder.put(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeAssignment(), "rule__VariableOrNodeArgument__VariableOrNodeAssignment"); |
136 | builder.put(grammarAccess.getConstantArgumentAccess().getConstantAssignment(), "rule__ConstantArgument__ConstantAssignment"); | ||
124 | builder.put(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0(), "rule__Assertion__RelationAssignment_0_0_0"); | 137 | builder.put(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0(), "rule__Assertion__RelationAssignment_0_0_0"); |
125 | builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0(), "rule__Assertion__ArgumentsAssignment_0_0_2_0"); | 138 | builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0(), "rule__Assertion__ArgumentsAssignment_0_0_2_0"); |
126 | builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1(), "rule__Assertion__ArgumentsAssignment_0_0_2_1_1"); | 139 | builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1(), "rule__Assertion__ArgumentsAssignment_0_0_2_1_1"); |
@@ -129,6 +142,13 @@ public class ProblemParser extends AbstractContentAssistParser { | |||
129 | builder.put(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1(), "rule__Assertion__RelationAssignment_0_1_1"); | 142 | builder.put(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1(), "rule__Assertion__RelationAssignment_0_1_1"); |
130 | builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0(), "rule__Assertion__ArgumentsAssignment_0_1_3_0"); | 143 | builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0(), "rule__Assertion__ArgumentsAssignment_0_1_3_0"); |
131 | builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1(), "rule__Assertion__ArgumentsAssignment_0_1_3_1_1"); | 144 | builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1(), "rule__Assertion__ArgumentsAssignment_0_1_3_1_1"); |
145 | builder.put(grammarAccess.getNodeAssertionArgumentAccess().getNodeAssignment(), "rule__NodeAssertionArgument__NodeAssignment"); | ||
146 | builder.put(grammarAccess.getConstantAssertionArgumentAccess().getConstantAssignment(), "rule__ConstantAssertionArgument__ConstantAssignment"); | ||
147 | builder.put(grammarAccess.getNodeValueAssertionAccess().getNodeAssignment_0(), "rule__NodeValueAssertion__NodeAssignment_0"); | ||
148 | builder.put(grammarAccess.getNodeValueAssertionAccess().getValueAssignment_2(), "rule__NodeValueAssertion__ValueAssignment_2"); | ||
149 | builder.put(grammarAccess.getIntConstantAccess().getIntValueAssignment(), "rule__IntConstant__IntValueAssignment"); | ||
150 | builder.put(grammarAccess.getRealConstantAccess().getRealValueAssignment(), "rule__RealConstant__RealValueAssignment"); | ||
151 | builder.put(grammarAccess.getStringConstantAccess().getStringValueAssignment(), "rule__StringConstant__StringValueAssignment"); | ||
132 | builder.put(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1(), "rule__ScopeDeclaration__TypeScopesAssignment_1"); | 152 | builder.put(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1(), "rule__ScopeDeclaration__TypeScopesAssignment_1"); |
133 | builder.put(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1(), "rule__ScopeDeclaration__TypeScopesAssignment_2_1"); | 153 | builder.put(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1(), "rule__ScopeDeclaration__TypeScopesAssignment_2_1"); |
134 | builder.put(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0(), "rule__TypeScope__TargetTypeAssignment_0"); | 154 | builder.put(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0(), "rule__TypeScope__TargetTypeAssignment_0"); |
diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g index c53ed3c4..a1504042 100644 --- a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g | |||
@@ -365,9 +365,59 @@ ruleArgument | |||
365 | } | 365 | } |
366 | : | 366 | : |
367 | ( | 367 | ( |
368 | { before(grammarAccess.getArgumentAccess().getVariableOrNodeAssignment()); } | 368 | { before(grammarAccess.getArgumentAccess().getAlternatives()); } |
369 | (rule__Argument__VariableOrNodeAssignment) | 369 | (rule__Argument__Alternatives) |
370 | { after(grammarAccess.getArgumentAccess().getVariableOrNodeAssignment()); } | 370 | { after(grammarAccess.getArgumentAccess().getAlternatives()); } |
371 | ) | ||
372 | ; | ||
373 | finally { | ||
374 | restoreStackSize(stackSize); | ||
375 | } | ||
376 | |||
377 | // Entry rule entryRuleVariableOrNodeArgument | ||
378 | entryRuleVariableOrNodeArgument | ||
379 | : | ||
380 | { before(grammarAccess.getVariableOrNodeArgumentRule()); } | ||
381 | ruleVariableOrNodeArgument | ||
382 | { after(grammarAccess.getVariableOrNodeArgumentRule()); } | ||
383 | EOF | ||
384 | ; | ||
385 | |||
386 | // Rule VariableOrNodeArgument | ||
387 | ruleVariableOrNodeArgument | ||
388 | @init { | ||
389 | int stackSize = keepStackSize(); | ||
390 | } | ||
391 | : | ||
392 | ( | ||
393 | { before(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeAssignment()); } | ||
394 | (rule__VariableOrNodeArgument__VariableOrNodeAssignment) | ||
395 | { after(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeAssignment()); } | ||
396 | ) | ||
397 | ; | ||
398 | finally { | ||
399 | restoreStackSize(stackSize); | ||
400 | } | ||
401 | |||
402 | // Entry rule entryRuleConstantArgument | ||
403 | entryRuleConstantArgument | ||
404 | : | ||
405 | { before(grammarAccess.getConstantArgumentRule()); } | ||
406 | ruleConstantArgument | ||
407 | { after(grammarAccess.getConstantArgumentRule()); } | ||
408 | EOF | ||
409 | ; | ||
410 | |||
411 | // Rule ConstantArgument | ||
412 | ruleConstantArgument | ||
413 | @init { | ||
414 | int stackSize = keepStackSize(); | ||
415 | } | ||
416 | : | ||
417 | ( | ||
418 | { before(grammarAccess.getConstantArgumentAccess().getConstantAssignment()); } | ||
419 | (rule__ConstantArgument__ConstantAssignment) | ||
420 | { after(grammarAccess.getConstantArgumentAccess().getConstantAssignment()); } | ||
371 | ) | 421 | ) |
372 | ; | 422 | ; |
373 | finally { | 423 | finally { |
@@ -399,6 +449,206 @@ finally { | |||
399 | restoreStackSize(stackSize); | 449 | restoreStackSize(stackSize); |
400 | } | 450 | } |
401 | 451 | ||
452 | // Entry rule entryRuleAssertionArgument | ||
453 | entryRuleAssertionArgument | ||
454 | : | ||
455 | { before(grammarAccess.getAssertionArgumentRule()); } | ||
456 | ruleAssertionArgument | ||
457 | { after(grammarAccess.getAssertionArgumentRule()); } | ||
458 | EOF | ||
459 | ; | ||
460 | |||
461 | // Rule AssertionArgument | ||
462 | ruleAssertionArgument | ||
463 | @init { | ||
464 | int stackSize = keepStackSize(); | ||
465 | } | ||
466 | : | ||
467 | ( | ||
468 | { before(grammarAccess.getAssertionArgumentAccess().getAlternatives()); } | ||
469 | (rule__AssertionArgument__Alternatives) | ||
470 | { after(grammarAccess.getAssertionArgumentAccess().getAlternatives()); } | ||
471 | ) | ||
472 | ; | ||
473 | finally { | ||
474 | restoreStackSize(stackSize); | ||
475 | } | ||
476 | |||
477 | // Entry rule entryRuleNodeAssertionArgument | ||
478 | entryRuleNodeAssertionArgument | ||
479 | : | ||
480 | { before(grammarAccess.getNodeAssertionArgumentRule()); } | ||
481 | ruleNodeAssertionArgument | ||
482 | { after(grammarAccess.getNodeAssertionArgumentRule()); } | ||
483 | EOF | ||
484 | ; | ||
485 | |||
486 | // Rule NodeAssertionArgument | ||
487 | ruleNodeAssertionArgument | ||
488 | @init { | ||
489 | int stackSize = keepStackSize(); | ||
490 | } | ||
491 | : | ||
492 | ( | ||
493 | { before(grammarAccess.getNodeAssertionArgumentAccess().getNodeAssignment()); } | ||
494 | (rule__NodeAssertionArgument__NodeAssignment) | ||
495 | { after(grammarAccess.getNodeAssertionArgumentAccess().getNodeAssignment()); } | ||
496 | ) | ||
497 | ; | ||
498 | finally { | ||
499 | restoreStackSize(stackSize); | ||
500 | } | ||
501 | |||
502 | // Entry rule entryRuleConstantAssertionArgument | ||
503 | entryRuleConstantAssertionArgument | ||
504 | : | ||
505 | { before(grammarAccess.getConstantAssertionArgumentRule()); } | ||
506 | ruleConstantAssertionArgument | ||
507 | { after(grammarAccess.getConstantAssertionArgumentRule()); } | ||
508 | EOF | ||
509 | ; | ||
510 | |||
511 | // Rule ConstantAssertionArgument | ||
512 | ruleConstantAssertionArgument | ||
513 | @init { | ||
514 | int stackSize = keepStackSize(); | ||
515 | } | ||
516 | : | ||
517 | ( | ||
518 | { before(grammarAccess.getConstantAssertionArgumentAccess().getConstantAssignment()); } | ||
519 | (rule__ConstantAssertionArgument__ConstantAssignment) | ||
520 | { after(grammarAccess.getConstantAssertionArgumentAccess().getConstantAssignment()); } | ||
521 | ) | ||
522 | ; | ||
523 | finally { | ||
524 | restoreStackSize(stackSize); | ||
525 | } | ||
526 | |||
527 | // Entry rule entryRuleNodeValueAssertion | ||
528 | entryRuleNodeValueAssertion | ||
529 | : | ||
530 | { before(grammarAccess.getNodeValueAssertionRule()); } | ||
531 | ruleNodeValueAssertion | ||
532 | { after(grammarAccess.getNodeValueAssertionRule()); } | ||
533 | EOF | ||
534 | ; | ||
535 | |||
536 | // Rule NodeValueAssertion | ||
537 | ruleNodeValueAssertion | ||
538 | @init { | ||
539 | int stackSize = keepStackSize(); | ||
540 | } | ||
541 | : | ||
542 | ( | ||
543 | { before(grammarAccess.getNodeValueAssertionAccess().getGroup()); } | ||
544 | (rule__NodeValueAssertion__Group__0) | ||
545 | { after(grammarAccess.getNodeValueAssertionAccess().getGroup()); } | ||
546 | ) | ||
547 | ; | ||
548 | finally { | ||
549 | restoreStackSize(stackSize); | ||
550 | } | ||
551 | |||
552 | // Entry rule entryRuleConstant | ||
553 | entryRuleConstant | ||
554 | : | ||
555 | { before(grammarAccess.getConstantRule()); } | ||
556 | ruleConstant | ||
557 | { after(grammarAccess.getConstantRule()); } | ||
558 | EOF | ||
559 | ; | ||
560 | |||
561 | // Rule Constant | ||
562 | ruleConstant | ||
563 | @init { | ||
564 | int stackSize = keepStackSize(); | ||
565 | } | ||
566 | : | ||
567 | ( | ||
568 | { before(grammarAccess.getConstantAccess().getAlternatives()); } | ||
569 | (rule__Constant__Alternatives) | ||
570 | { after(grammarAccess.getConstantAccess().getAlternatives()); } | ||
571 | ) | ||
572 | ; | ||
573 | finally { | ||
574 | restoreStackSize(stackSize); | ||
575 | } | ||
576 | |||
577 | // Entry rule entryRuleIntConstant | ||
578 | entryRuleIntConstant | ||
579 | : | ||
580 | { before(grammarAccess.getIntConstantRule()); } | ||
581 | ruleIntConstant | ||
582 | { after(grammarAccess.getIntConstantRule()); } | ||
583 | EOF | ||
584 | ; | ||
585 | |||
586 | // Rule IntConstant | ||
587 | ruleIntConstant | ||
588 | @init { | ||
589 | int stackSize = keepStackSize(); | ||
590 | } | ||
591 | : | ||
592 | ( | ||
593 | { before(grammarAccess.getIntConstantAccess().getIntValueAssignment()); } | ||
594 | (rule__IntConstant__IntValueAssignment) | ||
595 | { after(grammarAccess.getIntConstantAccess().getIntValueAssignment()); } | ||
596 | ) | ||
597 | ; | ||
598 | finally { | ||
599 | restoreStackSize(stackSize); | ||
600 | } | ||
601 | |||
602 | // Entry rule entryRuleRealConstant | ||
603 | entryRuleRealConstant | ||
604 | : | ||
605 | { before(grammarAccess.getRealConstantRule()); } | ||
606 | ruleRealConstant | ||
607 | { after(grammarAccess.getRealConstantRule()); } | ||
608 | EOF | ||
609 | ; | ||
610 | |||
611 | // Rule RealConstant | ||
612 | ruleRealConstant | ||
613 | @init { | ||
614 | int stackSize = keepStackSize(); | ||
615 | } | ||
616 | : | ||
617 | ( | ||
618 | { before(grammarAccess.getRealConstantAccess().getRealValueAssignment()); } | ||
619 | (rule__RealConstant__RealValueAssignment) | ||
620 | { after(grammarAccess.getRealConstantAccess().getRealValueAssignment()); } | ||
621 | ) | ||
622 | ; | ||
623 | finally { | ||
624 | restoreStackSize(stackSize); | ||
625 | } | ||
626 | |||
627 | // Entry rule entryRuleStringConstant | ||
628 | entryRuleStringConstant | ||
629 | : | ||
630 | { before(grammarAccess.getStringConstantRule()); } | ||
631 | ruleStringConstant | ||
632 | { after(grammarAccess.getStringConstantRule()); } | ||
633 | EOF | ||
634 | ; | ||
635 | |||
636 | // Rule StringConstant | ||
637 | ruleStringConstant | ||
638 | @init { | ||
639 | int stackSize = keepStackSize(); | ||
640 | } | ||
641 | : | ||
642 | ( | ||
643 | { before(grammarAccess.getStringConstantAccess().getStringValueAssignment()); } | ||
644 | (rule__StringConstant__StringValueAssignment) | ||
645 | { after(grammarAccess.getStringConstantAccess().getStringValueAssignment()); } | ||
646 | ) | ||
647 | ; | ||
648 | finally { | ||
649 | restoreStackSize(stackSize); | ||
650 | } | ||
651 | |||
402 | // Entry rule entryRuleScopeDeclaration | 652 | // Entry rule entryRuleScopeDeclaration |
403 | entryRuleScopeDeclaration | 653 | entryRuleScopeDeclaration |
404 | : | 654 | : |
@@ -626,16 +876,23 @@ finally { | |||
626 | 876 | ||
627 | // Entry rule entryRuleQualifiedName | 877 | // Entry rule entryRuleQualifiedName |
628 | entryRuleQualifiedName | 878 | entryRuleQualifiedName |
879 | @init { | ||
880 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
881 | } | ||
629 | : | 882 | : |
630 | { before(grammarAccess.getQualifiedNameRule()); } | 883 | { before(grammarAccess.getQualifiedNameRule()); } |
631 | ruleQualifiedName | 884 | ruleQualifiedName |
632 | { after(grammarAccess.getQualifiedNameRule()); } | 885 | { after(grammarAccess.getQualifiedNameRule()); } |
633 | EOF | 886 | EOF |
634 | ; | 887 | ; |
888 | finally { | ||
889 | myHiddenTokenState.restore(); | ||
890 | } | ||
635 | 891 | ||
636 | // Rule QualifiedName | 892 | // Rule QualifiedName |
637 | ruleQualifiedName | 893 | ruleQualifiedName |
638 | @init { | 894 | @init { |
895 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
639 | int stackSize = keepStackSize(); | 896 | int stackSize = keepStackSize(); |
640 | } | 897 | } |
641 | : | 898 | : |
@@ -647,6 +904,7 @@ ruleQualifiedName | |||
647 | ; | 904 | ; |
648 | finally { | 905 | finally { |
649 | restoreStackSize(stackSize); | 906 | restoreStackSize(stackSize); |
907 | myHiddenTokenState.restore(); | ||
650 | } | 908 | } |
651 | 909 | ||
652 | // Entry rule entryRuleIdentifier | 910 | // Entry rule entryRuleIdentifier |
@@ -674,6 +932,72 @@ finally { | |||
674 | restoreStackSize(stackSize); | 932 | restoreStackSize(stackSize); |
675 | } | 933 | } |
676 | 934 | ||
935 | // Entry rule entryRuleInteger | ||
936 | entryRuleInteger | ||
937 | @init { | ||
938 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
939 | } | ||
940 | : | ||
941 | { before(grammarAccess.getIntegerRule()); } | ||
942 | ruleInteger | ||
943 | { after(grammarAccess.getIntegerRule()); } | ||
944 | EOF | ||
945 | ; | ||
946 | finally { | ||
947 | myHiddenTokenState.restore(); | ||
948 | } | ||
949 | |||
950 | // Rule Integer | ||
951 | ruleInteger | ||
952 | @init { | ||
953 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
954 | int stackSize = keepStackSize(); | ||
955 | } | ||
956 | : | ||
957 | ( | ||
958 | { before(grammarAccess.getIntegerAccess().getGroup()); } | ||
959 | (rule__Integer__Group__0) | ||
960 | { after(grammarAccess.getIntegerAccess().getGroup()); } | ||
961 | ) | ||
962 | ; | ||
963 | finally { | ||
964 | restoreStackSize(stackSize); | ||
965 | myHiddenTokenState.restore(); | ||
966 | } | ||
967 | |||
968 | // Entry rule entryRuleReal | ||
969 | entryRuleReal | ||
970 | @init { | ||
971 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
972 | } | ||
973 | : | ||
974 | { before(grammarAccess.getRealRule()); } | ||
975 | ruleReal | ||
976 | { after(grammarAccess.getRealRule()); } | ||
977 | EOF | ||
978 | ; | ||
979 | finally { | ||
980 | myHiddenTokenState.restore(); | ||
981 | } | ||
982 | |||
983 | // Rule Real | ||
984 | ruleReal | ||
985 | @init { | ||
986 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
987 | int stackSize = keepStackSize(); | ||
988 | } | ||
989 | : | ||
990 | ( | ||
991 | { before(grammarAccess.getRealAccess().getGroup()); } | ||
992 | (rule__Real__Group__0) | ||
993 | { after(grammarAccess.getRealAccess().getGroup()); } | ||
994 | ) | ||
995 | ; | ||
996 | finally { | ||
997 | restoreStackSize(stackSize); | ||
998 | myHiddenTokenState.restore(); | ||
999 | } | ||
1000 | |||
677 | // Rule LogicValue | 1001 | // Rule LogicValue |
678 | ruleLogicValue | 1002 | ruleLogicValue |
679 | @init { | 1003 | @init { |
@@ -736,9 +1060,15 @@ rule__Statement__Alternatives | |||
736 | ) | 1060 | ) |
737 | | | 1061 | | |
738 | ( | 1062 | ( |
739 | { before(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); } | 1063 | { before(grammarAccess.getStatementAccess().getNodeValueAssertionParserRuleCall_4()); } |
1064 | ruleNodeValueAssertion | ||
1065 | { after(grammarAccess.getStatementAccess().getNodeValueAssertionParserRuleCall_4()); } | ||
1066 | ) | ||
1067 | | | ||
1068 | ( | ||
1069 | { before(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_5()); } | ||
740 | ruleScopeDeclaration | 1070 | ruleScopeDeclaration |
741 | { after(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); } | 1071 | { after(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_5()); } |
742 | ) | 1072 | ) |
743 | ; | 1073 | ; |
744 | finally { | 1074 | finally { |
@@ -871,6 +1201,27 @@ finally { | |||
871 | restoreStackSize(stackSize); | 1201 | restoreStackSize(stackSize); |
872 | } | 1202 | } |
873 | 1203 | ||
1204 | rule__Argument__Alternatives | ||
1205 | @init { | ||
1206 | int stackSize = keepStackSize(); | ||
1207 | } | ||
1208 | : | ||
1209 | ( | ||
1210 | { before(grammarAccess.getArgumentAccess().getVariableOrNodeArgumentParserRuleCall_0()); } | ||
1211 | ruleVariableOrNodeArgument | ||
1212 | { after(grammarAccess.getArgumentAccess().getVariableOrNodeArgumentParserRuleCall_0()); } | ||
1213 | ) | ||
1214 | | | ||
1215 | ( | ||
1216 | { before(grammarAccess.getArgumentAccess().getConstantArgumentParserRuleCall_1()); } | ||
1217 | ruleConstantArgument | ||
1218 | { after(grammarAccess.getArgumentAccess().getConstantArgumentParserRuleCall_1()); } | ||
1219 | ) | ||
1220 | ; | ||
1221 | finally { | ||
1222 | restoreStackSize(stackSize); | ||
1223 | } | ||
1224 | |||
874 | rule__Assertion__Alternatives_0 | 1225 | rule__Assertion__Alternatives_0 |
875 | @init { | 1226 | @init { |
876 | int stackSize = keepStackSize(); | 1227 | int stackSize = keepStackSize(); |
@@ -892,6 +1243,54 @@ finally { | |||
892 | restoreStackSize(stackSize); | 1243 | restoreStackSize(stackSize); |
893 | } | 1244 | } |
894 | 1245 | ||
1246 | rule__AssertionArgument__Alternatives | ||
1247 | @init { | ||
1248 | int stackSize = keepStackSize(); | ||
1249 | } | ||
1250 | : | ||
1251 | ( | ||
1252 | { before(grammarAccess.getAssertionArgumentAccess().getNodeAssertionArgumentParserRuleCall_0()); } | ||
1253 | ruleNodeAssertionArgument | ||
1254 | { after(grammarAccess.getAssertionArgumentAccess().getNodeAssertionArgumentParserRuleCall_0()); } | ||
1255 | ) | ||
1256 | | | ||
1257 | ( | ||
1258 | { before(grammarAccess.getAssertionArgumentAccess().getConstantAssertionArgumentParserRuleCall_1()); } | ||
1259 | ruleConstantAssertionArgument | ||
1260 | { after(grammarAccess.getAssertionArgumentAccess().getConstantAssertionArgumentParserRuleCall_1()); } | ||
1261 | ) | ||
1262 | ; | ||
1263 | finally { | ||
1264 | restoreStackSize(stackSize); | ||
1265 | } | ||
1266 | |||
1267 | rule__Constant__Alternatives | ||
1268 | @init { | ||
1269 | int stackSize = keepStackSize(); | ||
1270 | } | ||
1271 | : | ||
1272 | ( | ||
1273 | { before(grammarAccess.getConstantAccess().getIntConstantParserRuleCall_0()); } | ||
1274 | ruleIntConstant | ||
1275 | { after(grammarAccess.getConstantAccess().getIntConstantParserRuleCall_0()); } | ||
1276 | ) | ||
1277 | | | ||
1278 | ( | ||
1279 | { before(grammarAccess.getConstantAccess().getRealConstantParserRuleCall_1()); } | ||
1280 | ruleRealConstant | ||
1281 | { after(grammarAccess.getConstantAccess().getRealConstantParserRuleCall_1()); } | ||
1282 | ) | ||
1283 | | | ||
1284 | ( | ||
1285 | { before(grammarAccess.getConstantAccess().getStringConstantParserRuleCall_2()); } | ||
1286 | ruleStringConstant | ||
1287 | { after(grammarAccess.getConstantAccess().getStringConstantParserRuleCall_2()); } | ||
1288 | ) | ||
1289 | ; | ||
1290 | finally { | ||
1291 | restoreStackSize(stackSize); | ||
1292 | } | ||
1293 | |||
895 | rule__TypeScope__Alternatives_1 | 1294 | rule__TypeScope__Alternatives_1 |
896 | @init { | 1295 | @init { |
897 | int stackSize = keepStackSize(); | 1296 | int stackSize = keepStackSize(); |
@@ -1040,6 +1439,81 @@ rule__Identifier__Alternatives | |||
1040 | 'false' | 1439 | 'false' |
1041 | { after(grammarAccess.getIdentifierAccess().getFalseKeyword_2()); } | 1440 | { after(grammarAccess.getIdentifierAccess().getFalseKeyword_2()); } |
1042 | ) | 1441 | ) |
1442 | | | ||
1443 | ( | ||
1444 | { before(grammarAccess.getIdentifierAccess().getEKeyword_3()); } | ||
1445 | 'e' | ||
1446 | { after(grammarAccess.getIdentifierAccess().getEKeyword_3()); } | ||
1447 | ) | ||
1448 | | | ||
1449 | ( | ||
1450 | { before(grammarAccess.getIdentifierAccess().getEKeyword_4()); } | ||
1451 | 'E' | ||
1452 | { after(grammarAccess.getIdentifierAccess().getEKeyword_4()); } | ||
1453 | ) | ||
1454 | ; | ||
1455 | finally { | ||
1456 | restoreStackSize(stackSize); | ||
1457 | } | ||
1458 | |||
1459 | rule__Real__Alternatives_2 | ||
1460 | @init { | ||
1461 | int stackSize = keepStackSize(); | ||
1462 | } | ||
1463 | : | ||
1464 | ( | ||
1465 | { before(grammarAccess.getRealAccess().getGroup_2_0()); } | ||
1466 | (rule__Real__Group_2_0__0) | ||
1467 | { after(grammarAccess.getRealAccess().getGroup_2_0()); } | ||
1468 | ) | ||
1469 | | | ||
1470 | ( | ||
1471 | { before(grammarAccess.getRealAccess().getGroup_2_1()); } | ||
1472 | (rule__Real__Group_2_1__0) | ||
1473 | { after(grammarAccess.getRealAccess().getGroup_2_1()); } | ||
1474 | ) | ||
1475 | ; | ||
1476 | finally { | ||
1477 | restoreStackSize(stackSize); | ||
1478 | } | ||
1479 | |||
1480 | rule__Real__Alternatives_2_1_1 | ||
1481 | @init { | ||
1482 | int stackSize = keepStackSize(); | ||
1483 | } | ||
1484 | : | ||
1485 | ( | ||
1486 | { before(grammarAccess.getRealAccess().getEKeyword_2_1_1_0()); } | ||
1487 | 'e' | ||
1488 | { after(grammarAccess.getRealAccess().getEKeyword_2_1_1_0()); } | ||
1489 | ) | ||
1490 | | | ||
1491 | ( | ||
1492 | { before(grammarAccess.getRealAccess().getEKeyword_2_1_1_1()); } | ||
1493 | 'E' | ||
1494 | { after(grammarAccess.getRealAccess().getEKeyword_2_1_1_1()); } | ||
1495 | ) | ||
1496 | ; | ||
1497 | finally { | ||
1498 | restoreStackSize(stackSize); | ||
1499 | } | ||
1500 | |||
1501 | rule__Real__Alternatives_2_1_2 | ||
1502 | @init { | ||
1503 | int stackSize = keepStackSize(); | ||
1504 | } | ||
1505 | : | ||
1506 | ( | ||
1507 | { before(grammarAccess.getRealAccess().getHyphenMinusKeyword_2_1_2_0()); } | ||
1508 | '-' | ||
1509 | { after(grammarAccess.getRealAccess().getHyphenMinusKeyword_2_1_2_0()); } | ||
1510 | ) | ||
1511 | | | ||
1512 | ( | ||
1513 | { before(grammarAccess.getRealAccess().getPlusSignKeyword_2_1_2_1()); } | ||
1514 | '+' | ||
1515 | { after(grammarAccess.getRealAccess().getPlusSignKeyword_2_1_2_1()); } | ||
1516 | ) | ||
1043 | ; | 1517 | ; |
1044 | finally { | 1518 | finally { |
1045 | restoreStackSize(stackSize); | 1519 | restoreStackSize(stackSize); |
@@ -3712,6 +4186,114 @@ finally { | |||
3712 | } | 4186 | } |
3713 | 4187 | ||
3714 | 4188 | ||
4189 | rule__NodeValueAssertion__Group__0 | ||
4190 | @init { | ||
4191 | int stackSize = keepStackSize(); | ||
4192 | } | ||
4193 | : | ||
4194 | rule__NodeValueAssertion__Group__0__Impl | ||
4195 | rule__NodeValueAssertion__Group__1 | ||
4196 | ; | ||
4197 | finally { | ||
4198 | restoreStackSize(stackSize); | ||
4199 | } | ||
4200 | |||
4201 | rule__NodeValueAssertion__Group__0__Impl | ||
4202 | @init { | ||
4203 | int stackSize = keepStackSize(); | ||
4204 | } | ||
4205 | : | ||
4206 | ( | ||
4207 | { before(grammarAccess.getNodeValueAssertionAccess().getNodeAssignment_0()); } | ||
4208 | (rule__NodeValueAssertion__NodeAssignment_0) | ||
4209 | { after(grammarAccess.getNodeValueAssertionAccess().getNodeAssignment_0()); } | ||
4210 | ) | ||
4211 | ; | ||
4212 | finally { | ||
4213 | restoreStackSize(stackSize); | ||
4214 | } | ||
4215 | |||
4216 | rule__NodeValueAssertion__Group__1 | ||
4217 | @init { | ||
4218 | int stackSize = keepStackSize(); | ||
4219 | } | ||
4220 | : | ||
4221 | rule__NodeValueAssertion__Group__1__Impl | ||
4222 | rule__NodeValueAssertion__Group__2 | ||
4223 | ; | ||
4224 | finally { | ||
4225 | restoreStackSize(stackSize); | ||
4226 | } | ||
4227 | |||
4228 | rule__NodeValueAssertion__Group__1__Impl | ||
4229 | @init { | ||
4230 | int stackSize = keepStackSize(); | ||
4231 | } | ||
4232 | : | ||
4233 | ( | ||
4234 | { before(grammarAccess.getNodeValueAssertionAccess().getColonKeyword_1()); } | ||
4235 | ':' | ||
4236 | { after(grammarAccess.getNodeValueAssertionAccess().getColonKeyword_1()); } | ||
4237 | ) | ||
4238 | ; | ||
4239 | finally { | ||
4240 | restoreStackSize(stackSize); | ||
4241 | } | ||
4242 | |||
4243 | rule__NodeValueAssertion__Group__2 | ||
4244 | @init { | ||
4245 | int stackSize = keepStackSize(); | ||
4246 | } | ||
4247 | : | ||
4248 | rule__NodeValueAssertion__Group__2__Impl | ||
4249 | rule__NodeValueAssertion__Group__3 | ||
4250 | ; | ||
4251 | finally { | ||
4252 | restoreStackSize(stackSize); | ||
4253 | } | ||
4254 | |||
4255 | rule__NodeValueAssertion__Group__2__Impl | ||
4256 | @init { | ||
4257 | int stackSize = keepStackSize(); | ||
4258 | } | ||
4259 | : | ||
4260 | ( | ||
4261 | { before(grammarAccess.getNodeValueAssertionAccess().getValueAssignment_2()); } | ||
4262 | (rule__NodeValueAssertion__ValueAssignment_2) | ||
4263 | { after(grammarAccess.getNodeValueAssertionAccess().getValueAssignment_2()); } | ||
4264 | ) | ||
4265 | ; | ||
4266 | finally { | ||
4267 | restoreStackSize(stackSize); | ||
4268 | } | ||
4269 | |||
4270 | rule__NodeValueAssertion__Group__3 | ||
4271 | @init { | ||
4272 | int stackSize = keepStackSize(); | ||
4273 | } | ||
4274 | : | ||
4275 | rule__NodeValueAssertion__Group__3__Impl | ||
4276 | ; | ||
4277 | finally { | ||
4278 | restoreStackSize(stackSize); | ||
4279 | } | ||
4280 | |||
4281 | rule__NodeValueAssertion__Group__3__Impl | ||
4282 | @init { | ||
4283 | int stackSize = keepStackSize(); | ||
4284 | } | ||
4285 | : | ||
4286 | ( | ||
4287 | { before(grammarAccess.getNodeValueAssertionAccess().getFullStopKeyword_3()); } | ||
4288 | '.' | ||
4289 | { after(grammarAccess.getNodeValueAssertionAccess().getFullStopKeyword_3()); } | ||
4290 | ) | ||
4291 | ; | ||
4292 | finally { | ||
4293 | restoreStackSize(stackSize); | ||
4294 | } | ||
4295 | |||
4296 | |||
3715 | rule__ScopeDeclaration__Group__0 | 4297 | rule__ScopeDeclaration__Group__0 |
3716 | @init { | 4298 | @init { |
3717 | int stackSize = keepStackSize(); | 4299 | int stackSize = keepStackSize(); |
@@ -4225,6 +4807,357 @@ finally { | |||
4225 | } | 4807 | } |
4226 | 4808 | ||
4227 | 4809 | ||
4810 | rule__Integer__Group__0 | ||
4811 | @init { | ||
4812 | int stackSize = keepStackSize(); | ||
4813 | } | ||
4814 | : | ||
4815 | rule__Integer__Group__0__Impl | ||
4816 | rule__Integer__Group__1 | ||
4817 | ; | ||
4818 | finally { | ||
4819 | restoreStackSize(stackSize); | ||
4820 | } | ||
4821 | |||
4822 | rule__Integer__Group__0__Impl | ||
4823 | @init { | ||
4824 | int stackSize = keepStackSize(); | ||
4825 | } | ||
4826 | : | ||
4827 | ( | ||
4828 | { before(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0()); } | ||
4829 | ('-')? | ||
4830 | { after(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0()); } | ||
4831 | ) | ||
4832 | ; | ||
4833 | finally { | ||
4834 | restoreStackSize(stackSize); | ||
4835 | } | ||
4836 | |||
4837 | rule__Integer__Group__1 | ||
4838 | @init { | ||
4839 | int stackSize = keepStackSize(); | ||
4840 | } | ||
4841 | : | ||
4842 | rule__Integer__Group__1__Impl | ||
4843 | ; | ||
4844 | finally { | ||
4845 | restoreStackSize(stackSize); | ||
4846 | } | ||
4847 | |||
4848 | rule__Integer__Group__1__Impl | ||
4849 | @init { | ||
4850 | int stackSize = keepStackSize(); | ||
4851 | } | ||
4852 | : | ||
4853 | ( | ||
4854 | { before(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_1()); } | ||
4855 | RULE_INT | ||
4856 | { after(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_1()); } | ||
4857 | ) | ||
4858 | ; | ||
4859 | finally { | ||
4860 | restoreStackSize(stackSize); | ||
4861 | } | ||
4862 | |||
4863 | |||
4864 | rule__Real__Group__0 | ||
4865 | @init { | ||
4866 | int stackSize = keepStackSize(); | ||
4867 | } | ||
4868 | : | ||
4869 | rule__Real__Group__0__Impl | ||
4870 | rule__Real__Group__1 | ||
4871 | ; | ||
4872 | finally { | ||
4873 | restoreStackSize(stackSize); | ||
4874 | } | ||
4875 | |||
4876 | rule__Real__Group__0__Impl | ||
4877 | @init { | ||
4878 | int stackSize = keepStackSize(); | ||
4879 | } | ||
4880 | : | ||
4881 | ( | ||
4882 | { before(grammarAccess.getRealAccess().getHyphenMinusKeyword_0()); } | ||
4883 | ('-')? | ||
4884 | { after(grammarAccess.getRealAccess().getHyphenMinusKeyword_0()); } | ||
4885 | ) | ||
4886 | ; | ||
4887 | finally { | ||
4888 | restoreStackSize(stackSize); | ||
4889 | } | ||
4890 | |||
4891 | rule__Real__Group__1 | ||
4892 | @init { | ||
4893 | int stackSize = keepStackSize(); | ||
4894 | } | ||
4895 | : | ||
4896 | rule__Real__Group__1__Impl | ||
4897 | rule__Real__Group__2 | ||
4898 | ; | ||
4899 | finally { | ||
4900 | restoreStackSize(stackSize); | ||
4901 | } | ||
4902 | |||
4903 | rule__Real__Group__1__Impl | ||
4904 | @init { | ||
4905 | int stackSize = keepStackSize(); | ||
4906 | } | ||
4907 | : | ||
4908 | ( | ||
4909 | { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_1()); } | ||
4910 | RULE_INT | ||
4911 | { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_1()); } | ||
4912 | ) | ||
4913 | ; | ||
4914 | finally { | ||
4915 | restoreStackSize(stackSize); | ||
4916 | } | ||
4917 | |||
4918 | rule__Real__Group__2 | ||
4919 | @init { | ||
4920 | int stackSize = keepStackSize(); | ||
4921 | } | ||
4922 | : | ||
4923 | rule__Real__Group__2__Impl | ||
4924 | ; | ||
4925 | finally { | ||
4926 | restoreStackSize(stackSize); | ||
4927 | } | ||
4928 | |||
4929 | rule__Real__Group__2__Impl | ||
4930 | @init { | ||
4931 | int stackSize = keepStackSize(); | ||
4932 | } | ||
4933 | : | ||
4934 | ( | ||
4935 | { before(grammarAccess.getRealAccess().getAlternatives_2()); } | ||
4936 | (rule__Real__Alternatives_2) | ||
4937 | { after(grammarAccess.getRealAccess().getAlternatives_2()); } | ||
4938 | ) | ||
4939 | ; | ||
4940 | finally { | ||
4941 | restoreStackSize(stackSize); | ||
4942 | } | ||
4943 | |||
4944 | |||
4945 | rule__Real__Group_2_0__0 | ||
4946 | @init { | ||
4947 | int stackSize = keepStackSize(); | ||
4948 | } | ||
4949 | : | ||
4950 | rule__Real__Group_2_0__0__Impl | ||
4951 | rule__Real__Group_2_0__1 | ||
4952 | ; | ||
4953 | finally { | ||
4954 | restoreStackSize(stackSize); | ||
4955 | } | ||
4956 | |||
4957 | rule__Real__Group_2_0__0__Impl | ||
4958 | @init { | ||
4959 | int stackSize = keepStackSize(); | ||
4960 | } | ||
4961 | : | ||
4962 | ( | ||
4963 | { before(grammarAccess.getRealAccess().getFullStopKeyword_2_0_0()); } | ||
4964 | '.' | ||
4965 | { after(grammarAccess.getRealAccess().getFullStopKeyword_2_0_0()); } | ||
4966 | ) | ||
4967 | ; | ||
4968 | finally { | ||
4969 | restoreStackSize(stackSize); | ||
4970 | } | ||
4971 | |||
4972 | rule__Real__Group_2_0__1 | ||
4973 | @init { | ||
4974 | int stackSize = keepStackSize(); | ||
4975 | } | ||
4976 | : | ||
4977 | rule__Real__Group_2_0__1__Impl | ||
4978 | ; | ||
4979 | finally { | ||
4980 | restoreStackSize(stackSize); | ||
4981 | } | ||
4982 | |||
4983 | rule__Real__Group_2_0__1__Impl | ||
4984 | @init { | ||
4985 | int stackSize = keepStackSize(); | ||
4986 | } | ||
4987 | : | ||
4988 | ( | ||
4989 | { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_0_1()); } | ||
4990 | RULE_INT | ||
4991 | { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_0_1()); } | ||
4992 | ) | ||
4993 | ; | ||
4994 | finally { | ||
4995 | restoreStackSize(stackSize); | ||
4996 | } | ||
4997 | |||
4998 | |||
4999 | rule__Real__Group_2_1__0 | ||
5000 | @init { | ||
5001 | int stackSize = keepStackSize(); | ||
5002 | } | ||
5003 | : | ||
5004 | rule__Real__Group_2_1__0__Impl | ||
5005 | rule__Real__Group_2_1__1 | ||
5006 | ; | ||
5007 | finally { | ||
5008 | restoreStackSize(stackSize); | ||
5009 | } | ||
5010 | |||
5011 | rule__Real__Group_2_1__0__Impl | ||
5012 | @init { | ||
5013 | int stackSize = keepStackSize(); | ||
5014 | } | ||
5015 | : | ||
5016 | ( | ||
5017 | { before(grammarAccess.getRealAccess().getGroup_2_1_0()); } | ||
5018 | (rule__Real__Group_2_1_0__0)? | ||
5019 | { after(grammarAccess.getRealAccess().getGroup_2_1_0()); } | ||
5020 | ) | ||
5021 | ; | ||
5022 | finally { | ||
5023 | restoreStackSize(stackSize); | ||
5024 | } | ||
5025 | |||
5026 | rule__Real__Group_2_1__1 | ||
5027 | @init { | ||
5028 | int stackSize = keepStackSize(); | ||
5029 | } | ||
5030 | : | ||
5031 | rule__Real__Group_2_1__1__Impl | ||
5032 | rule__Real__Group_2_1__2 | ||
5033 | ; | ||
5034 | finally { | ||
5035 | restoreStackSize(stackSize); | ||
5036 | } | ||
5037 | |||
5038 | rule__Real__Group_2_1__1__Impl | ||
5039 | @init { | ||
5040 | int stackSize = keepStackSize(); | ||
5041 | } | ||
5042 | : | ||
5043 | ( | ||
5044 | { before(grammarAccess.getRealAccess().getAlternatives_2_1_1()); } | ||
5045 | (rule__Real__Alternatives_2_1_1) | ||
5046 | { after(grammarAccess.getRealAccess().getAlternatives_2_1_1()); } | ||
5047 | ) | ||
5048 | ; | ||
5049 | finally { | ||
5050 | restoreStackSize(stackSize); | ||
5051 | } | ||
5052 | |||
5053 | rule__Real__Group_2_1__2 | ||
5054 | @init { | ||
5055 | int stackSize = keepStackSize(); | ||
5056 | } | ||
5057 | : | ||
5058 | rule__Real__Group_2_1__2__Impl | ||
5059 | rule__Real__Group_2_1__3 | ||
5060 | ; | ||
5061 | finally { | ||
5062 | restoreStackSize(stackSize); | ||
5063 | } | ||
5064 | |||
5065 | rule__Real__Group_2_1__2__Impl | ||
5066 | @init { | ||
5067 | int stackSize = keepStackSize(); | ||
5068 | } | ||
5069 | : | ||
5070 | ( | ||
5071 | { before(grammarAccess.getRealAccess().getAlternatives_2_1_2()); } | ||
5072 | (rule__Real__Alternatives_2_1_2)? | ||
5073 | { after(grammarAccess.getRealAccess().getAlternatives_2_1_2()); } | ||
5074 | ) | ||
5075 | ; | ||
5076 | finally { | ||
5077 | restoreStackSize(stackSize); | ||
5078 | } | ||
5079 | |||
5080 | rule__Real__Group_2_1__3 | ||
5081 | @init { | ||
5082 | int stackSize = keepStackSize(); | ||
5083 | } | ||
5084 | : | ||
5085 | rule__Real__Group_2_1__3__Impl | ||
5086 | ; | ||
5087 | finally { | ||
5088 | restoreStackSize(stackSize); | ||
5089 | } | ||
5090 | |||
5091 | rule__Real__Group_2_1__3__Impl | ||
5092 | @init { | ||
5093 | int stackSize = keepStackSize(); | ||
5094 | } | ||
5095 | : | ||
5096 | ( | ||
5097 | { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_3()); } | ||
5098 | RULE_INT | ||
5099 | { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_3()); } | ||
5100 | ) | ||
5101 | ; | ||
5102 | finally { | ||
5103 | restoreStackSize(stackSize); | ||
5104 | } | ||
5105 | |||
5106 | |||
5107 | rule__Real__Group_2_1_0__0 | ||
5108 | @init { | ||
5109 | int stackSize = keepStackSize(); | ||
5110 | } | ||
5111 | : | ||
5112 | rule__Real__Group_2_1_0__0__Impl | ||
5113 | rule__Real__Group_2_1_0__1 | ||
5114 | ; | ||
5115 | finally { | ||
5116 | restoreStackSize(stackSize); | ||
5117 | } | ||
5118 | |||
5119 | rule__Real__Group_2_1_0__0__Impl | ||
5120 | @init { | ||
5121 | int stackSize = keepStackSize(); | ||
5122 | } | ||
5123 | : | ||
5124 | ( | ||
5125 | { before(grammarAccess.getRealAccess().getFullStopKeyword_2_1_0_0()); } | ||
5126 | '.' | ||
5127 | { after(grammarAccess.getRealAccess().getFullStopKeyword_2_1_0_0()); } | ||
5128 | ) | ||
5129 | ; | ||
5130 | finally { | ||
5131 | restoreStackSize(stackSize); | ||
5132 | } | ||
5133 | |||
5134 | rule__Real__Group_2_1_0__1 | ||
5135 | @init { | ||
5136 | int stackSize = keepStackSize(); | ||
5137 | } | ||
5138 | : | ||
5139 | rule__Real__Group_2_1_0__1__Impl | ||
5140 | ; | ||
5141 | finally { | ||
5142 | restoreStackSize(stackSize); | ||
5143 | } | ||
5144 | |||
5145 | rule__Real__Group_2_1_0__1__Impl | ||
5146 | @init { | ||
5147 | int stackSize = keepStackSize(); | ||
5148 | } | ||
5149 | : | ||
5150 | ( | ||
5151 | { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_0_1()); } | ||
5152 | RULE_INT | ||
5153 | { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_0_1()); } | ||
5154 | ) | ||
5155 | ; | ||
5156 | finally { | ||
5157 | restoreStackSize(stackSize); | ||
5158 | } | ||
5159 | |||
5160 | |||
4228 | rule__Problem__NameAssignment_0_1 | 5161 | rule__Problem__NameAssignment_0_1 |
4229 | @init { | 5162 | @init { |
4230 | int stackSize = keepStackSize(); | 5163 | int stackSize = keepStackSize(); |
@@ -4730,19 +5663,34 @@ finally { | |||
4730 | restoreStackSize(stackSize); | 5663 | restoreStackSize(stackSize); |
4731 | } | 5664 | } |
4732 | 5665 | ||
4733 | rule__Argument__VariableOrNodeAssignment | 5666 | rule__VariableOrNodeArgument__VariableOrNodeAssignment |
4734 | @init { | 5667 | @init { |
4735 | int stackSize = keepStackSize(); | 5668 | int stackSize = keepStackSize(); |
4736 | } | 5669 | } |
4737 | : | 5670 | : |
4738 | ( | 5671 | ( |
4739 | { before(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); } | 5672 | { before(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); } |
4740 | ( | 5673 | ( |
4741 | { before(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); } | 5674 | { before(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); } |
4742 | ruleQualifiedName | 5675 | ruleQualifiedName |
4743 | { after(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); } | 5676 | { after(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); } |
4744 | ) | 5677 | ) |
4745 | { after(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); } | 5678 | { after(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); } |
5679 | ) | ||
5680 | ; | ||
5681 | finally { | ||
5682 | restoreStackSize(stackSize); | ||
5683 | } | ||
5684 | |||
5685 | rule__ConstantArgument__ConstantAssignment | ||
5686 | @init { | ||
5687 | int stackSize = keepStackSize(); | ||
5688 | } | ||
5689 | : | ||
5690 | ( | ||
5691 | { before(grammarAccess.getConstantArgumentAccess().getConstantConstantParserRuleCall_0()); } | ||
5692 | ruleConstant | ||
5693 | { after(grammarAccess.getConstantArgumentAccess().getConstantConstantParserRuleCall_0()); } | ||
4746 | ) | 5694 | ) |
4747 | ; | 5695 | ; |
4748 | finally { | 5696 | finally { |
@@ -4774,13 +5722,9 @@ rule__Assertion__ArgumentsAssignment_0_0_2_0 | |||
4774 | } | 5722 | } |
4775 | : | 5723 | : |
4776 | ( | 5724 | ( |
4777 | { before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); } | 5725 | { before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0()); } |
4778 | ( | 5726 | ruleAssertionArgument |
4779 | { before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1()); } | 5727 | { after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0()); } |
4780 | ruleQualifiedName | ||
4781 | { after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1()); } | ||
4782 | ) | ||
4783 | { after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); } | ||
4784 | ) | 5728 | ) |
4785 | ; | 5729 | ; |
4786 | finally { | 5730 | finally { |
@@ -4793,13 +5737,9 @@ rule__Assertion__ArgumentsAssignment_0_0_2_1_1 | |||
4793 | } | 5737 | } |
4794 | : | 5738 | : |
4795 | ( | 5739 | ( |
4796 | { before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); } | 5740 | { before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0()); } |
4797 | ( | 5741 | ruleAssertionArgument |
4798 | { before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1()); } | 5742 | { after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0()); } |
4799 | ruleQualifiedName | ||
4800 | { after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1()); } | ||
4801 | ) | ||
4802 | { after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); } | ||
4803 | ) | 5743 | ) |
4804 | ; | 5744 | ; |
4805 | finally { | 5745 | finally { |
@@ -4861,32 +5801,137 @@ rule__Assertion__ArgumentsAssignment_0_1_3_0 | |||
4861 | } | 5801 | } |
4862 | : | 5802 | : |
4863 | ( | 5803 | ( |
4864 | { before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); } | 5804 | { before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0()); } |
5805 | ruleAssertionArgument | ||
5806 | { after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0()); } | ||
5807 | ) | ||
5808 | ; | ||
5809 | finally { | ||
5810 | restoreStackSize(stackSize); | ||
5811 | } | ||
5812 | |||
5813 | rule__Assertion__ArgumentsAssignment_0_1_3_1_1 | ||
5814 | @init { | ||
5815 | int stackSize = keepStackSize(); | ||
5816 | } | ||
5817 | : | ||
5818 | ( | ||
5819 | { before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0()); } | ||
5820 | ruleAssertionArgument | ||
5821 | { after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0()); } | ||
5822 | ) | ||
5823 | ; | ||
5824 | finally { | ||
5825 | restoreStackSize(stackSize); | ||
5826 | } | ||
5827 | |||
5828 | rule__NodeAssertionArgument__NodeAssignment | ||
5829 | @init { | ||
5830 | int stackSize = keepStackSize(); | ||
5831 | } | ||
5832 | : | ||
5833 | ( | ||
5834 | { before(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeCrossReference_0()); } | ||
4865 | ( | 5835 | ( |
4866 | { before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1()); } | 5836 | { before(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeQualifiedNameParserRuleCall_0_1()); } |
4867 | ruleQualifiedName | 5837 | ruleQualifiedName |
4868 | { after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1()); } | 5838 | { after(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeQualifiedNameParserRuleCall_0_1()); } |
4869 | ) | 5839 | ) |
4870 | { after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); } | 5840 | { after(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeCrossReference_0()); } |
4871 | ) | 5841 | ) |
4872 | ; | 5842 | ; |
4873 | finally { | 5843 | finally { |
4874 | restoreStackSize(stackSize); | 5844 | restoreStackSize(stackSize); |
4875 | } | 5845 | } |
4876 | 5846 | ||
4877 | rule__Assertion__ArgumentsAssignment_0_1_3_1_1 | 5847 | rule__ConstantAssertionArgument__ConstantAssignment |
4878 | @init { | 5848 | @init { |
4879 | int stackSize = keepStackSize(); | 5849 | int stackSize = keepStackSize(); |
4880 | } | 5850 | } |
4881 | : | 5851 | : |
4882 | ( | 5852 | ( |
4883 | { before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); } | 5853 | { before(grammarAccess.getConstantAssertionArgumentAccess().getConstantConstantParserRuleCall_0()); } |
5854 | ruleConstant | ||
5855 | { after(grammarAccess.getConstantAssertionArgumentAccess().getConstantConstantParserRuleCall_0()); } | ||
5856 | ) | ||
5857 | ; | ||
5858 | finally { | ||
5859 | restoreStackSize(stackSize); | ||
5860 | } | ||
5861 | |||
5862 | rule__NodeValueAssertion__NodeAssignment_0 | ||
5863 | @init { | ||
5864 | int stackSize = keepStackSize(); | ||
5865 | } | ||
5866 | : | ||
5867 | ( | ||
5868 | { before(grammarAccess.getNodeValueAssertionAccess().getNodeNodeCrossReference_0_0()); } | ||
4884 | ( | 5869 | ( |
4885 | { before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1()); } | 5870 | { before(grammarAccess.getNodeValueAssertionAccess().getNodeNodeQualifiedNameParserRuleCall_0_0_1()); } |
4886 | ruleQualifiedName | 5871 | ruleQualifiedName |
4887 | { after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1()); } | 5872 | { after(grammarAccess.getNodeValueAssertionAccess().getNodeNodeQualifiedNameParserRuleCall_0_0_1()); } |
4888 | ) | 5873 | ) |
4889 | { after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); } | 5874 | { after(grammarAccess.getNodeValueAssertionAccess().getNodeNodeCrossReference_0_0()); } |
5875 | ) | ||
5876 | ; | ||
5877 | finally { | ||
5878 | restoreStackSize(stackSize); | ||
5879 | } | ||
5880 | |||
5881 | rule__NodeValueAssertion__ValueAssignment_2 | ||
5882 | @init { | ||
5883 | int stackSize = keepStackSize(); | ||
5884 | } | ||
5885 | : | ||
5886 | ( | ||
5887 | { before(grammarAccess.getNodeValueAssertionAccess().getValueConstantParserRuleCall_2_0()); } | ||
5888 | ruleConstant | ||
5889 | { after(grammarAccess.getNodeValueAssertionAccess().getValueConstantParserRuleCall_2_0()); } | ||
5890 | ) | ||
5891 | ; | ||
5892 | finally { | ||
5893 | restoreStackSize(stackSize); | ||
5894 | } | ||
5895 | |||
5896 | rule__IntConstant__IntValueAssignment | ||
5897 | @init { | ||
5898 | int stackSize = keepStackSize(); | ||
5899 | } | ||
5900 | : | ||
5901 | ( | ||
5902 | { before(grammarAccess.getIntConstantAccess().getIntValueIntegerParserRuleCall_0()); } | ||
5903 | ruleInteger | ||
5904 | { after(grammarAccess.getIntConstantAccess().getIntValueIntegerParserRuleCall_0()); } | ||
5905 | ) | ||
5906 | ; | ||
5907 | finally { | ||
5908 | restoreStackSize(stackSize); | ||
5909 | } | ||
5910 | |||
5911 | rule__RealConstant__RealValueAssignment | ||
5912 | @init { | ||
5913 | int stackSize = keepStackSize(); | ||
5914 | } | ||
5915 | : | ||
5916 | ( | ||
5917 | { before(grammarAccess.getRealConstantAccess().getRealValueRealParserRuleCall_0()); } | ||
5918 | ruleReal | ||
5919 | { after(grammarAccess.getRealConstantAccess().getRealValueRealParserRuleCall_0()); } | ||
5920 | ) | ||
5921 | ; | ||
5922 | finally { | ||
5923 | restoreStackSize(stackSize); | ||
5924 | } | ||
5925 | |||
5926 | rule__StringConstant__StringValueAssignment | ||
5927 | @init { | ||
5928 | int stackSize = keepStackSize(); | ||
5929 | } | ||
5930 | : | ||
5931 | ( | ||
5932 | { before(grammarAccess.getStringConstantAccess().getStringValueSTRINGTerminalRuleCall_0()); } | ||
5933 | RULE_STRING | ||
5934 | { after(grammarAccess.getStringConstantAccess().getStringValueSTRINGTerminalRuleCall_0()); } | ||
4890 | ) | 5935 | ) |
4891 | ; | 5936 | ; |
4892 | finally { | 5937 | finally { |
@@ -5021,14 +6066,14 @@ finally { | |||
5021 | restoreStackSize(stackSize); | 6066 | restoreStackSize(stackSize); |
5022 | } | 6067 | } |
5023 | 6068 | ||
6069 | RULE_ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
6070 | |||
5024 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; | 6071 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; |
5025 | 6072 | ||
5026 | RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; | 6073 | RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; |
5027 | 6074 | ||
5028 | RULE_SL_COMMENT : ('%'|'//') ~(('\n'|'\r'))* ('\r'? '\n')?; | 6075 | RULE_SL_COMMENT : ('%'|'//') ~(('\n'|'\r'))* ('\r'? '\n')?; |
5029 | 6076 | ||
5030 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
5031 | |||
5032 | RULE_INT : ('0'..'9')+; | 6077 | RULE_INT : ('0'..'9')+; |
5033 | 6078 | ||
5034 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | 6079 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; |
diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.tokens b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.tokens index 49838545..a9f3d8e2 100644 --- a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.tokens +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.tokens | |||
@@ -1,36 +1,39 @@ | |||
1 | '!'=22 | 1 | '!'=26 |
2 | '('=33 | 2 | '('=37 |
3 | ')'=34 | 3 | ')'=38 |
4 | '*'=18 | 4 | '*'=18 |
5 | '+'=43 | 5 | '+'=24 |
6 | '+='=44 | 6 | '+='=47 |
7 | ','=13 | 7 | ','=13 |
8 | '-'=23 | ||
8 | '.'=12 | 9 | '.'=12 |
9 | '..'=38 | 10 | '..'=42 |
10 | ':'=36 | 11 | ':'=40 |
11 | ':-'=35 | 12 | ':-'=39 |
12 | '::'=39 | 13 | '::'=43 |
13 | ';'=14 | 14 | ';'=14 |
14 | '='=17 | 15 | '='=17 |
15 | '?'=23 | 16 | '?'=27 |
16 | '['=30 | 17 | 'E'=22 |
17 | ']'=31 | 18 | '['=34 |
18 | 'abstract'=40 | 19 | ']'=35 |
19 | 'class'=25 | 20 | 'abstract'=44 |
20 | 'contains'=41 | 21 | 'class'=29 |
21 | 'enum'=29 | 22 | 'contains'=45 |
22 | 'error'=42 | 23 | 'e'=21 |
23 | 'extends'=26 | 24 | 'enum'=33 |
25 | 'error'=46 | ||
26 | 'extends'=30 | ||
24 | 'false'=20 | 27 | 'false'=20 |
25 | 'opposite'=32 | 28 | 'opposite'=36 |
26 | 'pred'=16 | 29 | 'pred'=16 |
27 | 'problem'=24 | 30 | 'problem'=28 |
28 | 'refers'=15 | 31 | 'refers'=15 |
29 | 'scope'=37 | 32 | 'scope'=41 |
30 | 'true'=19 | 33 | 'true'=19 |
31 | 'unknown'=21 | 34 | 'unknown'=25 |
32 | '{'=27 | 35 | '{'=31 |
33 | '}'=28 | 36 | '}'=32 |
34 | RULE_ANY_OTHER=11 | 37 | RULE_ANY_OTHER=11 |
35 | RULE_ID=6 | 38 | RULE_ID=6 |
36 | RULE_INT=4 | 39 | RULE_INT=4 |
@@ -72,3 +75,6 @@ T__41=41 | |||
72 | T__42=42 | 75 | T__42=42 |
73 | T__43=43 | 76 | T__43=43 |
74 | T__44=44 | 77 | T__44=44 |
78 | T__45=45 | ||
79 | T__46=46 | ||
80 | T__47=47 | ||
diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java index 36b14a55..8e000971 100644 --- a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java | |||
@@ -50,6 +50,9 @@ public class InternalProblemLexer extends Lexer { | |||
50 | public static final int RULE_WS=10; | 50 | public static final int RULE_WS=10; |
51 | public static final int RULE_ANY_OTHER=11; | 51 | public static final int RULE_ANY_OTHER=11; |
52 | public static final int T__44=44; | 52 | public static final int T__44=44; |
53 | public static final int T__45=45; | ||
54 | public static final int T__46=46; | ||
55 | public static final int T__47=47; | ||
53 | public static final int T__40=40; | 56 | public static final int T__40=40; |
54 | public static final int T__41=41; | 57 | public static final int T__41=41; |
55 | public static final int T__42=42; | 58 | public static final int T__42=42; |
@@ -257,11 +260,10 @@ public class InternalProblemLexer extends Lexer { | |||
257 | try { | 260 | try { |
258 | int _type = T__21; | 261 | int _type = T__21; |
259 | int _channel = DEFAULT_TOKEN_CHANNEL; | 262 | int _channel = DEFAULT_TOKEN_CHANNEL; |
260 | // InternalProblem.g:20:7: ( 'unknown' ) | 263 | // InternalProblem.g:20:7: ( 'e' ) |
261 | // InternalProblem.g:20:9: 'unknown' | 264 | // InternalProblem.g:20:9: 'e' |
262 | { | 265 | { |
263 | match("unknown"); | 266 | match('e'); |
264 | |||
265 | 267 | ||
266 | } | 268 | } |
267 | 269 | ||
@@ -278,10 +280,10 @@ public class InternalProblemLexer extends Lexer { | |||
278 | try { | 280 | try { |
279 | int _type = T__22; | 281 | int _type = T__22; |
280 | int _channel = DEFAULT_TOKEN_CHANNEL; | 282 | int _channel = DEFAULT_TOKEN_CHANNEL; |
281 | // InternalProblem.g:21:7: ( '!' ) | 283 | // InternalProblem.g:21:7: ( 'E' ) |
282 | // InternalProblem.g:21:9: '!' | 284 | // InternalProblem.g:21:9: 'E' |
283 | { | 285 | { |
284 | match('!'); | 286 | match('E'); |
285 | 287 | ||
286 | } | 288 | } |
287 | 289 | ||
@@ -298,10 +300,10 @@ public class InternalProblemLexer extends Lexer { | |||
298 | try { | 300 | try { |
299 | int _type = T__23; | 301 | int _type = T__23; |
300 | int _channel = DEFAULT_TOKEN_CHANNEL; | 302 | int _channel = DEFAULT_TOKEN_CHANNEL; |
301 | // InternalProblem.g:22:7: ( '?' ) | 303 | // InternalProblem.g:22:7: ( '-' ) |
302 | // InternalProblem.g:22:9: '?' | 304 | // InternalProblem.g:22:9: '-' |
303 | { | 305 | { |
304 | match('?'); | 306 | match('-'); |
305 | 307 | ||
306 | } | 308 | } |
307 | 309 | ||
@@ -318,11 +320,10 @@ public class InternalProblemLexer extends Lexer { | |||
318 | try { | 320 | try { |
319 | int _type = T__24; | 321 | int _type = T__24; |
320 | int _channel = DEFAULT_TOKEN_CHANNEL; | 322 | int _channel = DEFAULT_TOKEN_CHANNEL; |
321 | // InternalProblem.g:23:7: ( 'problem' ) | 323 | // InternalProblem.g:23:7: ( '+' ) |
322 | // InternalProblem.g:23:9: 'problem' | 324 | // InternalProblem.g:23:9: '+' |
323 | { | 325 | { |
324 | match("problem"); | 326 | match('+'); |
325 | |||
326 | 327 | ||
327 | } | 328 | } |
328 | 329 | ||
@@ -339,10 +340,10 @@ public class InternalProblemLexer extends Lexer { | |||
339 | try { | 340 | try { |
340 | int _type = T__25; | 341 | int _type = T__25; |
341 | int _channel = DEFAULT_TOKEN_CHANNEL; | 342 | int _channel = DEFAULT_TOKEN_CHANNEL; |
342 | // InternalProblem.g:24:7: ( 'class' ) | 343 | // InternalProblem.g:24:7: ( 'unknown' ) |
343 | // InternalProblem.g:24:9: 'class' | 344 | // InternalProblem.g:24:9: 'unknown' |
344 | { | 345 | { |
345 | match("class"); | 346 | match("unknown"); |
346 | 347 | ||
347 | 348 | ||
348 | } | 349 | } |
@@ -360,11 +361,10 @@ public class InternalProblemLexer extends Lexer { | |||
360 | try { | 361 | try { |
361 | int _type = T__26; | 362 | int _type = T__26; |
362 | int _channel = DEFAULT_TOKEN_CHANNEL; | 363 | int _channel = DEFAULT_TOKEN_CHANNEL; |
363 | // InternalProblem.g:25:7: ( 'extends' ) | 364 | // InternalProblem.g:25:7: ( '!' ) |
364 | // InternalProblem.g:25:9: 'extends' | 365 | // InternalProblem.g:25:9: '!' |
365 | { | 366 | { |
366 | match("extends"); | 367 | match('!'); |
367 | |||
368 | 368 | ||
369 | } | 369 | } |
370 | 370 | ||
@@ -381,10 +381,10 @@ public class InternalProblemLexer extends Lexer { | |||
381 | try { | 381 | try { |
382 | int _type = T__27; | 382 | int _type = T__27; |
383 | int _channel = DEFAULT_TOKEN_CHANNEL; | 383 | int _channel = DEFAULT_TOKEN_CHANNEL; |
384 | // InternalProblem.g:26:7: ( '{' ) | 384 | // InternalProblem.g:26:7: ( '?' ) |
385 | // InternalProblem.g:26:9: '{' | 385 | // InternalProblem.g:26:9: '?' |
386 | { | 386 | { |
387 | match('{'); | 387 | match('?'); |
388 | 388 | ||
389 | } | 389 | } |
390 | 390 | ||
@@ -401,10 +401,11 @@ public class InternalProblemLexer extends Lexer { | |||
401 | try { | 401 | try { |
402 | int _type = T__28; | 402 | int _type = T__28; |
403 | int _channel = DEFAULT_TOKEN_CHANNEL; | 403 | int _channel = DEFAULT_TOKEN_CHANNEL; |
404 | // InternalProblem.g:27:7: ( '}' ) | 404 | // InternalProblem.g:27:7: ( 'problem' ) |
405 | // InternalProblem.g:27:9: '}' | 405 | // InternalProblem.g:27:9: 'problem' |
406 | { | 406 | { |
407 | match('}'); | 407 | match("problem"); |
408 | |||
408 | 409 | ||
409 | } | 410 | } |
410 | 411 | ||
@@ -421,10 +422,10 @@ public class InternalProblemLexer extends Lexer { | |||
421 | try { | 422 | try { |
422 | int _type = T__29; | 423 | int _type = T__29; |
423 | int _channel = DEFAULT_TOKEN_CHANNEL; | 424 | int _channel = DEFAULT_TOKEN_CHANNEL; |
424 | // InternalProblem.g:28:7: ( 'enum' ) | 425 | // InternalProblem.g:28:7: ( 'class' ) |
425 | // InternalProblem.g:28:9: 'enum' | 426 | // InternalProblem.g:28:9: 'class' |
426 | { | 427 | { |
427 | match("enum"); | 428 | match("class"); |
428 | 429 | ||
429 | 430 | ||
430 | } | 431 | } |
@@ -442,10 +443,11 @@ public class InternalProblemLexer extends Lexer { | |||
442 | try { | 443 | try { |
443 | int _type = T__30; | 444 | int _type = T__30; |
444 | int _channel = DEFAULT_TOKEN_CHANNEL; | 445 | int _channel = DEFAULT_TOKEN_CHANNEL; |
445 | // InternalProblem.g:29:7: ( '[' ) | 446 | // InternalProblem.g:29:7: ( 'extends' ) |
446 | // InternalProblem.g:29:9: '[' | 447 | // InternalProblem.g:29:9: 'extends' |
447 | { | 448 | { |
448 | match('['); | 449 | match("extends"); |
450 | |||
449 | 451 | ||
450 | } | 452 | } |
451 | 453 | ||
@@ -462,10 +464,10 @@ public class InternalProblemLexer extends Lexer { | |||
462 | try { | 464 | try { |
463 | int _type = T__31; | 465 | int _type = T__31; |
464 | int _channel = DEFAULT_TOKEN_CHANNEL; | 466 | int _channel = DEFAULT_TOKEN_CHANNEL; |
465 | // InternalProblem.g:30:7: ( ']' ) | 467 | // InternalProblem.g:30:7: ( '{' ) |
466 | // InternalProblem.g:30:9: ']' | 468 | // InternalProblem.g:30:9: '{' |
467 | { | 469 | { |
468 | match(']'); | 470 | match('{'); |
469 | 471 | ||
470 | } | 472 | } |
471 | 473 | ||
@@ -482,11 +484,10 @@ public class InternalProblemLexer extends Lexer { | |||
482 | try { | 484 | try { |
483 | int _type = T__32; | 485 | int _type = T__32; |
484 | int _channel = DEFAULT_TOKEN_CHANNEL; | 486 | int _channel = DEFAULT_TOKEN_CHANNEL; |
485 | // InternalProblem.g:31:7: ( 'opposite' ) | 487 | // InternalProblem.g:31:7: ( '}' ) |
486 | // InternalProblem.g:31:9: 'opposite' | 488 | // InternalProblem.g:31:9: '}' |
487 | { | 489 | { |
488 | match("opposite"); | 490 | match('}'); |
489 | |||
490 | 491 | ||
491 | } | 492 | } |
492 | 493 | ||
@@ -503,10 +504,11 @@ public class InternalProblemLexer extends Lexer { | |||
503 | try { | 504 | try { |
504 | int _type = T__33; | 505 | int _type = T__33; |
505 | int _channel = DEFAULT_TOKEN_CHANNEL; | 506 | int _channel = DEFAULT_TOKEN_CHANNEL; |
506 | // InternalProblem.g:32:7: ( '(' ) | 507 | // InternalProblem.g:32:7: ( 'enum' ) |
507 | // InternalProblem.g:32:9: '(' | 508 | // InternalProblem.g:32:9: 'enum' |
508 | { | 509 | { |
509 | match('('); | 510 | match("enum"); |
511 | |||
510 | 512 | ||
511 | } | 513 | } |
512 | 514 | ||
@@ -523,10 +525,10 @@ public class InternalProblemLexer extends Lexer { | |||
523 | try { | 525 | try { |
524 | int _type = T__34; | 526 | int _type = T__34; |
525 | int _channel = DEFAULT_TOKEN_CHANNEL; | 527 | int _channel = DEFAULT_TOKEN_CHANNEL; |
526 | // InternalProblem.g:33:7: ( ')' ) | 528 | // InternalProblem.g:33:7: ( '[' ) |
527 | // InternalProblem.g:33:9: ')' | 529 | // InternalProblem.g:33:9: '[' |
528 | { | 530 | { |
529 | match(')'); | 531 | match('['); |
530 | 532 | ||
531 | } | 533 | } |
532 | 534 | ||
@@ -543,11 +545,10 @@ public class InternalProblemLexer extends Lexer { | |||
543 | try { | 545 | try { |
544 | int _type = T__35; | 546 | int _type = T__35; |
545 | int _channel = DEFAULT_TOKEN_CHANNEL; | 547 | int _channel = DEFAULT_TOKEN_CHANNEL; |
546 | // InternalProblem.g:34:7: ( ':-' ) | 548 | // InternalProblem.g:34:7: ( ']' ) |
547 | // InternalProblem.g:34:9: ':-' | 549 | // InternalProblem.g:34:9: ']' |
548 | { | 550 | { |
549 | match(":-"); | 551 | match(']'); |
550 | |||
551 | 552 | ||
552 | } | 553 | } |
553 | 554 | ||
@@ -564,10 +565,11 @@ public class InternalProblemLexer extends Lexer { | |||
564 | try { | 565 | try { |
565 | int _type = T__36; | 566 | int _type = T__36; |
566 | int _channel = DEFAULT_TOKEN_CHANNEL; | 567 | int _channel = DEFAULT_TOKEN_CHANNEL; |
567 | // InternalProblem.g:35:7: ( ':' ) | 568 | // InternalProblem.g:35:7: ( 'opposite' ) |
568 | // InternalProblem.g:35:9: ':' | 569 | // InternalProblem.g:35:9: 'opposite' |
569 | { | 570 | { |
570 | match(':'); | 571 | match("opposite"); |
572 | |||
571 | 573 | ||
572 | } | 574 | } |
573 | 575 | ||
@@ -584,11 +586,10 @@ public class InternalProblemLexer extends Lexer { | |||
584 | try { | 586 | try { |
585 | int _type = T__37; | 587 | int _type = T__37; |
586 | int _channel = DEFAULT_TOKEN_CHANNEL; | 588 | int _channel = DEFAULT_TOKEN_CHANNEL; |
587 | // InternalProblem.g:36:7: ( 'scope' ) | 589 | // InternalProblem.g:36:7: ( '(' ) |
588 | // InternalProblem.g:36:9: 'scope' | 590 | // InternalProblem.g:36:9: '(' |
589 | { | 591 | { |
590 | match("scope"); | 592 | match('('); |
591 | |||
592 | 593 | ||
593 | } | 594 | } |
594 | 595 | ||
@@ -605,11 +606,10 @@ public class InternalProblemLexer extends Lexer { | |||
605 | try { | 606 | try { |
606 | int _type = T__38; | 607 | int _type = T__38; |
607 | int _channel = DEFAULT_TOKEN_CHANNEL; | 608 | int _channel = DEFAULT_TOKEN_CHANNEL; |
608 | // InternalProblem.g:37:7: ( '..' ) | 609 | // InternalProblem.g:37:7: ( ')' ) |
609 | // InternalProblem.g:37:9: '..' | 610 | // InternalProblem.g:37:9: ')' |
610 | { | 611 | { |
611 | match(".."); | 612 | match(')'); |
612 | |||
613 | 613 | ||
614 | } | 614 | } |
615 | 615 | ||
@@ -626,10 +626,10 @@ public class InternalProblemLexer extends Lexer { | |||
626 | try { | 626 | try { |
627 | int _type = T__39; | 627 | int _type = T__39; |
628 | int _channel = DEFAULT_TOKEN_CHANNEL; | 628 | int _channel = DEFAULT_TOKEN_CHANNEL; |
629 | // InternalProblem.g:38:7: ( '::' ) | 629 | // InternalProblem.g:38:7: ( ':-' ) |
630 | // InternalProblem.g:38:9: '::' | 630 | // InternalProblem.g:38:9: ':-' |
631 | { | 631 | { |
632 | match("::"); | 632 | match(":-"); |
633 | 633 | ||
634 | 634 | ||
635 | } | 635 | } |
@@ -647,11 +647,10 @@ public class InternalProblemLexer extends Lexer { | |||
647 | try { | 647 | try { |
648 | int _type = T__40; | 648 | int _type = T__40; |
649 | int _channel = DEFAULT_TOKEN_CHANNEL; | 649 | int _channel = DEFAULT_TOKEN_CHANNEL; |
650 | // InternalProblem.g:39:7: ( 'abstract' ) | 650 | // InternalProblem.g:39:7: ( ':' ) |
651 | // InternalProblem.g:39:9: 'abstract' | 651 | // InternalProblem.g:39:9: ':' |
652 | { | 652 | { |
653 | match("abstract"); | 653 | match(':'); |
654 | |||
655 | 654 | ||
656 | } | 655 | } |
657 | 656 | ||
@@ -668,10 +667,10 @@ public class InternalProblemLexer extends Lexer { | |||
668 | try { | 667 | try { |
669 | int _type = T__41; | 668 | int _type = T__41; |
670 | int _channel = DEFAULT_TOKEN_CHANNEL; | 669 | int _channel = DEFAULT_TOKEN_CHANNEL; |
671 | // InternalProblem.g:40:7: ( 'contains' ) | 670 | // InternalProblem.g:40:7: ( 'scope' ) |
672 | // InternalProblem.g:40:9: 'contains' | 671 | // InternalProblem.g:40:9: 'scope' |
673 | { | 672 | { |
674 | match("contains"); | 673 | match("scope"); |
675 | 674 | ||
676 | 675 | ||
677 | } | 676 | } |
@@ -689,10 +688,10 @@ public class InternalProblemLexer extends Lexer { | |||
689 | try { | 688 | try { |
690 | int _type = T__42; | 689 | int _type = T__42; |
691 | int _channel = DEFAULT_TOKEN_CHANNEL; | 690 | int _channel = DEFAULT_TOKEN_CHANNEL; |
692 | // InternalProblem.g:41:7: ( 'error' ) | 691 | // InternalProblem.g:41:7: ( '..' ) |
693 | // InternalProblem.g:41:9: 'error' | 692 | // InternalProblem.g:41:9: '..' |
694 | { | 693 | { |
695 | match("error"); | 694 | match(".."); |
696 | 695 | ||
697 | 696 | ||
698 | } | 697 | } |
@@ -710,10 +709,11 @@ public class InternalProblemLexer extends Lexer { | |||
710 | try { | 709 | try { |
711 | int _type = T__43; | 710 | int _type = T__43; |
712 | int _channel = DEFAULT_TOKEN_CHANNEL; | 711 | int _channel = DEFAULT_TOKEN_CHANNEL; |
713 | // InternalProblem.g:42:7: ( '+' ) | 712 | // InternalProblem.g:42:7: ( '::' ) |
714 | // InternalProblem.g:42:9: '+' | 713 | // InternalProblem.g:42:9: '::' |
715 | { | 714 | { |
716 | match('+'); | 715 | match("::"); |
716 | |||
717 | 717 | ||
718 | } | 718 | } |
719 | 719 | ||
@@ -730,10 +730,10 @@ public class InternalProblemLexer extends Lexer { | |||
730 | try { | 730 | try { |
731 | int _type = T__44; | 731 | int _type = T__44; |
732 | int _channel = DEFAULT_TOKEN_CHANNEL; | 732 | int _channel = DEFAULT_TOKEN_CHANNEL; |
733 | // InternalProblem.g:43:7: ( '+=' ) | 733 | // InternalProblem.g:43:7: ( 'abstract' ) |
734 | // InternalProblem.g:43:9: '+=' | 734 | // InternalProblem.g:43:9: 'abstract' |
735 | { | 735 | { |
736 | match("+="); | 736 | match("abstract"); |
737 | 737 | ||
738 | 738 | ||
739 | } | 739 | } |
@@ -746,32 +746,156 @@ public class InternalProblemLexer extends Lexer { | |||
746 | } | 746 | } |
747 | // $ANTLR end "T__44" | 747 | // $ANTLR end "T__44" |
748 | 748 | ||
749 | // $ANTLR start "T__45" | ||
750 | public final void mT__45() throws RecognitionException { | ||
751 | try { | ||
752 | int _type = T__45; | ||
753 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
754 | // InternalProblem.g:44:7: ( 'contains' ) | ||
755 | // InternalProblem.g:44:9: 'contains' | ||
756 | { | ||
757 | match("contains"); | ||
758 | |||
759 | |||
760 | } | ||
761 | |||
762 | state.type = _type; | ||
763 | state.channel = _channel; | ||
764 | } | ||
765 | finally { | ||
766 | } | ||
767 | } | ||
768 | // $ANTLR end "T__45" | ||
769 | |||
770 | // $ANTLR start "T__46" | ||
771 | public final void mT__46() throws RecognitionException { | ||
772 | try { | ||
773 | int _type = T__46; | ||
774 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
775 | // InternalProblem.g:45:7: ( 'error' ) | ||
776 | // InternalProblem.g:45:9: 'error' | ||
777 | { | ||
778 | match("error"); | ||
779 | |||
780 | |||
781 | } | ||
782 | |||
783 | state.type = _type; | ||
784 | state.channel = _channel; | ||
785 | } | ||
786 | finally { | ||
787 | } | ||
788 | } | ||
789 | // $ANTLR end "T__46" | ||
790 | |||
791 | // $ANTLR start "T__47" | ||
792 | public final void mT__47() throws RecognitionException { | ||
793 | try { | ||
794 | int _type = T__47; | ||
795 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
796 | // InternalProblem.g:46:7: ( '+=' ) | ||
797 | // InternalProblem.g:46:9: '+=' | ||
798 | { | ||
799 | match("+="); | ||
800 | |||
801 | |||
802 | } | ||
803 | |||
804 | state.type = _type; | ||
805 | state.channel = _channel; | ||
806 | } | ||
807 | finally { | ||
808 | } | ||
809 | } | ||
810 | // $ANTLR end "T__47" | ||
811 | |||
812 | // $ANTLR start "RULE_ID" | ||
813 | public final void mRULE_ID() throws RecognitionException { | ||
814 | try { | ||
815 | int _type = RULE_ID; | ||
816 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
817 | // InternalProblem.g:6069:9: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | ||
818 | // InternalProblem.g:6069:11: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
819 | { | ||
820 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
821 | input.consume(); | ||
822 | |||
823 | } | ||
824 | else { | ||
825 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
826 | recover(mse); | ||
827 | throw mse;} | ||
828 | |||
829 | // InternalProblem.g:6069:35: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
830 | loop1: | ||
831 | do { | ||
832 | int alt1=2; | ||
833 | int LA1_0 = input.LA(1); | ||
834 | |||
835 | if ( ((LA1_0>='0' && LA1_0<='9')||(LA1_0>='A' && LA1_0<='Z')||LA1_0=='_'||(LA1_0>='a' && LA1_0<='z')) ) { | ||
836 | alt1=1; | ||
837 | } | ||
838 | |||
839 | |||
840 | switch (alt1) { | ||
841 | case 1 : | ||
842 | // InternalProblem.g: | ||
843 | { | ||
844 | if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
845 | input.consume(); | ||
846 | |||
847 | } | ||
848 | else { | ||
849 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
850 | recover(mse); | ||
851 | throw mse;} | ||
852 | |||
853 | |||
854 | } | ||
855 | break; | ||
856 | |||
857 | default : | ||
858 | break loop1; | ||
859 | } | ||
860 | } while (true); | ||
861 | |||
862 | |||
863 | } | ||
864 | |||
865 | state.type = _type; | ||
866 | state.channel = _channel; | ||
867 | } | ||
868 | finally { | ||
869 | } | ||
870 | } | ||
871 | // $ANTLR end "RULE_ID" | ||
872 | |||
749 | // $ANTLR start "RULE_STRING" | 873 | // $ANTLR start "RULE_STRING" |
750 | public final void mRULE_STRING() throws RecognitionException { | 874 | public final void mRULE_STRING() throws RecognitionException { |
751 | try { | 875 | try { |
752 | int _type = RULE_STRING; | 876 | int _type = RULE_STRING; |
753 | int _channel = DEFAULT_TOKEN_CHANNEL; | 877 | int _channel = DEFAULT_TOKEN_CHANNEL; |
754 | // InternalProblem.g:5024:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | 878 | // InternalProblem.g:6071:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) |
755 | // InternalProblem.g:5024:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | 879 | // InternalProblem.g:6071:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' |
756 | { | 880 | { |
757 | match('\"'); | 881 | match('\"'); |
758 | // InternalProblem.g:5024:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | 882 | // InternalProblem.g:6071:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* |
759 | loop1: | 883 | loop2: |
760 | do { | 884 | do { |
761 | int alt1=3; | 885 | int alt2=3; |
762 | int LA1_0 = input.LA(1); | 886 | int LA2_0 = input.LA(1); |
763 | 887 | ||
764 | if ( (LA1_0=='\\') ) { | 888 | if ( (LA2_0=='\\') ) { |
765 | alt1=1; | 889 | alt2=1; |
766 | } | 890 | } |
767 | else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { | 891 | else if ( ((LA2_0>='\u0000' && LA2_0<='!')||(LA2_0>='#' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { |
768 | alt1=2; | 892 | alt2=2; |
769 | } | 893 | } |
770 | 894 | ||
771 | 895 | ||
772 | switch (alt1) { | 896 | switch (alt2) { |
773 | case 1 : | 897 | case 1 : |
774 | // InternalProblem.g:5024:20: '\\\\' . | 898 | // InternalProblem.g:6071:20: '\\\\' . |
775 | { | 899 | { |
776 | match('\\'); | 900 | match('\\'); |
777 | matchAny(); | 901 | matchAny(); |
@@ -779,7 +903,7 @@ public class InternalProblemLexer extends Lexer { | |||
779 | } | 903 | } |
780 | break; | 904 | break; |
781 | case 2 : | 905 | case 2 : |
782 | // InternalProblem.g:5024:27: ~ ( ( '\\\\' | '\"' ) ) | 906 | // InternalProblem.g:6071:27: ~ ( ( '\\\\' | '\"' ) ) |
783 | { | 907 | { |
784 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | 908 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { |
785 | input.consume(); | 909 | input.consume(); |
@@ -795,7 +919,7 @@ public class InternalProblemLexer extends Lexer { | |||
795 | break; | 919 | break; |
796 | 920 | ||
797 | default : | 921 | default : |
798 | break loop1; | 922 | break loop2; |
799 | } | 923 | } |
800 | } while (true); | 924 | } while (true); |
801 | 925 | ||
@@ -816,27 +940,27 @@ public class InternalProblemLexer extends Lexer { | |||
816 | try { | 940 | try { |
817 | int _type = RULE_QUOTED_ID; | 941 | int _type = RULE_QUOTED_ID; |
818 | int _channel = DEFAULT_TOKEN_CHANNEL; | 942 | int _channel = DEFAULT_TOKEN_CHANNEL; |
819 | // InternalProblem.g:5026:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | 943 | // InternalProblem.g:6073:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) |
820 | // InternalProblem.g:5026:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | 944 | // InternalProblem.g:6073:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' |
821 | { | 945 | { |
822 | match('\''); | 946 | match('\''); |
823 | // InternalProblem.g:5026:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* | 947 | // InternalProblem.g:6073:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* |
824 | loop2: | 948 | loop3: |
825 | do { | 949 | do { |
826 | int alt2=3; | 950 | int alt3=3; |
827 | int LA2_0 = input.LA(1); | 951 | int LA3_0 = input.LA(1); |
828 | 952 | ||
829 | if ( (LA2_0=='\\') ) { | 953 | if ( (LA3_0=='\\') ) { |
830 | alt2=1; | 954 | alt3=1; |
831 | } | 955 | } |
832 | else if ( ((LA2_0>='\u0000' && LA2_0<='&')||(LA2_0>='(' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { | 956 | else if ( ((LA3_0>='\u0000' && LA3_0<='&')||(LA3_0>='(' && LA3_0<='[')||(LA3_0>=']' && LA3_0<='\uFFFF')) ) { |
833 | alt2=2; | 957 | alt3=2; |
834 | } | 958 | } |
835 | 959 | ||
836 | 960 | ||
837 | switch (alt2) { | 961 | switch (alt3) { |
838 | case 1 : | 962 | case 1 : |
839 | // InternalProblem.g:5026:24: '\\\\' . | 963 | // InternalProblem.g:6073:24: '\\\\' . |
840 | { | 964 | { |
841 | match('\\'); | 965 | match('\\'); |
842 | matchAny(); | 966 | matchAny(); |
@@ -844,7 +968,7 @@ public class InternalProblemLexer extends Lexer { | |||
844 | } | 968 | } |
845 | break; | 969 | break; |
846 | case 2 : | 970 | case 2 : |
847 | // InternalProblem.g:5026:31: ~ ( ( '\\\\' | '\\'' ) ) | 971 | // InternalProblem.g:6073:31: ~ ( ( '\\\\' | '\\'' ) ) |
848 | { | 972 | { |
849 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | 973 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { |
850 | input.consume(); | 974 | input.consume(); |
@@ -860,7 +984,7 @@ public class InternalProblemLexer extends Lexer { | |||
860 | break; | 984 | break; |
861 | 985 | ||
862 | default : | 986 | default : |
863 | break loop2; | 987 | break loop3; |
864 | } | 988 | } |
865 | } while (true); | 989 | } while (true); |
866 | 990 | ||
@@ -881,35 +1005,35 @@ public class InternalProblemLexer extends Lexer { | |||
881 | try { | 1005 | try { |
882 | int _type = RULE_SL_COMMENT; | 1006 | int _type = RULE_SL_COMMENT; |
883 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1007 | int _channel = DEFAULT_TOKEN_CHANNEL; |
884 | // InternalProblem.g:5028:17: ( ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | 1008 | // InternalProblem.g:6075:17: ( ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) |
885 | // InternalProblem.g:5028:19: ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | 1009 | // InternalProblem.g:6075:19: ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? |
886 | { | 1010 | { |
887 | // InternalProblem.g:5028:19: ( '%' | '//' ) | 1011 | // InternalProblem.g:6075:19: ( '%' | '//' ) |
888 | int alt3=2; | 1012 | int alt4=2; |
889 | int LA3_0 = input.LA(1); | 1013 | int LA4_0 = input.LA(1); |
890 | 1014 | ||
891 | if ( (LA3_0=='%') ) { | 1015 | if ( (LA4_0=='%') ) { |
892 | alt3=1; | 1016 | alt4=1; |
893 | } | 1017 | } |
894 | else if ( (LA3_0=='/') ) { | 1018 | else if ( (LA4_0=='/') ) { |
895 | alt3=2; | 1019 | alt4=2; |
896 | } | 1020 | } |
897 | else { | 1021 | else { |
898 | NoViableAltException nvae = | 1022 | NoViableAltException nvae = |
899 | new NoViableAltException("", 3, 0, input); | 1023 | new NoViableAltException("", 4, 0, input); |
900 | 1024 | ||
901 | throw nvae; | 1025 | throw nvae; |
902 | } | 1026 | } |
903 | switch (alt3) { | 1027 | switch (alt4) { |
904 | case 1 : | 1028 | case 1 : |
905 | // InternalProblem.g:5028:20: '%' | 1029 | // InternalProblem.g:6075:20: '%' |
906 | { | 1030 | { |
907 | match('%'); | 1031 | match('%'); |
908 | 1032 | ||
909 | } | 1033 | } |
910 | break; | 1034 | break; |
911 | case 2 : | 1035 | case 2 : |
912 | // InternalProblem.g:5028:24: '//' | 1036 | // InternalProblem.g:6075:24: '//' |
913 | { | 1037 | { |
914 | match("//"); | 1038 | match("//"); |
915 | 1039 | ||
@@ -919,20 +1043,20 @@ public class InternalProblemLexer extends Lexer { | |||
919 | 1043 | ||
920 | } | 1044 | } |
921 | 1045 | ||
922 | // InternalProblem.g:5028:30: (~ ( ( '\\n' | '\\r' ) ) )* | 1046 | // InternalProblem.g:6075:30: (~ ( ( '\\n' | '\\r' ) ) )* |
923 | loop4: | 1047 | loop5: |
924 | do { | 1048 | do { |
925 | int alt4=2; | 1049 | int alt5=2; |
926 | int LA4_0 = input.LA(1); | 1050 | int LA5_0 = input.LA(1); |
927 | 1051 | ||
928 | if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\f')||(LA4_0>='\u000E' && LA4_0<='\uFFFF')) ) { | 1052 | if ( ((LA5_0>='\u0000' && LA5_0<='\t')||(LA5_0>='\u000B' && LA5_0<='\f')||(LA5_0>='\u000E' && LA5_0<='\uFFFF')) ) { |
929 | alt4=1; | 1053 | alt5=1; |
930 | } | 1054 | } |
931 | 1055 | ||
932 | 1056 | ||
933 | switch (alt4) { | 1057 | switch (alt5) { |
934 | case 1 : | 1058 | case 1 : |
935 | // InternalProblem.g:5028:30: ~ ( ( '\\n' | '\\r' ) ) | 1059 | // InternalProblem.g:6075:30: ~ ( ( '\\n' | '\\r' ) ) |
936 | { | 1060 | { |
937 | 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') ) { | 1061 | 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') ) { |
938 | input.consume(); | 1062 | input.consume(); |
@@ -948,31 +1072,31 @@ public class InternalProblemLexer extends Lexer { | |||
948 | break; | 1072 | break; |
949 | 1073 | ||
950 | default : | 1074 | default : |
951 | break loop4; | 1075 | break loop5; |
952 | } | 1076 | } |
953 | } while (true); | 1077 | } while (true); |
954 | 1078 | ||
955 | // InternalProblem.g:5028:46: ( ( '\\r' )? '\\n' )? | 1079 | // InternalProblem.g:6075:46: ( ( '\\r' )? '\\n' )? |
956 | int alt6=2; | 1080 | int alt7=2; |
957 | int LA6_0 = input.LA(1); | 1081 | int LA7_0 = input.LA(1); |
958 | 1082 | ||
959 | if ( (LA6_0=='\n'||LA6_0=='\r') ) { | 1083 | if ( (LA7_0=='\n'||LA7_0=='\r') ) { |
960 | alt6=1; | 1084 | alt7=1; |
961 | } | 1085 | } |
962 | switch (alt6) { | 1086 | switch (alt7) { |
963 | case 1 : | 1087 | case 1 : |
964 | // InternalProblem.g:5028:47: ( '\\r' )? '\\n' | 1088 | // InternalProblem.g:6075:47: ( '\\r' )? '\\n' |
965 | { | 1089 | { |
966 | // InternalProblem.g:5028:47: ( '\\r' )? | 1090 | // InternalProblem.g:6075:47: ( '\\r' )? |
967 | int alt5=2; | 1091 | int alt6=2; |
968 | int LA5_0 = input.LA(1); | 1092 | int LA6_0 = input.LA(1); |
969 | 1093 | ||
970 | if ( (LA5_0=='\r') ) { | 1094 | if ( (LA6_0=='\r') ) { |
971 | alt5=1; | 1095 | alt6=1; |
972 | } | 1096 | } |
973 | switch (alt5) { | 1097 | switch (alt6) { |
974 | case 1 : | 1098 | case 1 : |
975 | // InternalProblem.g:5028:47: '\\r' | 1099 | // InternalProblem.g:6075:47: '\\r' |
976 | { | 1100 | { |
977 | match('\r'); | 1101 | match('\r'); |
978 | 1102 | ||
@@ -999,108 +1123,29 @@ public class InternalProblemLexer extends Lexer { | |||
999 | } | 1123 | } |
1000 | // $ANTLR end "RULE_SL_COMMENT" | 1124 | // $ANTLR end "RULE_SL_COMMENT" |
1001 | 1125 | ||
1002 | // $ANTLR start "RULE_ID" | 1126 | // $ANTLR start "RULE_INT" |
1003 | public final void mRULE_ID() throws RecognitionException { | 1127 | public final void mRULE_INT() throws RecognitionException { |
1004 | try { | 1128 | try { |
1005 | int _type = RULE_ID; | 1129 | int _type = RULE_INT; |
1006 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1130 | int _channel = DEFAULT_TOKEN_CHANNEL; |
1007 | // InternalProblem.g:5030:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | 1131 | // InternalProblem.g:6077:10: ( ( '0' .. '9' )+ ) |
1008 | // InternalProblem.g:5030:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | 1132 | // InternalProblem.g:6077:12: ( '0' .. '9' )+ |
1009 | { | 1133 | { |
1010 | // InternalProblem.g:5030:11: ( '^' )? | 1134 | // InternalProblem.g:6077:12: ( '0' .. '9' )+ |
1011 | int alt7=2; | 1135 | int cnt8=0; |
1012 | int LA7_0 = input.LA(1); | ||
1013 | |||
1014 | if ( (LA7_0=='^') ) { | ||
1015 | alt7=1; | ||
1016 | } | ||
1017 | switch (alt7) { | ||
1018 | case 1 : | ||
1019 | // InternalProblem.g:5030:11: '^' | ||
1020 | { | ||
1021 | match('^'); | ||
1022 | |||
1023 | } | ||
1024 | break; | ||
1025 | |||
1026 | } | ||
1027 | |||
1028 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1029 | input.consume(); | ||
1030 | |||
1031 | } | ||
1032 | else { | ||
1033 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1034 | recover(mse); | ||
1035 | throw mse;} | ||
1036 | |||
1037 | // InternalProblem.g:5030:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
1038 | loop8: | 1136 | loop8: |
1039 | do { | 1137 | do { |
1040 | int alt8=2; | 1138 | int alt8=2; |
1041 | int LA8_0 = input.LA(1); | 1139 | int LA8_0 = input.LA(1); |
1042 | 1140 | ||
1043 | if ( ((LA8_0>='0' && LA8_0<='9')||(LA8_0>='A' && LA8_0<='Z')||LA8_0=='_'||(LA8_0>='a' && LA8_0<='z')) ) { | 1141 | if ( ((LA8_0>='0' && LA8_0<='9')) ) { |
1044 | alt8=1; | 1142 | alt8=1; |
1045 | } | 1143 | } |
1046 | 1144 | ||
1047 | 1145 | ||
1048 | switch (alt8) { | 1146 | switch (alt8) { |
1049 | case 1 : | 1147 | case 1 : |
1050 | // InternalProblem.g: | 1148 | // InternalProblem.g:6077:13: '0' .. '9' |
1051 | { | ||
1052 | if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1053 | input.consume(); | ||
1054 | |||
1055 | } | ||
1056 | else { | ||
1057 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1058 | recover(mse); | ||
1059 | throw mse;} | ||
1060 | |||
1061 | |||
1062 | } | ||
1063 | break; | ||
1064 | |||
1065 | default : | ||
1066 | break loop8; | ||
1067 | } | ||
1068 | } while (true); | ||
1069 | |||
1070 | |||
1071 | } | ||
1072 | |||
1073 | state.type = _type; | ||
1074 | state.channel = _channel; | ||
1075 | } | ||
1076 | finally { | ||
1077 | } | ||
1078 | } | ||
1079 | // $ANTLR end "RULE_ID" | ||
1080 | |||
1081 | // $ANTLR start "RULE_INT" | ||
1082 | public final void mRULE_INT() throws RecognitionException { | ||
1083 | try { | ||
1084 | int _type = RULE_INT; | ||
1085 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1086 | // InternalProblem.g:5032:10: ( ( '0' .. '9' )+ ) | ||
1087 | // InternalProblem.g:5032:12: ( '0' .. '9' )+ | ||
1088 | { | ||
1089 | // InternalProblem.g:5032:12: ( '0' .. '9' )+ | ||
1090 | int cnt9=0; | ||
1091 | loop9: | ||
1092 | do { | ||
1093 | int alt9=2; | ||
1094 | int LA9_0 = input.LA(1); | ||
1095 | |||
1096 | if ( ((LA9_0>='0' && LA9_0<='9')) ) { | ||
1097 | alt9=1; | ||
1098 | } | ||
1099 | |||
1100 | |||
1101 | switch (alt9) { | ||
1102 | case 1 : | ||
1103 | // InternalProblem.g:5032:13: '0' .. '9' | ||
1104 | { | 1149 | { |
1105 | matchRange('0','9'); | 1150 | matchRange('0','9'); |
1106 | 1151 | ||
@@ -1108,12 +1153,12 @@ public class InternalProblemLexer extends Lexer { | |||
1108 | break; | 1153 | break; |
1109 | 1154 | ||
1110 | default : | 1155 | default : |
1111 | if ( cnt9 >= 1 ) break loop9; | 1156 | if ( cnt8 >= 1 ) break loop8; |
1112 | EarlyExitException eee = | 1157 | EarlyExitException eee = |
1113 | new EarlyExitException(9, input); | 1158 | new EarlyExitException(8, input); |
1114 | throw eee; | 1159 | throw eee; |
1115 | } | 1160 | } |
1116 | cnt9++; | 1161 | cnt8++; |
1117 | } while (true); | 1162 | } while (true); |
1118 | 1163 | ||
1119 | 1164 | ||
@@ -1132,37 +1177,37 @@ public class InternalProblemLexer extends Lexer { | |||
1132 | try { | 1177 | try { |
1133 | int _type = RULE_ML_COMMENT; | 1178 | int _type = RULE_ML_COMMENT; |
1134 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1179 | int _channel = DEFAULT_TOKEN_CHANNEL; |
1135 | // InternalProblem.g:5034:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | 1180 | // InternalProblem.g:6079:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) |
1136 | // InternalProblem.g:5034:19: '/*' ( options {greedy=false; } : . )* '*/' | 1181 | // InternalProblem.g:6079:19: '/*' ( options {greedy=false; } : . )* '*/' |
1137 | { | 1182 | { |
1138 | match("/*"); | 1183 | match("/*"); |
1139 | 1184 | ||
1140 | // InternalProblem.g:5034:24: ( options {greedy=false; } : . )* | 1185 | // InternalProblem.g:6079:24: ( options {greedy=false; } : . )* |
1141 | loop10: | 1186 | loop9: |
1142 | do { | 1187 | do { |
1143 | int alt10=2; | 1188 | int alt9=2; |
1144 | int LA10_0 = input.LA(1); | 1189 | int LA9_0 = input.LA(1); |
1145 | 1190 | ||
1146 | if ( (LA10_0=='*') ) { | 1191 | if ( (LA9_0=='*') ) { |
1147 | int LA10_1 = input.LA(2); | 1192 | int LA9_1 = input.LA(2); |
1148 | 1193 | ||
1149 | if ( (LA10_1=='/') ) { | 1194 | if ( (LA9_1=='/') ) { |
1150 | alt10=2; | 1195 | alt9=2; |
1151 | } | 1196 | } |
1152 | else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) { | 1197 | else if ( ((LA9_1>='\u0000' && LA9_1<='.')||(LA9_1>='0' && LA9_1<='\uFFFF')) ) { |
1153 | alt10=1; | 1198 | alt9=1; |
1154 | } | 1199 | } |
1155 | 1200 | ||
1156 | 1201 | ||
1157 | } | 1202 | } |
1158 | else if ( ((LA10_0>='\u0000' && LA10_0<=')')||(LA10_0>='+' && LA10_0<='\uFFFF')) ) { | 1203 | else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { |
1159 | alt10=1; | 1204 | alt9=1; |
1160 | } | 1205 | } |
1161 | 1206 | ||
1162 | 1207 | ||
1163 | switch (alt10) { | 1208 | switch (alt9) { |
1164 | case 1 : | 1209 | case 1 : |
1165 | // InternalProblem.g:5034:52: . | 1210 | // InternalProblem.g:6079:52: . |
1166 | { | 1211 | { |
1167 | matchAny(); | 1212 | matchAny(); |
1168 | 1213 | ||
@@ -1170,7 +1215,7 @@ public class InternalProblemLexer extends Lexer { | |||
1170 | break; | 1215 | break; |
1171 | 1216 | ||
1172 | default : | 1217 | default : |
1173 | break loop10; | 1218 | break loop9; |
1174 | } | 1219 | } |
1175 | } while (true); | 1220 | } while (true); |
1176 | 1221 | ||
@@ -1192,22 +1237,22 @@ public class InternalProblemLexer extends Lexer { | |||
1192 | try { | 1237 | try { |
1193 | int _type = RULE_WS; | 1238 | int _type = RULE_WS; |
1194 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1239 | int _channel = DEFAULT_TOKEN_CHANNEL; |
1195 | // InternalProblem.g:5036:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | 1240 | // InternalProblem.g:6081:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) |
1196 | // InternalProblem.g:5036:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | 1241 | // InternalProblem.g:6081:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ |
1197 | { | 1242 | { |
1198 | // InternalProblem.g:5036:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | 1243 | // InternalProblem.g:6081:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ |
1199 | int cnt11=0; | 1244 | int cnt10=0; |
1200 | loop11: | 1245 | loop10: |
1201 | do { | 1246 | do { |
1202 | int alt11=2; | 1247 | int alt10=2; |
1203 | int LA11_0 = input.LA(1); | 1248 | int LA10_0 = input.LA(1); |
1204 | 1249 | ||
1205 | if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) { | 1250 | if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) { |
1206 | alt11=1; | 1251 | alt10=1; |
1207 | } | 1252 | } |
1208 | 1253 | ||
1209 | 1254 | ||
1210 | switch (alt11) { | 1255 | switch (alt10) { |
1211 | case 1 : | 1256 | case 1 : |
1212 | // InternalProblem.g: | 1257 | // InternalProblem.g: |
1213 | { | 1258 | { |
@@ -1225,12 +1270,12 @@ public class InternalProblemLexer extends Lexer { | |||
1225 | break; | 1270 | break; |
1226 | 1271 | ||
1227 | default : | 1272 | default : |
1228 | if ( cnt11 >= 1 ) break loop11; | 1273 | if ( cnt10 >= 1 ) break loop10; |
1229 | EarlyExitException eee = | 1274 | EarlyExitException eee = |
1230 | new EarlyExitException(11, input); | 1275 | new EarlyExitException(10, input); |
1231 | throw eee; | 1276 | throw eee; |
1232 | } | 1277 | } |
1233 | cnt11++; | 1278 | cnt10++; |
1234 | } while (true); | 1279 | } while (true); |
1235 | 1280 | ||
1236 | 1281 | ||
@@ -1249,8 +1294,8 @@ public class InternalProblemLexer extends Lexer { | |||
1249 | try { | 1294 | try { |
1250 | int _type = RULE_ANY_OTHER; | 1295 | int _type = RULE_ANY_OTHER; |
1251 | int _channel = DEFAULT_TOKEN_CHANNEL; | 1296 | int _channel = DEFAULT_TOKEN_CHANNEL; |
1252 | // InternalProblem.g:5038:16: ( . ) | 1297 | // InternalProblem.g:6083:16: ( . ) |
1253 | // InternalProblem.g:5038:18: . | 1298 | // InternalProblem.g:6083:18: . |
1254 | { | 1299 | { |
1255 | matchAny(); | 1300 | matchAny(); |
1256 | 1301 | ||
@@ -1265,10 +1310,10 @@ public class InternalProblemLexer extends Lexer { | |||
1265 | // $ANTLR end "RULE_ANY_OTHER" | 1310 | // $ANTLR end "RULE_ANY_OTHER" |
1266 | 1311 | ||
1267 | public void mTokens() throws RecognitionException { | 1312 | public void mTokens() throws RecognitionException { |
1268 | // InternalProblem.g:1:8: ( 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 | T__42 | T__43 | T__44 | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) | 1313 | // InternalProblem.g:1:8: ( 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 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | RULE_ID | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) |
1269 | int alt12=41; | 1314 | int alt11=44; |
1270 | alt12 = dfa12.predict(input); | 1315 | alt11 = dfa11.predict(input); |
1271 | switch (alt12) { | 1316 | switch (alt11) { |
1272 | case 1 : | 1317 | case 1 : |
1273 | // InternalProblem.g:1:10: T__12 | 1318 | // InternalProblem.g:1:10: T__12 |
1274 | { | 1319 | { |
@@ -1501,56 +1546,77 @@ public class InternalProblemLexer extends Lexer { | |||
1501 | } | 1546 | } |
1502 | break; | 1547 | break; |
1503 | case 34 : | 1548 | case 34 : |
1504 | // InternalProblem.g:1:208: RULE_STRING | 1549 | // InternalProblem.g:1:208: T__45 |
1505 | { | 1550 | { |
1506 | mRULE_STRING(); | 1551 | mT__45(); |
1507 | 1552 | ||
1508 | } | 1553 | } |
1509 | break; | 1554 | break; |
1510 | case 35 : | 1555 | case 35 : |
1511 | // InternalProblem.g:1:220: RULE_QUOTED_ID | 1556 | // InternalProblem.g:1:214: T__46 |
1512 | { | 1557 | { |
1513 | mRULE_QUOTED_ID(); | 1558 | mT__46(); |
1514 | 1559 | ||
1515 | } | 1560 | } |
1516 | break; | 1561 | break; |
1517 | case 36 : | 1562 | case 36 : |
1518 | // InternalProblem.g:1:235: RULE_SL_COMMENT | 1563 | // InternalProblem.g:1:220: T__47 |
1519 | { | 1564 | { |
1520 | mRULE_SL_COMMENT(); | 1565 | mT__47(); |
1521 | 1566 | ||
1522 | } | 1567 | } |
1523 | break; | 1568 | break; |
1524 | case 37 : | 1569 | case 37 : |
1525 | // InternalProblem.g:1:251: RULE_ID | 1570 | // InternalProblem.g:1:226: RULE_ID |
1526 | { | 1571 | { |
1527 | mRULE_ID(); | 1572 | mRULE_ID(); |
1528 | 1573 | ||
1529 | } | 1574 | } |
1530 | break; | 1575 | break; |
1531 | case 38 : | 1576 | case 38 : |
1532 | // InternalProblem.g:1:259: RULE_INT | 1577 | // InternalProblem.g:1:234: RULE_STRING |
1533 | { | 1578 | { |
1534 | mRULE_INT(); | 1579 | mRULE_STRING(); |
1535 | 1580 | ||
1536 | } | 1581 | } |
1537 | break; | 1582 | break; |
1538 | case 39 : | 1583 | case 39 : |
1539 | // InternalProblem.g:1:268: RULE_ML_COMMENT | 1584 | // InternalProblem.g:1:246: RULE_QUOTED_ID |
1540 | { | 1585 | { |
1541 | mRULE_ML_COMMENT(); | 1586 | mRULE_QUOTED_ID(); |
1542 | 1587 | ||
1543 | } | 1588 | } |
1544 | break; | 1589 | break; |
1545 | case 40 : | 1590 | case 40 : |
1546 | // InternalProblem.g:1:284: RULE_WS | 1591 | // InternalProblem.g:1:261: RULE_SL_COMMENT |
1547 | { | 1592 | { |
1548 | mRULE_WS(); | 1593 | mRULE_SL_COMMENT(); |
1549 | 1594 | ||
1550 | } | 1595 | } |
1551 | break; | 1596 | break; |
1552 | case 41 : | 1597 | case 41 : |
1553 | // InternalProblem.g:1:292: RULE_ANY_OTHER | 1598 | // InternalProblem.g:1:277: RULE_INT |
1599 | { | ||
1600 | mRULE_INT(); | ||
1601 | |||
1602 | } | ||
1603 | break; | ||
1604 | case 42 : | ||
1605 | // InternalProblem.g:1:286: RULE_ML_COMMENT | ||
1606 | { | ||
1607 | mRULE_ML_COMMENT(); | ||
1608 | |||
1609 | } | ||
1610 | break; | ||
1611 | case 43 : | ||
1612 | // InternalProblem.g:1:302: RULE_WS | ||
1613 | { | ||
1614 | mRULE_WS(); | ||
1615 | |||
1616 | } | ||
1617 | break; | ||
1618 | case 44 : | ||
1619 | // InternalProblem.g:1:310: RULE_ANY_OTHER | ||
1554 | { | 1620 | { |
1555 | mRULE_ANY_OTHER(); | 1621 | mRULE_ANY_OTHER(); |
1556 | 1622 | ||
@@ -1562,78 +1628,69 @@ public class InternalProblemLexer extends Lexer { | |||
1562 | } | 1628 | } |
1563 | 1629 | ||
1564 | 1630 | ||
1565 | protected DFA12 dfa12 = new DFA12(this); | 1631 | protected DFA11 dfa11 = new DFA11(this); |
1566 | static final String DFA12_eotS = | 1632 | static final String DFA11_eotS = |
1567 | "\1\uffff\1\44\2\uffff\2\50\2\uffff\3\50\2\uffff\2\50\4\uffff\1\50\2\uffff\1\77\2\50\1\103\2\42\1\uffff\2\42\10\uffff\1\50\1\uffff\1\50\2\uffff\3\50\2\uffff\5\50\4\uffff\1\50\5\uffff\2\50\10\uffff\17\50\1\147\1\50\1\151\5\50\1\157\5\50\1\uffff\1\50\1\uffff\1\166\1\50\1\170\2\50\1\uffff\1\173\1\50\1\175\1\50\1\177\1\50\1\uffff\1\50\1\uffff\2\50\1\uffff\1\50\1\uffff\1\50\1\uffff\1\u0086\1\u0087\1\50\1\u0089\2\50\2\uffff\1\u008c\1\uffff\1\u008d\1\u008e\3\uffff"; | 1633 | "\1\uffff\1\45\2\uffff\2\51\2\uffff\2\51\1\62\1\63\1\uffff\1\66\1\51\2\uffff\1\51\4\uffff\1\51\2\uffff\1\105\2\51\1\uffff\2\43\1\uffff\1\43\7\uffff\1\51\1\uffff\1\51\2\uffff\5\51\5\uffff\1\51\2\uffff\2\51\4\uffff\1\51\5\uffff\2\51\6\uffff\17\51\1\153\1\51\1\155\2\51\1\160\10\51\1\uffff\1\51\1\uffff\1\172\1\51\1\uffff\1\174\1\51\1\176\2\51\1\u0081\1\51\1\u0083\1\51\1\uffff\1\51\1\uffff\1\51\1\uffff\2\51\1\uffff\1\51\1\uffff\1\u008a\1\u008b\1\u008c\3\51\3\uffff\1\u0090\1\u0091\1\u0092\3\uffff"; |
1568 | static final String DFA12_eofS = | 1634 | static final String DFA11_eofS = |
1569 | "\u008f\uffff"; | 1635 | "\u0093\uffff"; |
1570 | static final String DFA12_minS = | 1636 | static final String DFA11_minS = |
1571 | "\1\0\1\56\2\uffff\1\145\1\162\2\uffff\1\162\1\141\1\156\2\uffff\1\154\1\156\4\uffff\1\160\2\uffff\1\55\1\143\1\142\1\75\2\0\1\uffff\1\52\1\101\10\uffff\1\146\1\uffff\1\145\2\uffff\1\165\1\154\1\153\2\uffff\1\141\1\156\1\164\1\165\1\162\4\uffff\1\160\5\uffff\1\157\1\163\10\uffff\1\145\1\144\1\142\1\145\1\163\1\156\1\163\1\164\1\145\1\155\2\157\1\160\1\164\1\162\1\60\1\154\1\60\1\145\1\157\1\163\1\141\1\156\1\60\1\162\1\163\1\145\1\162\1\163\1\uffff\1\145\1\uffff\1\60\1\167\1\60\1\151\1\144\1\uffff\1\60\1\151\1\60\1\141\1\60\1\155\1\uffff\1\156\1\uffff\1\156\1\163\1\uffff\1\164\1\uffff\1\143\1\uffff\2\60\1\163\1\60\1\145\1\164\2\uffff\1\60\1\uffff\2\60\3\uffff"; | 1637 | "\1\0\1\56\2\uffff\1\145\1\162\2\uffff\1\162\1\141\2\60\1\uffff\1\75\1\156\2\uffff\1\154\4\uffff\1\160\2\uffff\1\55\1\143\1\142\1\uffff\2\0\1\uffff\1\52\7\uffff\1\146\1\uffff\1\145\2\uffff\1\165\1\154\1\164\1\165\1\162\5\uffff\1\153\2\uffff\1\141\1\156\4\uffff\1\160\5\uffff\1\157\1\163\6\uffff\1\145\1\144\1\142\1\145\1\163\1\145\1\155\1\157\1\156\1\163\1\164\1\157\1\160\1\164\1\162\1\60\1\154\1\60\1\145\1\156\1\60\1\162\1\157\1\163\1\141\1\163\1\145\1\162\1\163\1\uffff\1\145\1\uffff\1\60\1\144\1\uffff\1\60\1\167\1\60\2\151\1\60\1\141\1\60\1\155\1\uffff\1\163\1\uffff\1\156\1\uffff\1\156\1\164\1\uffff\1\143\1\uffff\3\60\1\163\1\145\1\164\3\uffff\3\60\3\uffff"; |
1572 | static final String DFA12_maxS = | 1638 | static final String DFA11_maxS = |
1573 | "\1\uffff\1\56\2\uffff\1\145\1\162\2\uffff\1\162\1\141\1\156\2\uffff\1\157\1\170\4\uffff\1\160\2\uffff\1\72\1\143\1\142\1\75\2\uffff\1\uffff\1\57\1\172\10\uffff\1\146\1\uffff\1\157\2\uffff\1\165\1\154\1\153\2\uffff\1\141\1\156\1\164\1\165\1\162\4\uffff\1\160\5\uffff\1\157\1\163\10\uffff\1\145\1\144\1\142\1\145\1\163\1\156\1\163\1\164\1\145\1\155\2\157\1\160\1\164\1\162\1\172\1\154\1\172\1\145\1\157\1\163\1\141\1\156\1\172\1\162\1\163\1\145\1\162\1\163\1\uffff\1\145\1\uffff\1\172\1\167\1\172\1\151\1\144\1\uffff\1\172\1\151\1\172\1\141\1\172\1\155\1\uffff\1\156\1\uffff\1\156\1\163\1\uffff\1\164\1\uffff\1\143\1\uffff\2\172\1\163\1\172\1\145\1\164\2\uffff\1\172\1\uffff\2\172\3\uffff"; | 1639 | "\1\uffff\1\56\2\uffff\1\145\1\162\2\uffff\1\162\1\141\2\172\1\uffff\1\75\1\156\2\uffff\1\157\4\uffff\1\160\2\uffff\1\72\1\143\1\142\1\uffff\2\uffff\1\uffff\1\57\7\uffff\1\146\1\uffff\1\157\2\uffff\1\165\1\154\1\164\1\165\1\162\5\uffff\1\153\2\uffff\1\141\1\156\4\uffff\1\160\5\uffff\1\157\1\163\6\uffff\1\145\1\144\1\142\1\145\1\163\1\145\1\155\1\157\1\156\1\163\1\164\1\157\1\160\1\164\1\162\1\172\1\154\1\172\1\145\1\156\1\172\1\162\1\157\1\163\1\141\1\163\1\145\1\162\1\163\1\uffff\1\145\1\uffff\1\172\1\144\1\uffff\1\172\1\167\1\172\2\151\1\172\1\141\1\172\1\155\1\uffff\1\163\1\uffff\1\156\1\uffff\1\156\1\164\1\uffff\1\143\1\uffff\3\172\1\163\1\145\1\164\3\uffff\3\172\3\uffff"; |
1574 | static final String DFA12_acceptS = | 1640 | static final String DFA11_acceptS = |
1575 | "\2\uffff\1\2\1\3\2\uffff\1\6\1\7\3\uffff\1\13\1\14\2\uffff\1\20\1\21\1\23\1\24\1\uffff\1\26\1\27\6\uffff\1\44\2\uffff\1\45\1\46\1\50\1\51\1\33\1\1\1\2\1\3\1\uffff\1\45\1\uffff\1\6\1\7\3\uffff\1\13\1\14\5\uffff\1\20\1\21\1\23\1\24\1\uffff\1\26\1\27\1\30\1\34\1\31\2\uffff\1\41\1\40\1\42\1\43\1\44\1\47\1\46\1\50\35\uffff\1\5\1\uffff\1\10\5\uffff\1\22\6\uffff\1\11\1\uffff\1\16\2\uffff\1\37\1\uffff\1\32\1\uffff\1\4\6\uffff\1\15\1\12\1\uffff\1\17\2\uffff\1\36\1\25\1\35"; | 1641 | "\2\uffff\1\2\1\3\2\uffff\1\6\1\7\4\uffff\1\14\2\uffff\1\17\1\20\1\uffff\1\24\1\25\1\27\1\30\1\uffff\1\32\1\33\3\uffff\1\45\2\uffff\1\50\1\uffff\1\51\1\53\1\54\1\37\1\1\1\2\1\3\1\uffff\1\45\1\uffff\1\6\1\7\5\uffff\1\12\1\13\1\14\1\44\1\15\1\uffff\1\17\1\20\2\uffff\1\24\1\25\1\27\1\30\1\uffff\1\32\1\33\1\34\1\40\1\35\2\uffff\1\46\1\47\1\50\1\52\1\51\1\53\35\uffff\1\5\1\uffff\1\10\2\uffff\1\26\11\uffff\1\11\1\uffff\1\43\1\uffff\1\22\2\uffff\1\36\1\uffff\1\4\6\uffff\1\21\1\23\1\16\3\uffff\1\42\1\31\1\41"; |
1576 | static final String DFA12_specialS = | 1642 | static final String DFA11_specialS = |
1577 | "\1\0\31\uffff\1\2\1\1\163\uffff}>"; | 1643 | "\1\1\34\uffff\1\2\1\0\164\uffff}>"; |
1578 | static final String[] DFA12_transitionS = { | 1644 | static final String[] DFA11_transitionS = { |
1579 | "\11\42\2\41\2\42\1\41\22\42\1\41\1\13\1\32\2\42\1\34\1\42\1\33\1\24\1\25\1\7\1\31\1\2\1\42\1\1\1\35\12\40\1\26\1\3\1\42\1\6\1\42\1\14\1\42\32\37\1\21\1\42\1\22\1\36\1\37\1\42\1\30\1\37\1\15\1\37\1\16\1\11\10\37\1\23\1\5\1\37\1\4\1\27\1\10\1\12\5\37\1\17\1\42\1\20\uff82\42", | 1645 | "\11\43\2\42\2\43\1\42\22\43\1\42\1\17\1\35\2\43\1\37\1\43\1\36\1\27\1\30\1\7\1\15\1\2\1\14\1\1\1\40\12\41\1\31\1\3\1\43\1\6\1\43\1\20\1\43\4\34\1\13\25\34\1\24\1\43\1\25\1\43\1\34\1\43\1\33\1\34\1\21\1\34\1\12\1\11\10\34\1\26\1\5\1\34\1\4\1\32\1\10\1\16\5\34\1\22\1\43\1\23\uff82\43", |
1580 | "\1\43", | 1646 | "\1\44", |
1581 | "", | 1647 | "", |
1582 | "", | 1648 | "", |
1583 | "\1\47", | 1649 | "\1\50", |
1584 | "\1\51", | 1650 | "\1\52", |
1585 | "", | 1651 | "", |
1586 | "", | 1652 | "", |
1587 | "\1\54", | ||
1588 | "\1\55", | 1653 | "\1\55", |
1589 | "\1\56", | 1654 | "\1\56", |
1655 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\15\51\1\60\3\51\1\61\5\51\1\57\2\51", | ||
1656 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
1590 | "", | 1657 | "", |
1658 | "\1\65", | ||
1659 | "\1\67", | ||
1591 | "", | 1660 | "", |
1592 | "\1\61\2\uffff\1\62", | ||
1593 | "\1\64\3\uffff\1\65\5\uffff\1\63", | ||
1594 | "", | 1661 | "", |
1662 | "\1\72\2\uffff\1\73", | ||
1595 | "", | 1663 | "", |
1596 | "", | 1664 | "", |
1597 | "", | 1665 | "", |
1598 | "\1\72", | ||
1599 | "", | 1666 | "", |
1600 | "", | ||
1601 | "\1\75\14\uffff\1\76", | ||
1602 | "\1\100", | 1667 | "\1\100", |
1603 | "\1\101", | ||
1604 | "\1\102", | ||
1605 | "\0\104", | ||
1606 | "\0\105", | ||
1607 | "", | ||
1608 | "\1\107\4\uffff\1\106", | ||
1609 | "\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1610 | "", | 1668 | "", |
1611 | "", | 1669 | "", |
1670 | "\1\103\14\uffff\1\104", | ||
1671 | "\1\106", | ||
1672 | "\1\107", | ||
1612 | "", | 1673 | "", |
1674 | "\0\110", | ||
1675 | "\0\111", | ||
1613 | "", | 1676 | "", |
1677 | "\1\113\4\uffff\1\112", | ||
1614 | "", | 1678 | "", |
1615 | "", | 1679 | "", |
1616 | "", | 1680 | "", |
1617 | "", | 1681 | "", |
1618 | "\1\112", | ||
1619 | "", | 1682 | "", |
1620 | "\1\113\11\uffff\1\114", | ||
1621 | "", | 1683 | "", |
1622 | "", | 1684 | "", |
1623 | "\1\115", | ||
1624 | "\1\116", | 1685 | "\1\116", |
1625 | "\1\117", | 1686 | "", |
1687 | "\1\117\11\uffff\1\120", | ||
1626 | "", | 1688 | "", |
1627 | "", | 1689 | "", |
1628 | "\1\120", | ||
1629 | "\1\121", | 1690 | "\1\121", |
1630 | "\1\122", | 1691 | "\1\122", |
1631 | "\1\123", | 1692 | "\1\123", |
1632 | "\1\124", | 1693 | "\1\124", |
1633 | "", | ||
1634 | "", | ||
1635 | "", | ||
1636 | "", | ||
1637 | "\1\125", | 1694 | "\1\125", |
1638 | "", | 1695 | "", |
1639 | "", | 1696 | "", |
@@ -1641,19 +1698,28 @@ public class InternalProblemLexer extends Lexer { | |||
1641 | "", | 1698 | "", |
1642 | "", | 1699 | "", |
1643 | "\1\126", | 1700 | "\1\126", |
1701 | "", | ||
1702 | "", | ||
1644 | "\1\127", | 1703 | "\1\127", |
1704 | "\1\130", | ||
1645 | "", | 1705 | "", |
1646 | "", | 1706 | "", |
1647 | "", | 1707 | "", |
1648 | "", | 1708 | "", |
1709 | "\1\131", | ||
1710 | "", | ||
1649 | "", | 1711 | "", |
1650 | "", | 1712 | "", |
1651 | "", | 1713 | "", |
1652 | "", | 1714 | "", |
1653 | "\1\130", | ||
1654 | "\1\131", | ||
1655 | "\1\132", | 1715 | "\1\132", |
1656 | "\1\133", | 1716 | "\1\133", |
1717 | "", | ||
1718 | "", | ||
1719 | "", | ||
1720 | "", | ||
1721 | "", | ||
1722 | "", | ||
1657 | "\1\134", | 1723 | "\1\134", |
1658 | "\1\135", | 1724 | "\1\135", |
1659 | "\1\136", | 1725 | "\1\136", |
@@ -1665,195 +1731,201 @@ public class InternalProblemLexer extends Lexer { | |||
1665 | "\1\144", | 1731 | "\1\144", |
1666 | "\1\145", | 1732 | "\1\145", |
1667 | "\1\146", | 1733 | "\1\146", |
1668 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | 1734 | "\1\147", |
1669 | "\1\150", | 1735 | "\1\150", |
1670 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | 1736 | "\1\151", |
1671 | "\1\152", | 1737 | "\1\152", |
1672 | "\1\153", | 1738 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", |
1673 | "\1\154", | 1739 | "\1\154", |
1674 | "\1\155", | 1740 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", |
1675 | "\1\156", | 1741 | "\1\156", |
1676 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | 1742 | "\1\157", |
1677 | "\1\160", | 1743 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", |
1678 | "\1\161", | 1744 | "\1\161", |
1679 | "\1\162", | 1745 | "\1\162", |
1680 | "\1\163", | 1746 | "\1\163", |
1681 | "\1\164", | 1747 | "\1\164", |
1682 | "", | ||
1683 | "\1\165", | 1748 | "\1\165", |
1684 | "", | 1749 | "\1\166", |
1685 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1686 | "\1\167", | 1750 | "\1\167", |
1687 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | 1751 | "\1\170", |
1688 | "\1\171", | ||
1689 | "\1\172", | ||
1690 | "", | 1752 | "", |
1691 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | 1753 | "\1\171", |
1692 | "\1\174", | ||
1693 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1694 | "\1\176", | ||
1695 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1696 | "\1\u0080", | ||
1697 | "", | 1754 | "", |
1698 | "\1\u0081", | 1755 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", |
1756 | "\1\173", | ||
1699 | "", | 1757 | "", |
1758 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
1759 | "\1\175", | ||
1760 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
1761 | "\1\177", | ||
1762 | "\1\u0080", | ||
1763 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
1700 | "\1\u0082", | 1764 | "\1\u0082", |
1701 | "\1\u0083", | 1765 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", |
1702 | "", | ||
1703 | "\1\u0084", | 1766 | "\1\u0084", |
1704 | "", | 1767 | "", |
1705 | "\1\u0085", | 1768 | "\1\u0085", |
1706 | "", | 1769 | "", |
1707 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | 1770 | "\1\u0086", |
1708 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | 1771 | "", |
1772 | "\1\u0087", | ||
1709 | "\1\u0088", | 1773 | "\1\u0088", |
1710 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1711 | "\1\u008a", | ||
1712 | "\1\u008b", | ||
1713 | "", | 1774 | "", |
1775 | "\1\u0089", | ||
1776 | "", | ||
1777 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
1778 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
1779 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
1780 | "\1\u008d", | ||
1781 | "\1\u008e", | ||
1782 | "\1\u008f", | ||
1714 | "", | 1783 | "", |
1715 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1716 | "", | 1784 | "", |
1717 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | 1785 | "", |
1718 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | 1786 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", |
1787 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
1788 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
1719 | "", | 1789 | "", |
1720 | "", | 1790 | "", |
1721 | "" | 1791 | "" |
1722 | }; | 1792 | }; |
1723 | 1793 | ||
1724 | static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); | 1794 | static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); |
1725 | static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); | 1795 | static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); |
1726 | static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); | 1796 | static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); |
1727 | static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); | 1797 | static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); |
1728 | static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); | 1798 | static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); |
1729 | static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); | 1799 | static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); |
1730 | static final short[][] DFA12_transition; | 1800 | static final short[][] DFA11_transition; |
1731 | 1801 | ||
1732 | static { | 1802 | static { |
1733 | int numStates = DFA12_transitionS.length; | 1803 | int numStates = DFA11_transitionS.length; |
1734 | DFA12_transition = new short[numStates][]; | 1804 | DFA11_transition = new short[numStates][]; |
1735 | for (int i=0; i<numStates; i++) { | 1805 | for (int i=0; i<numStates; i++) { |
1736 | DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]); | 1806 | DFA11_transition[i] = DFA.unpackEncodedString(DFA11_transitionS[i]); |
1737 | } | 1807 | } |
1738 | } | 1808 | } |
1739 | 1809 | ||
1740 | class DFA12 extends DFA { | 1810 | class DFA11 extends DFA { |
1741 | 1811 | ||
1742 | public DFA12(BaseRecognizer recognizer) { | 1812 | public DFA11(BaseRecognizer recognizer) { |
1743 | this.recognizer = recognizer; | 1813 | this.recognizer = recognizer; |
1744 | this.decisionNumber = 12; | 1814 | this.decisionNumber = 11; |
1745 | this.eot = DFA12_eot; | 1815 | this.eot = DFA11_eot; |
1746 | this.eof = DFA12_eof; | 1816 | this.eof = DFA11_eof; |
1747 | this.min = DFA12_min; | 1817 | this.min = DFA11_min; |
1748 | this.max = DFA12_max; | 1818 | this.max = DFA11_max; |
1749 | this.accept = DFA12_accept; | 1819 | this.accept = DFA11_accept; |
1750 | this.special = DFA12_special; | 1820 | this.special = DFA11_special; |
1751 | this.transition = DFA12_transition; | 1821 | this.transition = DFA11_transition; |
1752 | } | 1822 | } |
1753 | public String getDescription() { | 1823 | public String getDescription() { |
1754 | return "1:1: Tokens : ( 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 | T__42 | T__43 | T__44 | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | 1824 | return "1:1: Tokens : ( 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 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | RULE_ID | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER );"; |
1755 | } | 1825 | } |
1756 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | 1826 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
1757 | IntStream input = _input; | 1827 | IntStream input = _input; |
1758 | int _s = s; | 1828 | int _s = s; |
1759 | switch ( s ) { | 1829 | switch ( s ) { |
1760 | case 0 : | 1830 | case 0 : |
1761 | int LA12_0 = input.LA(1); | 1831 | int LA11_30 = input.LA(1); |
1762 | 1832 | ||
1763 | s = -1; | 1833 | s = -1; |
1764 | if ( (LA12_0=='.') ) {s = 1;} | 1834 | if ( ((LA11_30>='\u0000' && LA11_30<='\uFFFF')) ) {s = 73;} |
1835 | |||
1836 | else s = 35; | ||
1765 | 1837 | ||
1766 | else if ( (LA12_0==',') ) {s = 2;} | 1838 | if ( s>=0 ) return s; |
1839 | break; | ||
1840 | case 1 : | ||
1841 | int LA11_0 = input.LA(1); | ||
1767 | 1842 | ||
1768 | else if ( (LA12_0==';') ) {s = 3;} | 1843 | s = -1; |
1844 | if ( (LA11_0=='.') ) {s = 1;} | ||
1769 | 1845 | ||
1770 | else if ( (LA12_0=='r') ) {s = 4;} | 1846 | else if ( (LA11_0==',') ) {s = 2;} |
1771 | 1847 | ||
1772 | else if ( (LA12_0=='p') ) {s = 5;} | 1848 | else if ( (LA11_0==';') ) {s = 3;} |
1773 | 1849 | ||
1774 | else if ( (LA12_0=='=') ) {s = 6;} | 1850 | else if ( (LA11_0=='r') ) {s = 4;} |
1775 | 1851 | ||
1776 | else if ( (LA12_0=='*') ) {s = 7;} | 1852 | else if ( (LA11_0=='p') ) {s = 5;} |
1777 | 1853 | ||
1778 | else if ( (LA12_0=='t') ) {s = 8;} | 1854 | else if ( (LA11_0=='=') ) {s = 6;} |
1779 | 1855 | ||
1780 | else if ( (LA12_0=='f') ) {s = 9;} | 1856 | else if ( (LA11_0=='*') ) {s = 7;} |
1781 | 1857 | ||
1782 | else if ( (LA12_0=='u') ) {s = 10;} | 1858 | else if ( (LA11_0=='t') ) {s = 8;} |
1783 | 1859 | ||
1784 | else if ( (LA12_0=='!') ) {s = 11;} | 1860 | else if ( (LA11_0=='f') ) {s = 9;} |
1785 | 1861 | ||
1786 | else if ( (LA12_0=='?') ) {s = 12;} | 1862 | else if ( (LA11_0=='e') ) {s = 10;} |
1787 | 1863 | ||
1788 | else if ( (LA12_0=='c') ) {s = 13;} | 1864 | else if ( (LA11_0=='E') ) {s = 11;} |
1789 | 1865 | ||
1790 | else if ( (LA12_0=='e') ) {s = 14;} | 1866 | else if ( (LA11_0=='-') ) {s = 12;} |
1791 | 1867 | ||
1792 | else if ( (LA12_0=='{') ) {s = 15;} | 1868 | else if ( (LA11_0=='+') ) {s = 13;} |
1793 | 1869 | ||
1794 | else if ( (LA12_0=='}') ) {s = 16;} | 1870 | else if ( (LA11_0=='u') ) {s = 14;} |
1795 | 1871 | ||
1796 | else if ( (LA12_0=='[') ) {s = 17;} | 1872 | else if ( (LA11_0=='!') ) {s = 15;} |
1797 | 1873 | ||
1798 | else if ( (LA12_0==']') ) {s = 18;} | 1874 | else if ( (LA11_0=='?') ) {s = 16;} |
1799 | 1875 | ||
1800 | else if ( (LA12_0=='o') ) {s = 19;} | 1876 | else if ( (LA11_0=='c') ) {s = 17;} |
1801 | 1877 | ||
1802 | else if ( (LA12_0=='(') ) {s = 20;} | 1878 | else if ( (LA11_0=='{') ) {s = 18;} |
1803 | 1879 | ||
1804 | else if ( (LA12_0==')') ) {s = 21;} | 1880 | else if ( (LA11_0=='}') ) {s = 19;} |
1805 | 1881 | ||
1806 | else if ( (LA12_0==':') ) {s = 22;} | 1882 | else if ( (LA11_0=='[') ) {s = 20;} |
1807 | 1883 | ||
1808 | else if ( (LA12_0=='s') ) {s = 23;} | 1884 | else if ( (LA11_0==']') ) {s = 21;} |
1809 | 1885 | ||
1810 | else if ( (LA12_0=='a') ) {s = 24;} | 1886 | else if ( (LA11_0=='o') ) {s = 22;} |
1811 | 1887 | ||
1812 | else if ( (LA12_0=='+') ) {s = 25;} | 1888 | else if ( (LA11_0=='(') ) {s = 23;} |
1813 | 1889 | ||
1814 | else if ( (LA12_0=='\"') ) {s = 26;} | 1890 | else if ( (LA11_0==')') ) {s = 24;} |
1815 | 1891 | ||
1816 | else if ( (LA12_0=='\'') ) {s = 27;} | 1892 | else if ( (LA11_0==':') ) {s = 25;} |
1817 | 1893 | ||
1818 | else if ( (LA12_0=='%') ) {s = 28;} | 1894 | else if ( (LA11_0=='s') ) {s = 26;} |
1819 | 1895 | ||
1820 | else if ( (LA12_0=='/') ) {s = 29;} | 1896 | else if ( (LA11_0=='a') ) {s = 27;} |
1821 | 1897 | ||
1822 | else if ( (LA12_0=='^') ) {s = 30;} | 1898 | else if ( ((LA11_0>='A' && LA11_0<='D')||(LA11_0>='F' && LA11_0<='Z')||LA11_0=='_'||LA11_0=='b'||LA11_0=='d'||(LA11_0>='g' && LA11_0<='n')||LA11_0=='q'||(LA11_0>='v' && LA11_0<='z')) ) {s = 28;} |
1823 | 1899 | ||
1824 | else if ( ((LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||LA12_0=='b'||LA12_0=='d'||(LA12_0>='g' && LA12_0<='n')||LA12_0=='q'||(LA12_0>='v' && LA12_0<='z')) ) {s = 31;} | 1900 | else if ( (LA11_0=='\"') ) {s = 29;} |
1825 | 1901 | ||
1826 | else if ( ((LA12_0>='0' && LA12_0<='9')) ) {s = 32;} | 1902 | else if ( (LA11_0=='\'') ) {s = 30;} |
1827 | 1903 | ||
1828 | else if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) {s = 33;} | 1904 | else if ( (LA11_0=='%') ) {s = 31;} |
1829 | 1905 | ||
1830 | else if ( ((LA12_0>='\u0000' && LA12_0<='\b')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='\u001F')||(LA12_0>='#' && LA12_0<='$')||LA12_0=='&'||LA12_0=='-'||LA12_0=='<'||LA12_0=='>'||LA12_0=='@'||LA12_0=='\\'||LA12_0=='`'||LA12_0=='|'||(LA12_0>='~' && LA12_0<='\uFFFF')) ) {s = 34;} | 1906 | else if ( (LA11_0=='/') ) {s = 32;} |
1831 | 1907 | ||
1832 | if ( s>=0 ) return s; | 1908 | else if ( ((LA11_0>='0' && LA11_0<='9')) ) {s = 33;} |
1833 | break; | ||
1834 | case 1 : | ||
1835 | int LA12_27 = input.LA(1); | ||
1836 | 1909 | ||
1837 | s = -1; | 1910 | else if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {s = 34;} |
1838 | if ( ((LA12_27>='\u0000' && LA12_27<='\uFFFF')) ) {s = 69;} | ||
1839 | 1911 | ||
1840 | else s = 34; | 1912 | 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=='^'||LA11_0=='`'||LA11_0=='|'||(LA11_0>='~' && LA11_0<='\uFFFF')) ) {s = 35;} |
1841 | 1913 | ||
1842 | if ( s>=0 ) return s; | 1914 | if ( s>=0 ) return s; |
1843 | break; | 1915 | break; |
1844 | case 2 : | 1916 | case 2 : |
1845 | int LA12_26 = input.LA(1); | 1917 | int LA11_29 = input.LA(1); |
1846 | 1918 | ||
1847 | s = -1; | 1919 | s = -1; |
1848 | if ( ((LA12_26>='\u0000' && LA12_26<='\uFFFF')) ) {s = 68;} | 1920 | if ( ((LA11_29>='\u0000' && LA11_29<='\uFFFF')) ) {s = 72;} |
1849 | 1921 | ||
1850 | else s = 34; | 1922 | else s = 35; |
1851 | 1923 | ||
1852 | if ( s>=0 ) return s; | 1924 | if ( s>=0 ) return s; |
1853 | break; | 1925 | break; |
1854 | } | 1926 | } |
1855 | NoViableAltException nvae = | 1927 | NoViableAltException nvae = |
1856 | new NoViableAltException(getDescription(), 12, _s, input); | 1928 | new NoViableAltException(getDescription(), 11, _s, input); |
1857 | error(nvae); | 1929 | error(nvae); |
1858 | throw nvae; | 1930 | throw nvae; |
1859 | } | 1931 | } |
diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemParser.java b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemParser.java index c93cb758..76a70bff 100644 --- a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemParser.java +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemParser.java | |||
@@ -22,7 +22,7 @@ import java.util.ArrayList; | |||
22 | @SuppressWarnings("all") | 22 | @SuppressWarnings("all") |
23 | public class InternalProblemParser extends AbstractInternalContentAssistParser { | 23 | public class InternalProblemParser extends AbstractInternalContentAssistParser { |
24 | public static final String[] tokenNames = new String[] { | 24 | public static final String[] tokenNames = new String[] { |
25 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_INT", "RULE_QUOTED_ID", "RULE_ID", "RULE_STRING", "RULE_SL_COMMENT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'.'", "','", "';'", "'refers'", "'pred'", "'='", "'*'", "'true'", "'false'", "'unknown'", "'!'", "'?'", "'problem'", "'class'", "'extends'", "'{'", "'}'", "'enum'", "'['", "']'", "'opposite'", "'('", "')'", "':-'", "':'", "'scope'", "'..'", "'::'", "'abstract'", "'contains'", "'error'", "'+'", "'+='" | 25 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_INT", "RULE_QUOTED_ID", "RULE_ID", "RULE_STRING", "RULE_SL_COMMENT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'.'", "','", "';'", "'refers'", "'pred'", "'='", "'*'", "'true'", "'false'", "'e'", "'E'", "'-'", "'+'", "'unknown'", "'!'", "'?'", "'problem'", "'class'", "'extends'", "'{'", "'}'", "'enum'", "'['", "']'", "'opposite'", "'('", "')'", "':-'", "':'", "'scope'", "'..'", "'::'", "'abstract'", "'contains'", "'error'", "'+='" |
26 | }; | 26 | }; |
27 | public static final int T__19=19; | 27 | public static final int T__19=19; |
28 | public static final int T__15=15; | 28 | public static final int T__15=15; |
@@ -62,6 +62,9 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
62 | public static final int RULE_WS=10; | 62 | public static final int RULE_WS=10; |
63 | public static final int RULE_ANY_OTHER=11; | 63 | public static final int RULE_ANY_OTHER=11; |
64 | public static final int T__44=44; | 64 | public static final int T__44=44; |
65 | public static final int T__45=45; | ||
66 | public static final int T__46=46; | ||
67 | public static final int T__47=47; | ||
65 | public static final int T__40=40; | 68 | public static final int T__40=40; |
66 | public static final int T__41=41; | 69 | public static final int T__41=41; |
67 | public static final int T__42=42; | 70 | public static final int T__42=42; |
@@ -1057,31 +1060,31 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1057 | 1060 | ||
1058 | 1061 | ||
1059 | // $ANTLR start "ruleArgument" | 1062 | // $ANTLR start "ruleArgument" |
1060 | // InternalProblem.g:362:1: ruleArgument : ( ( rule__Argument__VariableOrNodeAssignment ) ) ; | 1063 | // InternalProblem.g:362:1: ruleArgument : ( ( rule__Argument__Alternatives ) ) ; |
1061 | public final void ruleArgument() throws RecognitionException { | 1064 | public final void ruleArgument() throws RecognitionException { |
1062 | 1065 | ||
1063 | int stackSize = keepStackSize(); | 1066 | int stackSize = keepStackSize(); |
1064 | 1067 | ||
1065 | try { | 1068 | try { |
1066 | // InternalProblem.g:366:2: ( ( ( rule__Argument__VariableOrNodeAssignment ) ) ) | 1069 | // InternalProblem.g:366:2: ( ( ( rule__Argument__Alternatives ) ) ) |
1067 | // InternalProblem.g:367:2: ( ( rule__Argument__VariableOrNodeAssignment ) ) | 1070 | // InternalProblem.g:367:2: ( ( rule__Argument__Alternatives ) ) |
1068 | { | 1071 | { |
1069 | // InternalProblem.g:367:2: ( ( rule__Argument__VariableOrNodeAssignment ) ) | 1072 | // InternalProblem.g:367:2: ( ( rule__Argument__Alternatives ) ) |
1070 | // InternalProblem.g:368:3: ( rule__Argument__VariableOrNodeAssignment ) | 1073 | // InternalProblem.g:368:3: ( rule__Argument__Alternatives ) |
1071 | { | 1074 | { |
1072 | before(grammarAccess.getArgumentAccess().getVariableOrNodeAssignment()); | 1075 | before(grammarAccess.getArgumentAccess().getAlternatives()); |
1073 | // InternalProblem.g:369:3: ( rule__Argument__VariableOrNodeAssignment ) | 1076 | // InternalProblem.g:369:3: ( rule__Argument__Alternatives ) |
1074 | // InternalProblem.g:369:4: rule__Argument__VariableOrNodeAssignment | 1077 | // InternalProblem.g:369:4: rule__Argument__Alternatives |
1075 | { | 1078 | { |
1076 | pushFollow(FOLLOW_2); | 1079 | pushFollow(FOLLOW_2); |
1077 | rule__Argument__VariableOrNodeAssignment(); | 1080 | rule__Argument__Alternatives(); |
1078 | 1081 | ||
1079 | state._fsp--; | 1082 | state._fsp--; |
1080 | 1083 | ||
1081 | 1084 | ||
1082 | } | 1085 | } |
1083 | 1086 | ||
1084 | after(grammarAccess.getArgumentAccess().getVariableOrNodeAssignment()); | 1087 | after(grammarAccess.getArgumentAccess().getAlternatives()); |
1085 | 1088 | ||
1086 | } | 1089 | } |
1087 | 1090 | ||
@@ -1103,12 +1106,166 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1103 | // $ANTLR end "ruleArgument" | 1106 | // $ANTLR end "ruleArgument" |
1104 | 1107 | ||
1105 | 1108 | ||
1109 | // $ANTLR start "entryRuleVariableOrNodeArgument" | ||
1110 | // InternalProblem.g:378:1: entryRuleVariableOrNodeArgument : ruleVariableOrNodeArgument EOF ; | ||
1111 | public final void entryRuleVariableOrNodeArgument() throws RecognitionException { | ||
1112 | try { | ||
1113 | // InternalProblem.g:379:1: ( ruleVariableOrNodeArgument EOF ) | ||
1114 | // InternalProblem.g:380:1: ruleVariableOrNodeArgument EOF | ||
1115 | { | ||
1116 | before(grammarAccess.getVariableOrNodeArgumentRule()); | ||
1117 | pushFollow(FOLLOW_1); | ||
1118 | ruleVariableOrNodeArgument(); | ||
1119 | |||
1120 | state._fsp--; | ||
1121 | |||
1122 | after(grammarAccess.getVariableOrNodeArgumentRule()); | ||
1123 | match(input,EOF,FOLLOW_2); | ||
1124 | |||
1125 | } | ||
1126 | |||
1127 | } | ||
1128 | catch (RecognitionException re) { | ||
1129 | reportError(re); | ||
1130 | recover(input,re); | ||
1131 | } | ||
1132 | finally { | ||
1133 | } | ||
1134 | return ; | ||
1135 | } | ||
1136 | // $ANTLR end "entryRuleVariableOrNodeArgument" | ||
1137 | |||
1138 | |||
1139 | // $ANTLR start "ruleVariableOrNodeArgument" | ||
1140 | // InternalProblem.g:387:1: ruleVariableOrNodeArgument : ( ( rule__VariableOrNodeArgument__VariableOrNodeAssignment ) ) ; | ||
1141 | public final void ruleVariableOrNodeArgument() throws RecognitionException { | ||
1142 | |||
1143 | int stackSize = keepStackSize(); | ||
1144 | |||
1145 | try { | ||
1146 | // InternalProblem.g:391:2: ( ( ( rule__VariableOrNodeArgument__VariableOrNodeAssignment ) ) ) | ||
1147 | // InternalProblem.g:392:2: ( ( rule__VariableOrNodeArgument__VariableOrNodeAssignment ) ) | ||
1148 | { | ||
1149 | // InternalProblem.g:392:2: ( ( rule__VariableOrNodeArgument__VariableOrNodeAssignment ) ) | ||
1150 | // InternalProblem.g:393:3: ( rule__VariableOrNodeArgument__VariableOrNodeAssignment ) | ||
1151 | { | ||
1152 | before(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeAssignment()); | ||
1153 | // InternalProblem.g:394:3: ( rule__VariableOrNodeArgument__VariableOrNodeAssignment ) | ||
1154 | // InternalProblem.g:394:4: rule__VariableOrNodeArgument__VariableOrNodeAssignment | ||
1155 | { | ||
1156 | pushFollow(FOLLOW_2); | ||
1157 | rule__VariableOrNodeArgument__VariableOrNodeAssignment(); | ||
1158 | |||
1159 | state._fsp--; | ||
1160 | |||
1161 | |||
1162 | } | ||
1163 | |||
1164 | after(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeAssignment()); | ||
1165 | |||
1166 | } | ||
1167 | |||
1168 | |||
1169 | } | ||
1170 | |||
1171 | } | ||
1172 | catch (RecognitionException re) { | ||
1173 | reportError(re); | ||
1174 | recover(input,re); | ||
1175 | } | ||
1176 | finally { | ||
1177 | |||
1178 | restoreStackSize(stackSize); | ||
1179 | |||
1180 | } | ||
1181 | return ; | ||
1182 | } | ||
1183 | // $ANTLR end "ruleVariableOrNodeArgument" | ||
1184 | |||
1185 | |||
1186 | // $ANTLR start "entryRuleConstantArgument" | ||
1187 | // InternalProblem.g:403:1: entryRuleConstantArgument : ruleConstantArgument EOF ; | ||
1188 | public final void entryRuleConstantArgument() throws RecognitionException { | ||
1189 | try { | ||
1190 | // InternalProblem.g:404:1: ( ruleConstantArgument EOF ) | ||
1191 | // InternalProblem.g:405:1: ruleConstantArgument EOF | ||
1192 | { | ||
1193 | before(grammarAccess.getConstantArgumentRule()); | ||
1194 | pushFollow(FOLLOW_1); | ||
1195 | ruleConstantArgument(); | ||
1196 | |||
1197 | state._fsp--; | ||
1198 | |||
1199 | after(grammarAccess.getConstantArgumentRule()); | ||
1200 | match(input,EOF,FOLLOW_2); | ||
1201 | |||
1202 | } | ||
1203 | |||
1204 | } | ||
1205 | catch (RecognitionException re) { | ||
1206 | reportError(re); | ||
1207 | recover(input,re); | ||
1208 | } | ||
1209 | finally { | ||
1210 | } | ||
1211 | return ; | ||
1212 | } | ||
1213 | // $ANTLR end "entryRuleConstantArgument" | ||
1214 | |||
1215 | |||
1216 | // $ANTLR start "ruleConstantArgument" | ||
1217 | // InternalProblem.g:412:1: ruleConstantArgument : ( ( rule__ConstantArgument__ConstantAssignment ) ) ; | ||
1218 | public final void ruleConstantArgument() throws RecognitionException { | ||
1219 | |||
1220 | int stackSize = keepStackSize(); | ||
1221 | |||
1222 | try { | ||
1223 | // InternalProblem.g:416:2: ( ( ( rule__ConstantArgument__ConstantAssignment ) ) ) | ||
1224 | // InternalProblem.g:417:2: ( ( rule__ConstantArgument__ConstantAssignment ) ) | ||
1225 | { | ||
1226 | // InternalProblem.g:417:2: ( ( rule__ConstantArgument__ConstantAssignment ) ) | ||
1227 | // InternalProblem.g:418:3: ( rule__ConstantArgument__ConstantAssignment ) | ||
1228 | { | ||
1229 | before(grammarAccess.getConstantArgumentAccess().getConstantAssignment()); | ||
1230 | // InternalProblem.g:419:3: ( rule__ConstantArgument__ConstantAssignment ) | ||
1231 | // InternalProblem.g:419:4: rule__ConstantArgument__ConstantAssignment | ||
1232 | { | ||
1233 | pushFollow(FOLLOW_2); | ||
1234 | rule__ConstantArgument__ConstantAssignment(); | ||
1235 | |||
1236 | state._fsp--; | ||
1237 | |||
1238 | |||
1239 | } | ||
1240 | |||
1241 | after(grammarAccess.getConstantArgumentAccess().getConstantAssignment()); | ||
1242 | |||
1243 | } | ||
1244 | |||
1245 | |||
1246 | } | ||
1247 | |||
1248 | } | ||
1249 | catch (RecognitionException re) { | ||
1250 | reportError(re); | ||
1251 | recover(input,re); | ||
1252 | } | ||
1253 | finally { | ||
1254 | |||
1255 | restoreStackSize(stackSize); | ||
1256 | |||
1257 | } | ||
1258 | return ; | ||
1259 | } | ||
1260 | // $ANTLR end "ruleConstantArgument" | ||
1261 | |||
1262 | |||
1106 | // $ANTLR start "entryRuleAssertion" | 1263 | // $ANTLR start "entryRuleAssertion" |
1107 | // InternalProblem.g:378:1: entryRuleAssertion : ruleAssertion EOF ; | 1264 | // InternalProblem.g:428:1: entryRuleAssertion : ruleAssertion EOF ; |
1108 | public final void entryRuleAssertion() throws RecognitionException { | 1265 | public final void entryRuleAssertion() throws RecognitionException { |
1109 | try { | 1266 | try { |
1110 | // InternalProblem.g:379:1: ( ruleAssertion EOF ) | 1267 | // InternalProblem.g:429:1: ( ruleAssertion EOF ) |
1111 | // InternalProblem.g:380:1: ruleAssertion EOF | 1268 | // InternalProblem.g:430:1: ruleAssertion EOF |
1112 | { | 1269 | { |
1113 | before(grammarAccess.getAssertionRule()); | 1270 | before(grammarAccess.getAssertionRule()); |
1114 | pushFollow(FOLLOW_1); | 1271 | pushFollow(FOLLOW_1); |
@@ -1134,21 +1291,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1134 | 1291 | ||
1135 | 1292 | ||
1136 | // $ANTLR start "ruleAssertion" | 1293 | // $ANTLR start "ruleAssertion" |
1137 | // InternalProblem.g:387:1: ruleAssertion : ( ( rule__Assertion__Group__0 ) ) ; | 1294 | // InternalProblem.g:437:1: ruleAssertion : ( ( rule__Assertion__Group__0 ) ) ; |
1138 | public final void ruleAssertion() throws RecognitionException { | 1295 | public final void ruleAssertion() throws RecognitionException { |
1139 | 1296 | ||
1140 | int stackSize = keepStackSize(); | 1297 | int stackSize = keepStackSize(); |
1141 | 1298 | ||
1142 | try { | 1299 | try { |
1143 | // InternalProblem.g:391:2: ( ( ( rule__Assertion__Group__0 ) ) ) | 1300 | // InternalProblem.g:441:2: ( ( ( rule__Assertion__Group__0 ) ) ) |
1144 | // InternalProblem.g:392:2: ( ( rule__Assertion__Group__0 ) ) | 1301 | // InternalProblem.g:442:2: ( ( rule__Assertion__Group__0 ) ) |
1145 | { | 1302 | { |
1146 | // InternalProblem.g:392:2: ( ( rule__Assertion__Group__0 ) ) | 1303 | // InternalProblem.g:442:2: ( ( rule__Assertion__Group__0 ) ) |
1147 | // InternalProblem.g:393:3: ( rule__Assertion__Group__0 ) | 1304 | // InternalProblem.g:443:3: ( rule__Assertion__Group__0 ) |
1148 | { | 1305 | { |
1149 | before(grammarAccess.getAssertionAccess().getGroup()); | 1306 | before(grammarAccess.getAssertionAccess().getGroup()); |
1150 | // InternalProblem.g:394:3: ( rule__Assertion__Group__0 ) | 1307 | // InternalProblem.g:444:3: ( rule__Assertion__Group__0 ) |
1151 | // InternalProblem.g:394:4: rule__Assertion__Group__0 | 1308 | // InternalProblem.g:444:4: rule__Assertion__Group__0 |
1152 | { | 1309 | { |
1153 | pushFollow(FOLLOW_2); | 1310 | pushFollow(FOLLOW_2); |
1154 | rule__Assertion__Group__0(); | 1311 | rule__Assertion__Group__0(); |
@@ -1180,12 +1337,628 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1180 | // $ANTLR end "ruleAssertion" | 1337 | // $ANTLR end "ruleAssertion" |
1181 | 1338 | ||
1182 | 1339 | ||
1340 | // $ANTLR start "entryRuleAssertionArgument" | ||
1341 | // InternalProblem.g:453:1: entryRuleAssertionArgument : ruleAssertionArgument EOF ; | ||
1342 | public final void entryRuleAssertionArgument() throws RecognitionException { | ||
1343 | try { | ||
1344 | // InternalProblem.g:454:1: ( ruleAssertionArgument EOF ) | ||
1345 | // InternalProblem.g:455:1: ruleAssertionArgument EOF | ||
1346 | { | ||
1347 | before(grammarAccess.getAssertionArgumentRule()); | ||
1348 | pushFollow(FOLLOW_1); | ||
1349 | ruleAssertionArgument(); | ||
1350 | |||
1351 | state._fsp--; | ||
1352 | |||
1353 | after(grammarAccess.getAssertionArgumentRule()); | ||
1354 | match(input,EOF,FOLLOW_2); | ||
1355 | |||
1356 | } | ||
1357 | |||
1358 | } | ||
1359 | catch (RecognitionException re) { | ||
1360 | reportError(re); | ||
1361 | recover(input,re); | ||
1362 | } | ||
1363 | finally { | ||
1364 | } | ||
1365 | return ; | ||
1366 | } | ||
1367 | // $ANTLR end "entryRuleAssertionArgument" | ||
1368 | |||
1369 | |||
1370 | // $ANTLR start "ruleAssertionArgument" | ||
1371 | // InternalProblem.g:462:1: ruleAssertionArgument : ( ( rule__AssertionArgument__Alternatives ) ) ; | ||
1372 | public final void ruleAssertionArgument() throws RecognitionException { | ||
1373 | |||
1374 | int stackSize = keepStackSize(); | ||
1375 | |||
1376 | try { | ||
1377 | // InternalProblem.g:466:2: ( ( ( rule__AssertionArgument__Alternatives ) ) ) | ||
1378 | // InternalProblem.g:467:2: ( ( rule__AssertionArgument__Alternatives ) ) | ||
1379 | { | ||
1380 | // InternalProblem.g:467:2: ( ( rule__AssertionArgument__Alternatives ) ) | ||
1381 | // InternalProblem.g:468:3: ( rule__AssertionArgument__Alternatives ) | ||
1382 | { | ||
1383 | before(grammarAccess.getAssertionArgumentAccess().getAlternatives()); | ||
1384 | // InternalProblem.g:469:3: ( rule__AssertionArgument__Alternatives ) | ||
1385 | // InternalProblem.g:469:4: rule__AssertionArgument__Alternatives | ||
1386 | { | ||
1387 | pushFollow(FOLLOW_2); | ||
1388 | rule__AssertionArgument__Alternatives(); | ||
1389 | |||
1390 | state._fsp--; | ||
1391 | |||
1392 | |||
1393 | } | ||
1394 | |||
1395 | after(grammarAccess.getAssertionArgumentAccess().getAlternatives()); | ||
1396 | |||
1397 | } | ||
1398 | |||
1399 | |||
1400 | } | ||
1401 | |||
1402 | } | ||
1403 | catch (RecognitionException re) { | ||
1404 | reportError(re); | ||
1405 | recover(input,re); | ||
1406 | } | ||
1407 | finally { | ||
1408 | |||
1409 | restoreStackSize(stackSize); | ||
1410 | |||
1411 | } | ||
1412 | return ; | ||
1413 | } | ||
1414 | // $ANTLR end "ruleAssertionArgument" | ||
1415 | |||
1416 | |||
1417 | // $ANTLR start "entryRuleNodeAssertionArgument" | ||
1418 | // InternalProblem.g:478:1: entryRuleNodeAssertionArgument : ruleNodeAssertionArgument EOF ; | ||
1419 | public final void entryRuleNodeAssertionArgument() throws RecognitionException { | ||
1420 | try { | ||
1421 | // InternalProblem.g:479:1: ( ruleNodeAssertionArgument EOF ) | ||
1422 | // InternalProblem.g:480:1: ruleNodeAssertionArgument EOF | ||
1423 | { | ||
1424 | before(grammarAccess.getNodeAssertionArgumentRule()); | ||
1425 | pushFollow(FOLLOW_1); | ||
1426 | ruleNodeAssertionArgument(); | ||
1427 | |||
1428 | state._fsp--; | ||
1429 | |||
1430 | after(grammarAccess.getNodeAssertionArgumentRule()); | ||
1431 | match(input,EOF,FOLLOW_2); | ||
1432 | |||
1433 | } | ||
1434 | |||
1435 | } | ||
1436 | catch (RecognitionException re) { | ||
1437 | reportError(re); | ||
1438 | recover(input,re); | ||
1439 | } | ||
1440 | finally { | ||
1441 | } | ||
1442 | return ; | ||
1443 | } | ||
1444 | // $ANTLR end "entryRuleNodeAssertionArgument" | ||
1445 | |||
1446 | |||
1447 | // $ANTLR start "ruleNodeAssertionArgument" | ||
1448 | // InternalProblem.g:487:1: ruleNodeAssertionArgument : ( ( rule__NodeAssertionArgument__NodeAssignment ) ) ; | ||
1449 | public final void ruleNodeAssertionArgument() throws RecognitionException { | ||
1450 | |||
1451 | int stackSize = keepStackSize(); | ||
1452 | |||
1453 | try { | ||
1454 | // InternalProblem.g:491:2: ( ( ( rule__NodeAssertionArgument__NodeAssignment ) ) ) | ||
1455 | // InternalProblem.g:492:2: ( ( rule__NodeAssertionArgument__NodeAssignment ) ) | ||
1456 | { | ||
1457 | // InternalProblem.g:492:2: ( ( rule__NodeAssertionArgument__NodeAssignment ) ) | ||
1458 | // InternalProblem.g:493:3: ( rule__NodeAssertionArgument__NodeAssignment ) | ||
1459 | { | ||
1460 | before(grammarAccess.getNodeAssertionArgumentAccess().getNodeAssignment()); | ||
1461 | // InternalProblem.g:494:3: ( rule__NodeAssertionArgument__NodeAssignment ) | ||
1462 | // InternalProblem.g:494:4: rule__NodeAssertionArgument__NodeAssignment | ||
1463 | { | ||
1464 | pushFollow(FOLLOW_2); | ||
1465 | rule__NodeAssertionArgument__NodeAssignment(); | ||
1466 | |||
1467 | state._fsp--; | ||
1468 | |||
1469 | |||
1470 | } | ||
1471 | |||
1472 | after(grammarAccess.getNodeAssertionArgumentAccess().getNodeAssignment()); | ||
1473 | |||
1474 | } | ||
1475 | |||
1476 | |||
1477 | } | ||
1478 | |||
1479 | } | ||
1480 | catch (RecognitionException re) { | ||
1481 | reportError(re); | ||
1482 | recover(input,re); | ||
1483 | } | ||
1484 | finally { | ||
1485 | |||
1486 | restoreStackSize(stackSize); | ||
1487 | |||
1488 | } | ||
1489 | return ; | ||
1490 | } | ||
1491 | // $ANTLR end "ruleNodeAssertionArgument" | ||
1492 | |||
1493 | |||
1494 | // $ANTLR start "entryRuleConstantAssertionArgument" | ||
1495 | // InternalProblem.g:503:1: entryRuleConstantAssertionArgument : ruleConstantAssertionArgument EOF ; | ||
1496 | public final void entryRuleConstantAssertionArgument() throws RecognitionException { | ||
1497 | try { | ||
1498 | // InternalProblem.g:504:1: ( ruleConstantAssertionArgument EOF ) | ||
1499 | // InternalProblem.g:505:1: ruleConstantAssertionArgument EOF | ||
1500 | { | ||
1501 | before(grammarAccess.getConstantAssertionArgumentRule()); | ||
1502 | pushFollow(FOLLOW_1); | ||
1503 | ruleConstantAssertionArgument(); | ||
1504 | |||
1505 | state._fsp--; | ||
1506 | |||
1507 | after(grammarAccess.getConstantAssertionArgumentRule()); | ||
1508 | match(input,EOF,FOLLOW_2); | ||
1509 | |||
1510 | } | ||
1511 | |||
1512 | } | ||
1513 | catch (RecognitionException re) { | ||
1514 | reportError(re); | ||
1515 | recover(input,re); | ||
1516 | } | ||
1517 | finally { | ||
1518 | } | ||
1519 | return ; | ||
1520 | } | ||
1521 | // $ANTLR end "entryRuleConstantAssertionArgument" | ||
1522 | |||
1523 | |||
1524 | // $ANTLR start "ruleConstantAssertionArgument" | ||
1525 | // InternalProblem.g:512:1: ruleConstantAssertionArgument : ( ( rule__ConstantAssertionArgument__ConstantAssignment ) ) ; | ||
1526 | public final void ruleConstantAssertionArgument() throws RecognitionException { | ||
1527 | |||
1528 | int stackSize = keepStackSize(); | ||
1529 | |||
1530 | try { | ||
1531 | // InternalProblem.g:516:2: ( ( ( rule__ConstantAssertionArgument__ConstantAssignment ) ) ) | ||
1532 | // InternalProblem.g:517:2: ( ( rule__ConstantAssertionArgument__ConstantAssignment ) ) | ||
1533 | { | ||
1534 | // InternalProblem.g:517:2: ( ( rule__ConstantAssertionArgument__ConstantAssignment ) ) | ||
1535 | // InternalProblem.g:518:3: ( rule__ConstantAssertionArgument__ConstantAssignment ) | ||
1536 | { | ||
1537 | before(grammarAccess.getConstantAssertionArgumentAccess().getConstantAssignment()); | ||
1538 | // InternalProblem.g:519:3: ( rule__ConstantAssertionArgument__ConstantAssignment ) | ||
1539 | // InternalProblem.g:519:4: rule__ConstantAssertionArgument__ConstantAssignment | ||
1540 | { | ||
1541 | pushFollow(FOLLOW_2); | ||
1542 | rule__ConstantAssertionArgument__ConstantAssignment(); | ||
1543 | |||
1544 | state._fsp--; | ||
1545 | |||
1546 | |||
1547 | } | ||
1548 | |||
1549 | after(grammarAccess.getConstantAssertionArgumentAccess().getConstantAssignment()); | ||
1550 | |||
1551 | } | ||
1552 | |||
1553 | |||
1554 | } | ||
1555 | |||
1556 | } | ||
1557 | catch (RecognitionException re) { | ||
1558 | reportError(re); | ||
1559 | recover(input,re); | ||
1560 | } | ||
1561 | finally { | ||
1562 | |||
1563 | restoreStackSize(stackSize); | ||
1564 | |||
1565 | } | ||
1566 | return ; | ||
1567 | } | ||
1568 | // $ANTLR end "ruleConstantAssertionArgument" | ||
1569 | |||
1570 | |||
1571 | // $ANTLR start "entryRuleNodeValueAssertion" | ||
1572 | // InternalProblem.g:528:1: entryRuleNodeValueAssertion : ruleNodeValueAssertion EOF ; | ||
1573 | public final void entryRuleNodeValueAssertion() throws RecognitionException { | ||
1574 | try { | ||
1575 | // InternalProblem.g:529:1: ( ruleNodeValueAssertion EOF ) | ||
1576 | // InternalProblem.g:530:1: ruleNodeValueAssertion EOF | ||
1577 | { | ||
1578 | before(grammarAccess.getNodeValueAssertionRule()); | ||
1579 | pushFollow(FOLLOW_1); | ||
1580 | ruleNodeValueAssertion(); | ||
1581 | |||
1582 | state._fsp--; | ||
1583 | |||
1584 | after(grammarAccess.getNodeValueAssertionRule()); | ||
1585 | match(input,EOF,FOLLOW_2); | ||
1586 | |||
1587 | } | ||
1588 | |||
1589 | } | ||
1590 | catch (RecognitionException re) { | ||
1591 | reportError(re); | ||
1592 | recover(input,re); | ||
1593 | } | ||
1594 | finally { | ||
1595 | } | ||
1596 | return ; | ||
1597 | } | ||
1598 | // $ANTLR end "entryRuleNodeValueAssertion" | ||
1599 | |||
1600 | |||
1601 | // $ANTLR start "ruleNodeValueAssertion" | ||
1602 | // InternalProblem.g:537:1: ruleNodeValueAssertion : ( ( rule__NodeValueAssertion__Group__0 ) ) ; | ||
1603 | public final void ruleNodeValueAssertion() throws RecognitionException { | ||
1604 | |||
1605 | int stackSize = keepStackSize(); | ||
1606 | |||
1607 | try { | ||
1608 | // InternalProblem.g:541:2: ( ( ( rule__NodeValueAssertion__Group__0 ) ) ) | ||
1609 | // InternalProblem.g:542:2: ( ( rule__NodeValueAssertion__Group__0 ) ) | ||
1610 | { | ||
1611 | // InternalProblem.g:542:2: ( ( rule__NodeValueAssertion__Group__0 ) ) | ||
1612 | // InternalProblem.g:543:3: ( rule__NodeValueAssertion__Group__0 ) | ||
1613 | { | ||
1614 | before(grammarAccess.getNodeValueAssertionAccess().getGroup()); | ||
1615 | // InternalProblem.g:544:3: ( rule__NodeValueAssertion__Group__0 ) | ||
1616 | // InternalProblem.g:544:4: rule__NodeValueAssertion__Group__0 | ||
1617 | { | ||
1618 | pushFollow(FOLLOW_2); | ||
1619 | rule__NodeValueAssertion__Group__0(); | ||
1620 | |||
1621 | state._fsp--; | ||
1622 | |||
1623 | |||
1624 | } | ||
1625 | |||
1626 | after(grammarAccess.getNodeValueAssertionAccess().getGroup()); | ||
1627 | |||
1628 | } | ||
1629 | |||
1630 | |||
1631 | } | ||
1632 | |||
1633 | } | ||
1634 | catch (RecognitionException re) { | ||
1635 | reportError(re); | ||
1636 | recover(input,re); | ||
1637 | } | ||
1638 | finally { | ||
1639 | |||
1640 | restoreStackSize(stackSize); | ||
1641 | |||
1642 | } | ||
1643 | return ; | ||
1644 | } | ||
1645 | // $ANTLR end "ruleNodeValueAssertion" | ||
1646 | |||
1647 | |||
1648 | // $ANTLR start "entryRuleConstant" | ||
1649 | // InternalProblem.g:553:1: entryRuleConstant : ruleConstant EOF ; | ||
1650 | public final void entryRuleConstant() throws RecognitionException { | ||
1651 | try { | ||
1652 | // InternalProblem.g:554:1: ( ruleConstant EOF ) | ||
1653 | // InternalProblem.g:555:1: ruleConstant EOF | ||
1654 | { | ||
1655 | before(grammarAccess.getConstantRule()); | ||
1656 | pushFollow(FOLLOW_1); | ||
1657 | ruleConstant(); | ||
1658 | |||
1659 | state._fsp--; | ||
1660 | |||
1661 | after(grammarAccess.getConstantRule()); | ||
1662 | match(input,EOF,FOLLOW_2); | ||
1663 | |||
1664 | } | ||
1665 | |||
1666 | } | ||
1667 | catch (RecognitionException re) { | ||
1668 | reportError(re); | ||
1669 | recover(input,re); | ||
1670 | } | ||
1671 | finally { | ||
1672 | } | ||
1673 | return ; | ||
1674 | } | ||
1675 | // $ANTLR end "entryRuleConstant" | ||
1676 | |||
1677 | |||
1678 | // $ANTLR start "ruleConstant" | ||
1679 | // InternalProblem.g:562:1: ruleConstant : ( ( rule__Constant__Alternatives ) ) ; | ||
1680 | public final void ruleConstant() throws RecognitionException { | ||
1681 | |||
1682 | int stackSize = keepStackSize(); | ||
1683 | |||
1684 | try { | ||
1685 | // InternalProblem.g:566:2: ( ( ( rule__Constant__Alternatives ) ) ) | ||
1686 | // InternalProblem.g:567:2: ( ( rule__Constant__Alternatives ) ) | ||
1687 | { | ||
1688 | // InternalProblem.g:567:2: ( ( rule__Constant__Alternatives ) ) | ||
1689 | // InternalProblem.g:568:3: ( rule__Constant__Alternatives ) | ||
1690 | { | ||
1691 | before(grammarAccess.getConstantAccess().getAlternatives()); | ||
1692 | // InternalProblem.g:569:3: ( rule__Constant__Alternatives ) | ||
1693 | // InternalProblem.g:569:4: rule__Constant__Alternatives | ||
1694 | { | ||
1695 | pushFollow(FOLLOW_2); | ||
1696 | rule__Constant__Alternatives(); | ||
1697 | |||
1698 | state._fsp--; | ||
1699 | |||
1700 | |||
1701 | } | ||
1702 | |||
1703 | after(grammarAccess.getConstantAccess().getAlternatives()); | ||
1704 | |||
1705 | } | ||
1706 | |||
1707 | |||
1708 | } | ||
1709 | |||
1710 | } | ||
1711 | catch (RecognitionException re) { | ||
1712 | reportError(re); | ||
1713 | recover(input,re); | ||
1714 | } | ||
1715 | finally { | ||
1716 | |||
1717 | restoreStackSize(stackSize); | ||
1718 | |||
1719 | } | ||
1720 | return ; | ||
1721 | } | ||
1722 | // $ANTLR end "ruleConstant" | ||
1723 | |||
1724 | |||
1725 | // $ANTLR start "entryRuleIntConstant" | ||
1726 | // InternalProblem.g:578:1: entryRuleIntConstant : ruleIntConstant EOF ; | ||
1727 | public final void entryRuleIntConstant() throws RecognitionException { | ||
1728 | try { | ||
1729 | // InternalProblem.g:579:1: ( ruleIntConstant EOF ) | ||
1730 | // InternalProblem.g:580:1: ruleIntConstant EOF | ||
1731 | { | ||
1732 | before(grammarAccess.getIntConstantRule()); | ||
1733 | pushFollow(FOLLOW_1); | ||
1734 | ruleIntConstant(); | ||
1735 | |||
1736 | state._fsp--; | ||
1737 | |||
1738 | after(grammarAccess.getIntConstantRule()); | ||
1739 | match(input,EOF,FOLLOW_2); | ||
1740 | |||
1741 | } | ||
1742 | |||
1743 | } | ||
1744 | catch (RecognitionException re) { | ||
1745 | reportError(re); | ||
1746 | recover(input,re); | ||
1747 | } | ||
1748 | finally { | ||
1749 | } | ||
1750 | return ; | ||
1751 | } | ||
1752 | // $ANTLR end "entryRuleIntConstant" | ||
1753 | |||
1754 | |||
1755 | // $ANTLR start "ruleIntConstant" | ||
1756 | // InternalProblem.g:587:1: ruleIntConstant : ( ( rule__IntConstant__IntValueAssignment ) ) ; | ||
1757 | public final void ruleIntConstant() throws RecognitionException { | ||
1758 | |||
1759 | int stackSize = keepStackSize(); | ||
1760 | |||
1761 | try { | ||
1762 | // InternalProblem.g:591:2: ( ( ( rule__IntConstant__IntValueAssignment ) ) ) | ||
1763 | // InternalProblem.g:592:2: ( ( rule__IntConstant__IntValueAssignment ) ) | ||
1764 | { | ||
1765 | // InternalProblem.g:592:2: ( ( rule__IntConstant__IntValueAssignment ) ) | ||
1766 | // InternalProblem.g:593:3: ( rule__IntConstant__IntValueAssignment ) | ||
1767 | { | ||
1768 | before(grammarAccess.getIntConstantAccess().getIntValueAssignment()); | ||
1769 | // InternalProblem.g:594:3: ( rule__IntConstant__IntValueAssignment ) | ||
1770 | // InternalProblem.g:594:4: rule__IntConstant__IntValueAssignment | ||
1771 | { | ||
1772 | pushFollow(FOLLOW_2); | ||
1773 | rule__IntConstant__IntValueAssignment(); | ||
1774 | |||
1775 | state._fsp--; | ||
1776 | |||
1777 | |||
1778 | } | ||
1779 | |||
1780 | after(grammarAccess.getIntConstantAccess().getIntValueAssignment()); | ||
1781 | |||
1782 | } | ||
1783 | |||
1784 | |||
1785 | } | ||
1786 | |||
1787 | } | ||
1788 | catch (RecognitionException re) { | ||
1789 | reportError(re); | ||
1790 | recover(input,re); | ||
1791 | } | ||
1792 | finally { | ||
1793 | |||
1794 | restoreStackSize(stackSize); | ||
1795 | |||
1796 | } | ||
1797 | return ; | ||
1798 | } | ||
1799 | // $ANTLR end "ruleIntConstant" | ||
1800 | |||
1801 | |||
1802 | // $ANTLR start "entryRuleRealConstant" | ||
1803 | // InternalProblem.g:603:1: entryRuleRealConstant : ruleRealConstant EOF ; | ||
1804 | public final void entryRuleRealConstant() throws RecognitionException { | ||
1805 | try { | ||
1806 | // InternalProblem.g:604:1: ( ruleRealConstant EOF ) | ||
1807 | // InternalProblem.g:605:1: ruleRealConstant EOF | ||
1808 | { | ||
1809 | before(grammarAccess.getRealConstantRule()); | ||
1810 | pushFollow(FOLLOW_1); | ||
1811 | ruleRealConstant(); | ||
1812 | |||
1813 | state._fsp--; | ||
1814 | |||
1815 | after(grammarAccess.getRealConstantRule()); | ||
1816 | match(input,EOF,FOLLOW_2); | ||
1817 | |||
1818 | } | ||
1819 | |||
1820 | } | ||
1821 | catch (RecognitionException re) { | ||
1822 | reportError(re); | ||
1823 | recover(input,re); | ||
1824 | } | ||
1825 | finally { | ||
1826 | } | ||
1827 | return ; | ||
1828 | } | ||
1829 | // $ANTLR end "entryRuleRealConstant" | ||
1830 | |||
1831 | |||
1832 | // $ANTLR start "ruleRealConstant" | ||
1833 | // InternalProblem.g:612:1: ruleRealConstant : ( ( rule__RealConstant__RealValueAssignment ) ) ; | ||
1834 | public final void ruleRealConstant() throws RecognitionException { | ||
1835 | |||
1836 | int stackSize = keepStackSize(); | ||
1837 | |||
1838 | try { | ||
1839 | // InternalProblem.g:616:2: ( ( ( rule__RealConstant__RealValueAssignment ) ) ) | ||
1840 | // InternalProblem.g:617:2: ( ( rule__RealConstant__RealValueAssignment ) ) | ||
1841 | { | ||
1842 | // InternalProblem.g:617:2: ( ( rule__RealConstant__RealValueAssignment ) ) | ||
1843 | // InternalProblem.g:618:3: ( rule__RealConstant__RealValueAssignment ) | ||
1844 | { | ||
1845 | before(grammarAccess.getRealConstantAccess().getRealValueAssignment()); | ||
1846 | // InternalProblem.g:619:3: ( rule__RealConstant__RealValueAssignment ) | ||
1847 | // InternalProblem.g:619:4: rule__RealConstant__RealValueAssignment | ||
1848 | { | ||
1849 | pushFollow(FOLLOW_2); | ||
1850 | rule__RealConstant__RealValueAssignment(); | ||
1851 | |||
1852 | state._fsp--; | ||
1853 | |||
1854 | |||
1855 | } | ||
1856 | |||
1857 | after(grammarAccess.getRealConstantAccess().getRealValueAssignment()); | ||
1858 | |||
1859 | } | ||
1860 | |||
1861 | |||
1862 | } | ||
1863 | |||
1864 | } | ||
1865 | catch (RecognitionException re) { | ||
1866 | reportError(re); | ||
1867 | recover(input,re); | ||
1868 | } | ||
1869 | finally { | ||
1870 | |||
1871 | restoreStackSize(stackSize); | ||
1872 | |||
1873 | } | ||
1874 | return ; | ||
1875 | } | ||
1876 | // $ANTLR end "ruleRealConstant" | ||
1877 | |||
1878 | |||
1879 | // $ANTLR start "entryRuleStringConstant" | ||
1880 | // InternalProblem.g:628:1: entryRuleStringConstant : ruleStringConstant EOF ; | ||
1881 | public final void entryRuleStringConstant() throws RecognitionException { | ||
1882 | try { | ||
1883 | // InternalProblem.g:629:1: ( ruleStringConstant EOF ) | ||
1884 | // InternalProblem.g:630:1: ruleStringConstant EOF | ||
1885 | { | ||
1886 | before(grammarAccess.getStringConstantRule()); | ||
1887 | pushFollow(FOLLOW_1); | ||
1888 | ruleStringConstant(); | ||
1889 | |||
1890 | state._fsp--; | ||
1891 | |||
1892 | after(grammarAccess.getStringConstantRule()); | ||
1893 | match(input,EOF,FOLLOW_2); | ||
1894 | |||
1895 | } | ||
1896 | |||
1897 | } | ||
1898 | catch (RecognitionException re) { | ||
1899 | reportError(re); | ||
1900 | recover(input,re); | ||
1901 | } | ||
1902 | finally { | ||
1903 | } | ||
1904 | return ; | ||
1905 | } | ||
1906 | // $ANTLR end "entryRuleStringConstant" | ||
1907 | |||
1908 | |||
1909 | // $ANTLR start "ruleStringConstant" | ||
1910 | // InternalProblem.g:637:1: ruleStringConstant : ( ( rule__StringConstant__StringValueAssignment ) ) ; | ||
1911 | public final void ruleStringConstant() throws RecognitionException { | ||
1912 | |||
1913 | int stackSize = keepStackSize(); | ||
1914 | |||
1915 | try { | ||
1916 | // InternalProblem.g:641:2: ( ( ( rule__StringConstant__StringValueAssignment ) ) ) | ||
1917 | // InternalProblem.g:642:2: ( ( rule__StringConstant__StringValueAssignment ) ) | ||
1918 | { | ||
1919 | // InternalProblem.g:642:2: ( ( rule__StringConstant__StringValueAssignment ) ) | ||
1920 | // InternalProblem.g:643:3: ( rule__StringConstant__StringValueAssignment ) | ||
1921 | { | ||
1922 | before(grammarAccess.getStringConstantAccess().getStringValueAssignment()); | ||
1923 | // InternalProblem.g:644:3: ( rule__StringConstant__StringValueAssignment ) | ||
1924 | // InternalProblem.g:644:4: rule__StringConstant__StringValueAssignment | ||
1925 | { | ||
1926 | pushFollow(FOLLOW_2); | ||
1927 | rule__StringConstant__StringValueAssignment(); | ||
1928 | |||
1929 | state._fsp--; | ||
1930 | |||
1931 | |||
1932 | } | ||
1933 | |||
1934 | after(grammarAccess.getStringConstantAccess().getStringValueAssignment()); | ||
1935 | |||
1936 | } | ||
1937 | |||
1938 | |||
1939 | } | ||
1940 | |||
1941 | } | ||
1942 | catch (RecognitionException re) { | ||
1943 | reportError(re); | ||
1944 | recover(input,re); | ||
1945 | } | ||
1946 | finally { | ||
1947 | |||
1948 | restoreStackSize(stackSize); | ||
1949 | |||
1950 | } | ||
1951 | return ; | ||
1952 | } | ||
1953 | // $ANTLR end "ruleStringConstant" | ||
1954 | |||
1955 | |||
1183 | // $ANTLR start "entryRuleScopeDeclaration" | 1956 | // $ANTLR start "entryRuleScopeDeclaration" |
1184 | // InternalProblem.g:403:1: entryRuleScopeDeclaration : ruleScopeDeclaration EOF ; | 1957 | // InternalProblem.g:653:1: entryRuleScopeDeclaration : ruleScopeDeclaration EOF ; |
1185 | public final void entryRuleScopeDeclaration() throws RecognitionException { | 1958 | public final void entryRuleScopeDeclaration() throws RecognitionException { |
1186 | try { | 1959 | try { |
1187 | // InternalProblem.g:404:1: ( ruleScopeDeclaration EOF ) | 1960 | // InternalProblem.g:654:1: ( ruleScopeDeclaration EOF ) |
1188 | // InternalProblem.g:405:1: ruleScopeDeclaration EOF | 1961 | // InternalProblem.g:655:1: ruleScopeDeclaration EOF |
1189 | { | 1962 | { |
1190 | before(grammarAccess.getScopeDeclarationRule()); | 1963 | before(grammarAccess.getScopeDeclarationRule()); |
1191 | pushFollow(FOLLOW_1); | 1964 | pushFollow(FOLLOW_1); |
@@ -1211,21 +1984,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1211 | 1984 | ||
1212 | 1985 | ||
1213 | // $ANTLR start "ruleScopeDeclaration" | 1986 | // $ANTLR start "ruleScopeDeclaration" |
1214 | // InternalProblem.g:412:1: ruleScopeDeclaration : ( ( rule__ScopeDeclaration__Group__0 ) ) ; | 1987 | // InternalProblem.g:662:1: ruleScopeDeclaration : ( ( rule__ScopeDeclaration__Group__0 ) ) ; |
1215 | public final void ruleScopeDeclaration() throws RecognitionException { | 1988 | public final void ruleScopeDeclaration() throws RecognitionException { |
1216 | 1989 | ||
1217 | int stackSize = keepStackSize(); | 1990 | int stackSize = keepStackSize(); |
1218 | 1991 | ||
1219 | try { | 1992 | try { |
1220 | // InternalProblem.g:416:2: ( ( ( rule__ScopeDeclaration__Group__0 ) ) ) | 1993 | // InternalProblem.g:666:2: ( ( ( rule__ScopeDeclaration__Group__0 ) ) ) |
1221 | // InternalProblem.g:417:2: ( ( rule__ScopeDeclaration__Group__0 ) ) | 1994 | // InternalProblem.g:667:2: ( ( rule__ScopeDeclaration__Group__0 ) ) |
1222 | { | 1995 | { |
1223 | // InternalProblem.g:417:2: ( ( rule__ScopeDeclaration__Group__0 ) ) | 1996 | // InternalProblem.g:667:2: ( ( rule__ScopeDeclaration__Group__0 ) ) |
1224 | // InternalProblem.g:418:3: ( rule__ScopeDeclaration__Group__0 ) | 1997 | // InternalProblem.g:668:3: ( rule__ScopeDeclaration__Group__0 ) |
1225 | { | 1998 | { |
1226 | before(grammarAccess.getScopeDeclarationAccess().getGroup()); | 1999 | before(grammarAccess.getScopeDeclarationAccess().getGroup()); |
1227 | // InternalProblem.g:419:3: ( rule__ScopeDeclaration__Group__0 ) | 2000 | // InternalProblem.g:669:3: ( rule__ScopeDeclaration__Group__0 ) |
1228 | // InternalProblem.g:419:4: rule__ScopeDeclaration__Group__0 | 2001 | // InternalProblem.g:669:4: rule__ScopeDeclaration__Group__0 |
1229 | { | 2002 | { |
1230 | pushFollow(FOLLOW_2); | 2003 | pushFollow(FOLLOW_2); |
1231 | rule__ScopeDeclaration__Group__0(); | 2004 | rule__ScopeDeclaration__Group__0(); |
@@ -1258,11 +2031,11 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1258 | 2031 | ||
1259 | 2032 | ||
1260 | // $ANTLR start "entryRuleTypeScope" | 2033 | // $ANTLR start "entryRuleTypeScope" |
1261 | // InternalProblem.g:428:1: entryRuleTypeScope : ruleTypeScope EOF ; | 2034 | // InternalProblem.g:678:1: entryRuleTypeScope : ruleTypeScope EOF ; |
1262 | public final void entryRuleTypeScope() throws RecognitionException { | 2035 | public final void entryRuleTypeScope() throws RecognitionException { |
1263 | try { | 2036 | try { |
1264 | // InternalProblem.g:429:1: ( ruleTypeScope EOF ) | 2037 | // InternalProblem.g:679:1: ( ruleTypeScope EOF ) |
1265 | // InternalProblem.g:430:1: ruleTypeScope EOF | 2038 | // InternalProblem.g:680:1: ruleTypeScope EOF |
1266 | { | 2039 | { |
1267 | before(grammarAccess.getTypeScopeRule()); | 2040 | before(grammarAccess.getTypeScopeRule()); |
1268 | pushFollow(FOLLOW_1); | 2041 | pushFollow(FOLLOW_1); |
@@ -1288,21 +2061,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1288 | 2061 | ||
1289 | 2062 | ||
1290 | // $ANTLR start "ruleTypeScope" | 2063 | // $ANTLR start "ruleTypeScope" |
1291 | // InternalProblem.g:437:1: ruleTypeScope : ( ( rule__TypeScope__Group__0 ) ) ; | 2064 | // InternalProblem.g:687:1: ruleTypeScope : ( ( rule__TypeScope__Group__0 ) ) ; |
1292 | public final void ruleTypeScope() throws RecognitionException { | 2065 | public final void ruleTypeScope() throws RecognitionException { |
1293 | 2066 | ||
1294 | int stackSize = keepStackSize(); | 2067 | int stackSize = keepStackSize(); |
1295 | 2068 | ||
1296 | try { | 2069 | try { |
1297 | // InternalProblem.g:441:2: ( ( ( rule__TypeScope__Group__0 ) ) ) | 2070 | // InternalProblem.g:691:2: ( ( ( rule__TypeScope__Group__0 ) ) ) |
1298 | // InternalProblem.g:442:2: ( ( rule__TypeScope__Group__0 ) ) | 2071 | // InternalProblem.g:692:2: ( ( rule__TypeScope__Group__0 ) ) |
1299 | { | 2072 | { |
1300 | // InternalProblem.g:442:2: ( ( rule__TypeScope__Group__0 ) ) | 2073 | // InternalProblem.g:692:2: ( ( rule__TypeScope__Group__0 ) ) |
1301 | // InternalProblem.g:443:3: ( rule__TypeScope__Group__0 ) | 2074 | // InternalProblem.g:693:3: ( rule__TypeScope__Group__0 ) |
1302 | { | 2075 | { |
1303 | before(grammarAccess.getTypeScopeAccess().getGroup()); | 2076 | before(grammarAccess.getTypeScopeAccess().getGroup()); |
1304 | // InternalProblem.g:444:3: ( rule__TypeScope__Group__0 ) | 2077 | // InternalProblem.g:694:3: ( rule__TypeScope__Group__0 ) |
1305 | // InternalProblem.g:444:4: rule__TypeScope__Group__0 | 2078 | // InternalProblem.g:694:4: rule__TypeScope__Group__0 |
1306 | { | 2079 | { |
1307 | pushFollow(FOLLOW_2); | 2080 | pushFollow(FOLLOW_2); |
1308 | rule__TypeScope__Group__0(); | 2081 | rule__TypeScope__Group__0(); |
@@ -1335,11 +2108,11 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1335 | 2108 | ||
1336 | 2109 | ||
1337 | // $ANTLR start "entryRuleMultiplicity" | 2110 | // $ANTLR start "entryRuleMultiplicity" |
1338 | // InternalProblem.g:453:1: entryRuleMultiplicity : ruleMultiplicity EOF ; | 2111 | // InternalProblem.g:703:1: entryRuleMultiplicity : ruleMultiplicity EOF ; |
1339 | public final void entryRuleMultiplicity() throws RecognitionException { | 2112 | public final void entryRuleMultiplicity() throws RecognitionException { |
1340 | try { | 2113 | try { |
1341 | // InternalProblem.g:454:1: ( ruleMultiplicity EOF ) | 2114 | // InternalProblem.g:704:1: ( ruleMultiplicity EOF ) |
1342 | // InternalProblem.g:455:1: ruleMultiplicity EOF | 2115 | // InternalProblem.g:705:1: ruleMultiplicity EOF |
1343 | { | 2116 | { |
1344 | before(grammarAccess.getMultiplicityRule()); | 2117 | before(grammarAccess.getMultiplicityRule()); |
1345 | pushFollow(FOLLOW_1); | 2118 | pushFollow(FOLLOW_1); |
@@ -1365,21 +2138,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1365 | 2138 | ||
1366 | 2139 | ||
1367 | // $ANTLR start "ruleMultiplicity" | 2140 | // $ANTLR start "ruleMultiplicity" |
1368 | // InternalProblem.g:462:1: ruleMultiplicity : ( ( rule__Multiplicity__Alternatives ) ) ; | 2141 | // InternalProblem.g:712:1: ruleMultiplicity : ( ( rule__Multiplicity__Alternatives ) ) ; |
1369 | public final void ruleMultiplicity() throws RecognitionException { | 2142 | public final void ruleMultiplicity() throws RecognitionException { |
1370 | 2143 | ||
1371 | int stackSize = keepStackSize(); | 2144 | int stackSize = keepStackSize(); |
1372 | 2145 | ||
1373 | try { | 2146 | try { |
1374 | // InternalProblem.g:466:2: ( ( ( rule__Multiplicity__Alternatives ) ) ) | 2147 | // InternalProblem.g:716:2: ( ( ( rule__Multiplicity__Alternatives ) ) ) |
1375 | // InternalProblem.g:467:2: ( ( rule__Multiplicity__Alternatives ) ) | 2148 | // InternalProblem.g:717:2: ( ( rule__Multiplicity__Alternatives ) ) |
1376 | { | 2149 | { |
1377 | // InternalProblem.g:467:2: ( ( rule__Multiplicity__Alternatives ) ) | 2150 | // InternalProblem.g:717:2: ( ( rule__Multiplicity__Alternatives ) ) |
1378 | // InternalProblem.g:468:3: ( rule__Multiplicity__Alternatives ) | 2151 | // InternalProblem.g:718:3: ( rule__Multiplicity__Alternatives ) |
1379 | { | 2152 | { |
1380 | before(grammarAccess.getMultiplicityAccess().getAlternatives()); | 2153 | before(grammarAccess.getMultiplicityAccess().getAlternatives()); |
1381 | // InternalProblem.g:469:3: ( rule__Multiplicity__Alternatives ) | 2154 | // InternalProblem.g:719:3: ( rule__Multiplicity__Alternatives ) |
1382 | // InternalProblem.g:469:4: rule__Multiplicity__Alternatives | 2155 | // InternalProblem.g:719:4: rule__Multiplicity__Alternatives |
1383 | { | 2156 | { |
1384 | pushFollow(FOLLOW_2); | 2157 | pushFollow(FOLLOW_2); |
1385 | rule__Multiplicity__Alternatives(); | 2158 | rule__Multiplicity__Alternatives(); |
@@ -1412,11 +2185,11 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1412 | 2185 | ||
1413 | 2186 | ||
1414 | // $ANTLR start "entryRuleDefiniteMultiplicity" | 2187 | // $ANTLR start "entryRuleDefiniteMultiplicity" |
1415 | // InternalProblem.g:478:1: entryRuleDefiniteMultiplicity : ruleDefiniteMultiplicity EOF ; | 2188 | // InternalProblem.g:728:1: entryRuleDefiniteMultiplicity : ruleDefiniteMultiplicity EOF ; |
1416 | public final void entryRuleDefiniteMultiplicity() throws RecognitionException { | 2189 | public final void entryRuleDefiniteMultiplicity() throws RecognitionException { |
1417 | try { | 2190 | try { |
1418 | // InternalProblem.g:479:1: ( ruleDefiniteMultiplicity EOF ) | 2191 | // InternalProblem.g:729:1: ( ruleDefiniteMultiplicity EOF ) |
1419 | // InternalProblem.g:480:1: ruleDefiniteMultiplicity EOF | 2192 | // InternalProblem.g:730:1: ruleDefiniteMultiplicity EOF |
1420 | { | 2193 | { |
1421 | before(grammarAccess.getDefiniteMultiplicityRule()); | 2194 | before(grammarAccess.getDefiniteMultiplicityRule()); |
1422 | pushFollow(FOLLOW_1); | 2195 | pushFollow(FOLLOW_1); |
@@ -1442,21 +2215,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1442 | 2215 | ||
1443 | 2216 | ||
1444 | // $ANTLR start "ruleDefiniteMultiplicity" | 2217 | // $ANTLR start "ruleDefiniteMultiplicity" |
1445 | // InternalProblem.g:487:1: ruleDefiniteMultiplicity : ( ( rule__DefiniteMultiplicity__Alternatives ) ) ; | 2218 | // InternalProblem.g:737:1: ruleDefiniteMultiplicity : ( ( rule__DefiniteMultiplicity__Alternatives ) ) ; |
1446 | public final void ruleDefiniteMultiplicity() throws RecognitionException { | 2219 | public final void ruleDefiniteMultiplicity() throws RecognitionException { |
1447 | 2220 | ||
1448 | int stackSize = keepStackSize(); | 2221 | int stackSize = keepStackSize(); |
1449 | 2222 | ||
1450 | try { | 2223 | try { |
1451 | // InternalProblem.g:491:2: ( ( ( rule__DefiniteMultiplicity__Alternatives ) ) ) | 2224 | // InternalProblem.g:741:2: ( ( ( rule__DefiniteMultiplicity__Alternatives ) ) ) |
1452 | // InternalProblem.g:492:2: ( ( rule__DefiniteMultiplicity__Alternatives ) ) | 2225 | // InternalProblem.g:742:2: ( ( rule__DefiniteMultiplicity__Alternatives ) ) |
1453 | { | 2226 | { |
1454 | // InternalProblem.g:492:2: ( ( rule__DefiniteMultiplicity__Alternatives ) ) | 2227 | // InternalProblem.g:742:2: ( ( rule__DefiniteMultiplicity__Alternatives ) ) |
1455 | // InternalProblem.g:493:3: ( rule__DefiniteMultiplicity__Alternatives ) | 2228 | // InternalProblem.g:743:3: ( rule__DefiniteMultiplicity__Alternatives ) |
1456 | { | 2229 | { |
1457 | before(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives()); | 2230 | before(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives()); |
1458 | // InternalProblem.g:494:3: ( rule__DefiniteMultiplicity__Alternatives ) | 2231 | // InternalProblem.g:744:3: ( rule__DefiniteMultiplicity__Alternatives ) |
1459 | // InternalProblem.g:494:4: rule__DefiniteMultiplicity__Alternatives | 2232 | // InternalProblem.g:744:4: rule__DefiniteMultiplicity__Alternatives |
1460 | { | 2233 | { |
1461 | pushFollow(FOLLOW_2); | 2234 | pushFollow(FOLLOW_2); |
1462 | rule__DefiniteMultiplicity__Alternatives(); | 2235 | rule__DefiniteMultiplicity__Alternatives(); |
@@ -1489,11 +2262,11 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1489 | 2262 | ||
1490 | 2263 | ||
1491 | // $ANTLR start "entryRuleUnboundedMultiplicity" | 2264 | // $ANTLR start "entryRuleUnboundedMultiplicity" |
1492 | // InternalProblem.g:503:1: entryRuleUnboundedMultiplicity : ruleUnboundedMultiplicity EOF ; | 2265 | // InternalProblem.g:753:1: entryRuleUnboundedMultiplicity : ruleUnboundedMultiplicity EOF ; |
1493 | public final void entryRuleUnboundedMultiplicity() throws RecognitionException { | 2266 | public final void entryRuleUnboundedMultiplicity() throws RecognitionException { |
1494 | try { | 2267 | try { |
1495 | // InternalProblem.g:504:1: ( ruleUnboundedMultiplicity EOF ) | 2268 | // InternalProblem.g:754:1: ( ruleUnboundedMultiplicity EOF ) |
1496 | // InternalProblem.g:505:1: ruleUnboundedMultiplicity EOF | 2269 | // InternalProblem.g:755:1: ruleUnboundedMultiplicity EOF |
1497 | { | 2270 | { |
1498 | before(grammarAccess.getUnboundedMultiplicityRule()); | 2271 | before(grammarAccess.getUnboundedMultiplicityRule()); |
1499 | pushFollow(FOLLOW_1); | 2272 | pushFollow(FOLLOW_1); |
@@ -1519,21 +2292,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1519 | 2292 | ||
1520 | 2293 | ||
1521 | // $ANTLR start "ruleUnboundedMultiplicity" | 2294 | // $ANTLR start "ruleUnboundedMultiplicity" |
1522 | // InternalProblem.g:512:1: ruleUnboundedMultiplicity : ( () ) ; | 2295 | // InternalProblem.g:762:1: ruleUnboundedMultiplicity : ( () ) ; |
1523 | public final void ruleUnboundedMultiplicity() throws RecognitionException { | 2296 | public final void ruleUnboundedMultiplicity() throws RecognitionException { |
1524 | 2297 | ||
1525 | int stackSize = keepStackSize(); | 2298 | int stackSize = keepStackSize(); |
1526 | 2299 | ||
1527 | try { | 2300 | try { |
1528 | // InternalProblem.g:516:2: ( ( () ) ) | 2301 | // InternalProblem.g:766:2: ( ( () ) ) |
1529 | // InternalProblem.g:517:2: ( () ) | 2302 | // InternalProblem.g:767:2: ( () ) |
1530 | { | 2303 | { |
1531 | // InternalProblem.g:517:2: ( () ) | 2304 | // InternalProblem.g:767:2: ( () ) |
1532 | // InternalProblem.g:518:3: () | 2305 | // InternalProblem.g:768:3: () |
1533 | { | 2306 | { |
1534 | before(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction()); | 2307 | before(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction()); |
1535 | // InternalProblem.g:519:3: () | 2308 | // InternalProblem.g:769:3: () |
1536 | // InternalProblem.g:519:4: | 2309 | // InternalProblem.g:769:4: |
1537 | { | 2310 | { |
1538 | } | 2311 | } |
1539 | 2312 | ||
@@ -1556,11 +2329,11 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1556 | 2329 | ||
1557 | 2330 | ||
1558 | // $ANTLR start "entryRuleRangeMultiplicity" | 2331 | // $ANTLR start "entryRuleRangeMultiplicity" |
1559 | // InternalProblem.g:528:1: entryRuleRangeMultiplicity : ruleRangeMultiplicity EOF ; | 2332 | // InternalProblem.g:778:1: entryRuleRangeMultiplicity : ruleRangeMultiplicity EOF ; |
1560 | public final void entryRuleRangeMultiplicity() throws RecognitionException { | 2333 | public final void entryRuleRangeMultiplicity() throws RecognitionException { |
1561 | try { | 2334 | try { |
1562 | // InternalProblem.g:529:1: ( ruleRangeMultiplicity EOF ) | 2335 | // InternalProblem.g:779:1: ( ruleRangeMultiplicity EOF ) |
1563 | // InternalProblem.g:530:1: ruleRangeMultiplicity EOF | 2336 | // InternalProblem.g:780:1: ruleRangeMultiplicity EOF |
1564 | { | 2337 | { |
1565 | before(grammarAccess.getRangeMultiplicityRule()); | 2338 | before(grammarAccess.getRangeMultiplicityRule()); |
1566 | pushFollow(FOLLOW_1); | 2339 | pushFollow(FOLLOW_1); |
@@ -1586,21 +2359,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1586 | 2359 | ||
1587 | 2360 | ||
1588 | // $ANTLR start "ruleRangeMultiplicity" | 2361 | // $ANTLR start "ruleRangeMultiplicity" |
1589 | // InternalProblem.g:537:1: ruleRangeMultiplicity : ( ( rule__RangeMultiplicity__Group__0 ) ) ; | 2362 | // InternalProblem.g:787:1: ruleRangeMultiplicity : ( ( rule__RangeMultiplicity__Group__0 ) ) ; |
1590 | public final void ruleRangeMultiplicity() throws RecognitionException { | 2363 | public final void ruleRangeMultiplicity() throws RecognitionException { |
1591 | 2364 | ||
1592 | int stackSize = keepStackSize(); | 2365 | int stackSize = keepStackSize(); |
1593 | 2366 | ||
1594 | try { | 2367 | try { |
1595 | // InternalProblem.g:541:2: ( ( ( rule__RangeMultiplicity__Group__0 ) ) ) | 2368 | // InternalProblem.g:791:2: ( ( ( rule__RangeMultiplicity__Group__0 ) ) ) |
1596 | // InternalProblem.g:542:2: ( ( rule__RangeMultiplicity__Group__0 ) ) | 2369 | // InternalProblem.g:792:2: ( ( rule__RangeMultiplicity__Group__0 ) ) |
1597 | { | 2370 | { |
1598 | // InternalProblem.g:542:2: ( ( rule__RangeMultiplicity__Group__0 ) ) | 2371 | // InternalProblem.g:792:2: ( ( rule__RangeMultiplicity__Group__0 ) ) |
1599 | // InternalProblem.g:543:3: ( rule__RangeMultiplicity__Group__0 ) | 2372 | // InternalProblem.g:793:3: ( rule__RangeMultiplicity__Group__0 ) |
1600 | { | 2373 | { |
1601 | before(grammarAccess.getRangeMultiplicityAccess().getGroup()); | 2374 | before(grammarAccess.getRangeMultiplicityAccess().getGroup()); |
1602 | // InternalProblem.g:544:3: ( rule__RangeMultiplicity__Group__0 ) | 2375 | // InternalProblem.g:794:3: ( rule__RangeMultiplicity__Group__0 ) |
1603 | // InternalProblem.g:544:4: rule__RangeMultiplicity__Group__0 | 2376 | // InternalProblem.g:794:4: rule__RangeMultiplicity__Group__0 |
1604 | { | 2377 | { |
1605 | pushFollow(FOLLOW_2); | 2378 | pushFollow(FOLLOW_2); |
1606 | rule__RangeMultiplicity__Group__0(); | 2379 | rule__RangeMultiplicity__Group__0(); |
@@ -1633,11 +2406,11 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1633 | 2406 | ||
1634 | 2407 | ||
1635 | // $ANTLR start "entryRuleExactMultiplicity" | 2408 | // $ANTLR start "entryRuleExactMultiplicity" |
1636 | // InternalProblem.g:553:1: entryRuleExactMultiplicity : ruleExactMultiplicity EOF ; | 2409 | // InternalProblem.g:803:1: entryRuleExactMultiplicity : ruleExactMultiplicity EOF ; |
1637 | public final void entryRuleExactMultiplicity() throws RecognitionException { | 2410 | public final void entryRuleExactMultiplicity() throws RecognitionException { |
1638 | try { | 2411 | try { |
1639 | // InternalProblem.g:554:1: ( ruleExactMultiplicity EOF ) | 2412 | // InternalProblem.g:804:1: ( ruleExactMultiplicity EOF ) |
1640 | // InternalProblem.g:555:1: ruleExactMultiplicity EOF | 2413 | // InternalProblem.g:805:1: ruleExactMultiplicity EOF |
1641 | { | 2414 | { |
1642 | before(grammarAccess.getExactMultiplicityRule()); | 2415 | before(grammarAccess.getExactMultiplicityRule()); |
1643 | pushFollow(FOLLOW_1); | 2416 | pushFollow(FOLLOW_1); |
@@ -1663,21 +2436,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1663 | 2436 | ||
1664 | 2437 | ||
1665 | // $ANTLR start "ruleExactMultiplicity" | 2438 | // $ANTLR start "ruleExactMultiplicity" |
1666 | // InternalProblem.g:562:1: ruleExactMultiplicity : ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) ; | 2439 | // InternalProblem.g:812:1: ruleExactMultiplicity : ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) ; |
1667 | public final void ruleExactMultiplicity() throws RecognitionException { | 2440 | public final void ruleExactMultiplicity() throws RecognitionException { |
1668 | 2441 | ||
1669 | int stackSize = keepStackSize(); | 2442 | int stackSize = keepStackSize(); |
1670 | 2443 | ||
1671 | try { | 2444 | try { |
1672 | // InternalProblem.g:566:2: ( ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) ) | 2445 | // InternalProblem.g:816:2: ( ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) ) |
1673 | // InternalProblem.g:567:2: ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) | 2446 | // InternalProblem.g:817:2: ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) |
1674 | { | 2447 | { |
1675 | // InternalProblem.g:567:2: ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) | 2448 | // InternalProblem.g:817:2: ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) |
1676 | // InternalProblem.g:568:3: ( rule__ExactMultiplicity__ExactValueAssignment ) | 2449 | // InternalProblem.g:818:3: ( rule__ExactMultiplicity__ExactValueAssignment ) |
1677 | { | 2450 | { |
1678 | before(grammarAccess.getExactMultiplicityAccess().getExactValueAssignment()); | 2451 | before(grammarAccess.getExactMultiplicityAccess().getExactValueAssignment()); |
1679 | // InternalProblem.g:569:3: ( rule__ExactMultiplicity__ExactValueAssignment ) | 2452 | // InternalProblem.g:819:3: ( rule__ExactMultiplicity__ExactValueAssignment ) |
1680 | // InternalProblem.g:569:4: rule__ExactMultiplicity__ExactValueAssignment | 2453 | // InternalProblem.g:819:4: rule__ExactMultiplicity__ExactValueAssignment |
1681 | { | 2454 | { |
1682 | pushFollow(FOLLOW_2); | 2455 | pushFollow(FOLLOW_2); |
1683 | rule__ExactMultiplicity__ExactValueAssignment(); | 2456 | rule__ExactMultiplicity__ExactValueAssignment(); |
@@ -1710,11 +2483,11 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1710 | 2483 | ||
1711 | 2484 | ||
1712 | // $ANTLR start "entryRuleUpperBound" | 2485 | // $ANTLR start "entryRuleUpperBound" |
1713 | // InternalProblem.g:578:1: entryRuleUpperBound : ruleUpperBound EOF ; | 2486 | // InternalProblem.g:828:1: entryRuleUpperBound : ruleUpperBound EOF ; |
1714 | public final void entryRuleUpperBound() throws RecognitionException { | 2487 | public final void entryRuleUpperBound() throws RecognitionException { |
1715 | try { | 2488 | try { |
1716 | // InternalProblem.g:579:1: ( ruleUpperBound EOF ) | 2489 | // InternalProblem.g:829:1: ( ruleUpperBound EOF ) |
1717 | // InternalProblem.g:580:1: ruleUpperBound EOF | 2490 | // InternalProblem.g:830:1: ruleUpperBound EOF |
1718 | { | 2491 | { |
1719 | before(grammarAccess.getUpperBoundRule()); | 2492 | before(grammarAccess.getUpperBoundRule()); |
1720 | pushFollow(FOLLOW_1); | 2493 | pushFollow(FOLLOW_1); |
@@ -1740,21 +2513,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1740 | 2513 | ||
1741 | 2514 | ||
1742 | // $ANTLR start "ruleUpperBound" | 2515 | // $ANTLR start "ruleUpperBound" |
1743 | // InternalProblem.g:587:1: ruleUpperBound : ( ( rule__UpperBound__Alternatives ) ) ; | 2516 | // InternalProblem.g:837:1: ruleUpperBound : ( ( rule__UpperBound__Alternatives ) ) ; |
1744 | public final void ruleUpperBound() throws RecognitionException { | 2517 | public final void ruleUpperBound() throws RecognitionException { |
1745 | 2518 | ||
1746 | int stackSize = keepStackSize(); | 2519 | int stackSize = keepStackSize(); |
1747 | 2520 | ||
1748 | try { | 2521 | try { |
1749 | // InternalProblem.g:591:2: ( ( ( rule__UpperBound__Alternatives ) ) ) | 2522 | // InternalProblem.g:841:2: ( ( ( rule__UpperBound__Alternatives ) ) ) |
1750 | // InternalProblem.g:592:2: ( ( rule__UpperBound__Alternatives ) ) | 2523 | // InternalProblem.g:842:2: ( ( rule__UpperBound__Alternatives ) ) |
1751 | { | 2524 | { |
1752 | // InternalProblem.g:592:2: ( ( rule__UpperBound__Alternatives ) ) | 2525 | // InternalProblem.g:842:2: ( ( rule__UpperBound__Alternatives ) ) |
1753 | // InternalProblem.g:593:3: ( rule__UpperBound__Alternatives ) | 2526 | // InternalProblem.g:843:3: ( rule__UpperBound__Alternatives ) |
1754 | { | 2527 | { |
1755 | before(grammarAccess.getUpperBoundAccess().getAlternatives()); | 2528 | before(grammarAccess.getUpperBoundAccess().getAlternatives()); |
1756 | // InternalProblem.g:594:3: ( rule__UpperBound__Alternatives ) | 2529 | // InternalProblem.g:844:3: ( rule__UpperBound__Alternatives ) |
1757 | // InternalProblem.g:594:4: rule__UpperBound__Alternatives | 2530 | // InternalProblem.g:844:4: rule__UpperBound__Alternatives |
1758 | { | 2531 | { |
1759 | pushFollow(FOLLOW_2); | 2532 | pushFollow(FOLLOW_2); |
1760 | rule__UpperBound__Alternatives(); | 2533 | rule__UpperBound__Alternatives(); |
@@ -1787,11 +2560,11 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1787 | 2560 | ||
1788 | 2561 | ||
1789 | // $ANTLR start "entryRuleQuotedOrUnquotedId" | 2562 | // $ANTLR start "entryRuleQuotedOrUnquotedId" |
1790 | // InternalProblem.g:603:1: entryRuleQuotedOrUnquotedId : ruleQuotedOrUnquotedId EOF ; | 2563 | // InternalProblem.g:853:1: entryRuleQuotedOrUnquotedId : ruleQuotedOrUnquotedId EOF ; |
1791 | public final void entryRuleQuotedOrUnquotedId() throws RecognitionException { | 2564 | public final void entryRuleQuotedOrUnquotedId() throws RecognitionException { |
1792 | try { | 2565 | try { |
1793 | // InternalProblem.g:604:1: ( ruleQuotedOrUnquotedId EOF ) | 2566 | // InternalProblem.g:854:1: ( ruleQuotedOrUnquotedId EOF ) |
1794 | // InternalProblem.g:605:1: ruleQuotedOrUnquotedId EOF | 2567 | // InternalProblem.g:855:1: ruleQuotedOrUnquotedId EOF |
1795 | { | 2568 | { |
1796 | before(grammarAccess.getQuotedOrUnquotedIdRule()); | 2569 | before(grammarAccess.getQuotedOrUnquotedIdRule()); |
1797 | pushFollow(FOLLOW_1); | 2570 | pushFollow(FOLLOW_1); |
@@ -1817,21 +2590,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1817 | 2590 | ||
1818 | 2591 | ||
1819 | // $ANTLR start "ruleQuotedOrUnquotedId" | 2592 | // $ANTLR start "ruleQuotedOrUnquotedId" |
1820 | // InternalProblem.g:612:1: ruleQuotedOrUnquotedId : ( ( rule__QuotedOrUnquotedId__Alternatives ) ) ; | 2593 | // InternalProblem.g:862:1: ruleQuotedOrUnquotedId : ( ( rule__QuotedOrUnquotedId__Alternatives ) ) ; |
1821 | public final void ruleQuotedOrUnquotedId() throws RecognitionException { | 2594 | public final void ruleQuotedOrUnquotedId() throws RecognitionException { |
1822 | 2595 | ||
1823 | int stackSize = keepStackSize(); | 2596 | int stackSize = keepStackSize(); |
1824 | 2597 | ||
1825 | try { | 2598 | try { |
1826 | // InternalProblem.g:616:2: ( ( ( rule__QuotedOrUnquotedId__Alternatives ) ) ) | 2599 | // InternalProblem.g:866:2: ( ( ( rule__QuotedOrUnquotedId__Alternatives ) ) ) |
1827 | // InternalProblem.g:617:2: ( ( rule__QuotedOrUnquotedId__Alternatives ) ) | 2600 | // InternalProblem.g:867:2: ( ( rule__QuotedOrUnquotedId__Alternatives ) ) |
1828 | { | 2601 | { |
1829 | // InternalProblem.g:617:2: ( ( rule__QuotedOrUnquotedId__Alternatives ) ) | 2602 | // InternalProblem.g:867:2: ( ( rule__QuotedOrUnquotedId__Alternatives ) ) |
1830 | // InternalProblem.g:618:3: ( rule__QuotedOrUnquotedId__Alternatives ) | 2603 | // InternalProblem.g:868:3: ( rule__QuotedOrUnquotedId__Alternatives ) |
1831 | { | 2604 | { |
1832 | before(grammarAccess.getQuotedOrUnquotedIdAccess().getAlternatives()); | 2605 | before(grammarAccess.getQuotedOrUnquotedIdAccess().getAlternatives()); |
1833 | // InternalProblem.g:619:3: ( rule__QuotedOrUnquotedId__Alternatives ) | 2606 | // InternalProblem.g:869:3: ( rule__QuotedOrUnquotedId__Alternatives ) |
1834 | // InternalProblem.g:619:4: rule__QuotedOrUnquotedId__Alternatives | 2607 | // InternalProblem.g:869:4: rule__QuotedOrUnquotedId__Alternatives |
1835 | { | 2608 | { |
1836 | pushFollow(FOLLOW_2); | 2609 | pushFollow(FOLLOW_2); |
1837 | rule__QuotedOrUnquotedId__Alternatives(); | 2610 | rule__QuotedOrUnquotedId__Alternatives(); |
@@ -1864,11 +2637,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1864 | 2637 | ||
1865 | 2638 | ||
1866 | // $ANTLR start "entryRuleQualifiedName" | 2639 | // $ANTLR start "entryRuleQualifiedName" |
1867 | // InternalProblem.g:628:1: entryRuleQualifiedName : ruleQualifiedName EOF ; | 2640 | // InternalProblem.g:878:1: entryRuleQualifiedName : ruleQualifiedName EOF ; |
1868 | public final void entryRuleQualifiedName() throws RecognitionException { | 2641 | public final void entryRuleQualifiedName() throws RecognitionException { |
2642 | |||
2643 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
2644 | |||
1869 | try { | 2645 | try { |
1870 | // InternalProblem.g:629:1: ( ruleQualifiedName EOF ) | 2646 | // InternalProblem.g:882:1: ( ruleQualifiedName EOF ) |
1871 | // InternalProblem.g:630:1: ruleQualifiedName EOF | 2647 | // InternalProblem.g:883:1: ruleQualifiedName EOF |
1872 | { | 2648 | { |
1873 | before(grammarAccess.getQualifiedNameRule()); | 2649 | before(grammarAccess.getQualifiedNameRule()); |
1874 | pushFollow(FOLLOW_1); | 2650 | pushFollow(FOLLOW_1); |
@@ -1887,6 +2663,9 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1887 | recover(input,re); | 2663 | recover(input,re); |
1888 | } | 2664 | } |
1889 | finally { | 2665 | finally { |
2666 | |||
2667 | myHiddenTokenState.restore(); | ||
2668 | |||
1890 | } | 2669 | } |
1891 | return ; | 2670 | return ; |
1892 | } | 2671 | } |
@@ -1894,21 +2673,22 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1894 | 2673 | ||
1895 | 2674 | ||
1896 | // $ANTLR start "ruleQualifiedName" | 2675 | // $ANTLR start "ruleQualifiedName" |
1897 | // InternalProblem.g:637:1: ruleQualifiedName : ( ( rule__QualifiedName__Alternatives ) ) ; | 2676 | // InternalProblem.g:893:1: ruleQualifiedName : ( ( rule__QualifiedName__Alternatives ) ) ; |
1898 | public final void ruleQualifiedName() throws RecognitionException { | 2677 | public final void ruleQualifiedName() throws RecognitionException { |
1899 | 2678 | ||
2679 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
1900 | int stackSize = keepStackSize(); | 2680 | int stackSize = keepStackSize(); |
1901 | 2681 | ||
1902 | try { | 2682 | try { |
1903 | // InternalProblem.g:641:2: ( ( ( rule__QualifiedName__Alternatives ) ) ) | 2683 | // InternalProblem.g:898:2: ( ( ( rule__QualifiedName__Alternatives ) ) ) |
1904 | // InternalProblem.g:642:2: ( ( rule__QualifiedName__Alternatives ) ) | 2684 | // InternalProblem.g:899:2: ( ( rule__QualifiedName__Alternatives ) ) |
1905 | { | 2685 | { |
1906 | // InternalProblem.g:642:2: ( ( rule__QualifiedName__Alternatives ) ) | 2686 | // InternalProblem.g:899:2: ( ( rule__QualifiedName__Alternatives ) ) |
1907 | // InternalProblem.g:643:3: ( rule__QualifiedName__Alternatives ) | 2687 | // InternalProblem.g:900:3: ( rule__QualifiedName__Alternatives ) |
1908 | { | 2688 | { |
1909 | before(grammarAccess.getQualifiedNameAccess().getAlternatives()); | 2689 | before(grammarAccess.getQualifiedNameAccess().getAlternatives()); |
1910 | // InternalProblem.g:644:3: ( rule__QualifiedName__Alternatives ) | 2690 | // InternalProblem.g:901:3: ( rule__QualifiedName__Alternatives ) |
1911 | // InternalProblem.g:644:4: rule__QualifiedName__Alternatives | 2691 | // InternalProblem.g:901:4: rule__QualifiedName__Alternatives |
1912 | { | 2692 | { |
1913 | pushFollow(FOLLOW_2); | 2693 | pushFollow(FOLLOW_2); |
1914 | rule__QualifiedName__Alternatives(); | 2694 | rule__QualifiedName__Alternatives(); |
@@ -1933,6 +2713,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1933 | finally { | 2713 | finally { |
1934 | 2714 | ||
1935 | restoreStackSize(stackSize); | 2715 | restoreStackSize(stackSize); |
2716 | myHiddenTokenState.restore(); | ||
1936 | 2717 | ||
1937 | } | 2718 | } |
1938 | return ; | 2719 | return ; |
@@ -1941,11 +2722,11 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1941 | 2722 | ||
1942 | 2723 | ||
1943 | // $ANTLR start "entryRuleIdentifier" | 2724 | // $ANTLR start "entryRuleIdentifier" |
1944 | // InternalProblem.g:653:1: entryRuleIdentifier : ruleIdentifier EOF ; | 2725 | // InternalProblem.g:911:1: entryRuleIdentifier : ruleIdentifier EOF ; |
1945 | public final void entryRuleIdentifier() throws RecognitionException { | 2726 | public final void entryRuleIdentifier() throws RecognitionException { |
1946 | try { | 2727 | try { |
1947 | // InternalProblem.g:654:1: ( ruleIdentifier EOF ) | 2728 | // InternalProblem.g:912:1: ( ruleIdentifier EOF ) |
1948 | // InternalProblem.g:655:1: ruleIdentifier EOF | 2729 | // InternalProblem.g:913:1: ruleIdentifier EOF |
1949 | { | 2730 | { |
1950 | before(grammarAccess.getIdentifierRule()); | 2731 | before(grammarAccess.getIdentifierRule()); |
1951 | pushFollow(FOLLOW_1); | 2732 | pushFollow(FOLLOW_1); |
@@ -1971,21 +2752,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
1971 | 2752 | ||
1972 | 2753 | ||
1973 | // $ANTLR start "ruleIdentifier" | 2754 | // $ANTLR start "ruleIdentifier" |
1974 | // InternalProblem.g:662:1: ruleIdentifier : ( ( rule__Identifier__Alternatives ) ) ; | 2755 | // InternalProblem.g:920:1: ruleIdentifier : ( ( rule__Identifier__Alternatives ) ) ; |
1975 | public final void ruleIdentifier() throws RecognitionException { | 2756 | public final void ruleIdentifier() throws RecognitionException { |
1976 | 2757 | ||
1977 | int stackSize = keepStackSize(); | 2758 | int stackSize = keepStackSize(); |
1978 | 2759 | ||
1979 | try { | 2760 | try { |
1980 | // InternalProblem.g:666:2: ( ( ( rule__Identifier__Alternatives ) ) ) | 2761 | // InternalProblem.g:924:2: ( ( ( rule__Identifier__Alternatives ) ) ) |
1981 | // InternalProblem.g:667:2: ( ( rule__Identifier__Alternatives ) ) | 2762 | // InternalProblem.g:925:2: ( ( rule__Identifier__Alternatives ) ) |
1982 | { | 2763 | { |
1983 | // InternalProblem.g:667:2: ( ( rule__Identifier__Alternatives ) ) | 2764 | // InternalProblem.g:925:2: ( ( rule__Identifier__Alternatives ) ) |
1984 | // InternalProblem.g:668:3: ( rule__Identifier__Alternatives ) | 2765 | // InternalProblem.g:926:3: ( rule__Identifier__Alternatives ) |
1985 | { | 2766 | { |
1986 | before(grammarAccess.getIdentifierAccess().getAlternatives()); | 2767 | before(grammarAccess.getIdentifierAccess().getAlternatives()); |
1987 | // InternalProblem.g:669:3: ( rule__Identifier__Alternatives ) | 2768 | // InternalProblem.g:927:3: ( rule__Identifier__Alternatives ) |
1988 | // InternalProblem.g:669:4: rule__Identifier__Alternatives | 2769 | // InternalProblem.g:927:4: rule__Identifier__Alternatives |
1989 | { | 2770 | { |
1990 | pushFollow(FOLLOW_2); | 2771 | pushFollow(FOLLOW_2); |
1991 | rule__Identifier__Alternatives(); | 2772 | rule__Identifier__Alternatives(); |
@@ -2017,22 +2798,192 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2017 | // $ANTLR end "ruleIdentifier" | 2798 | // $ANTLR end "ruleIdentifier" |
2018 | 2799 | ||
2019 | 2800 | ||
2801 | // $ANTLR start "entryRuleInteger" | ||
2802 | // InternalProblem.g:936:1: entryRuleInteger : ruleInteger EOF ; | ||
2803 | public final void entryRuleInteger() throws RecognitionException { | ||
2804 | |||
2805 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
2806 | |||
2807 | try { | ||
2808 | // InternalProblem.g:940:1: ( ruleInteger EOF ) | ||
2809 | // InternalProblem.g:941:1: ruleInteger EOF | ||
2810 | { | ||
2811 | before(grammarAccess.getIntegerRule()); | ||
2812 | pushFollow(FOLLOW_1); | ||
2813 | ruleInteger(); | ||
2814 | |||
2815 | state._fsp--; | ||
2816 | |||
2817 | after(grammarAccess.getIntegerRule()); | ||
2818 | match(input,EOF,FOLLOW_2); | ||
2819 | |||
2820 | } | ||
2821 | |||
2822 | } | ||
2823 | catch (RecognitionException re) { | ||
2824 | reportError(re); | ||
2825 | recover(input,re); | ||
2826 | } | ||
2827 | finally { | ||
2828 | |||
2829 | myHiddenTokenState.restore(); | ||
2830 | |||
2831 | } | ||
2832 | return ; | ||
2833 | } | ||
2834 | // $ANTLR end "entryRuleInteger" | ||
2835 | |||
2836 | |||
2837 | // $ANTLR start "ruleInteger" | ||
2838 | // InternalProblem.g:951:1: ruleInteger : ( ( rule__Integer__Group__0 ) ) ; | ||
2839 | public final void ruleInteger() throws RecognitionException { | ||
2840 | |||
2841 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
2842 | int stackSize = keepStackSize(); | ||
2843 | |||
2844 | try { | ||
2845 | // InternalProblem.g:956:2: ( ( ( rule__Integer__Group__0 ) ) ) | ||
2846 | // InternalProblem.g:957:2: ( ( rule__Integer__Group__0 ) ) | ||
2847 | { | ||
2848 | // InternalProblem.g:957:2: ( ( rule__Integer__Group__0 ) ) | ||
2849 | // InternalProblem.g:958:3: ( rule__Integer__Group__0 ) | ||
2850 | { | ||
2851 | before(grammarAccess.getIntegerAccess().getGroup()); | ||
2852 | // InternalProblem.g:959:3: ( rule__Integer__Group__0 ) | ||
2853 | // InternalProblem.g:959:4: rule__Integer__Group__0 | ||
2854 | { | ||
2855 | pushFollow(FOLLOW_2); | ||
2856 | rule__Integer__Group__0(); | ||
2857 | |||
2858 | state._fsp--; | ||
2859 | |||
2860 | |||
2861 | } | ||
2862 | |||
2863 | after(grammarAccess.getIntegerAccess().getGroup()); | ||
2864 | |||
2865 | } | ||
2866 | |||
2867 | |||
2868 | } | ||
2869 | |||
2870 | } | ||
2871 | catch (RecognitionException re) { | ||
2872 | reportError(re); | ||
2873 | recover(input,re); | ||
2874 | } | ||
2875 | finally { | ||
2876 | |||
2877 | restoreStackSize(stackSize); | ||
2878 | myHiddenTokenState.restore(); | ||
2879 | |||
2880 | } | ||
2881 | return ; | ||
2882 | } | ||
2883 | // $ANTLR end "ruleInteger" | ||
2884 | |||
2885 | |||
2886 | // $ANTLR start "entryRuleReal" | ||
2887 | // InternalProblem.g:969:1: entryRuleReal : ruleReal EOF ; | ||
2888 | public final void entryRuleReal() throws RecognitionException { | ||
2889 | |||
2890 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
2891 | |||
2892 | try { | ||
2893 | // InternalProblem.g:973:1: ( ruleReal EOF ) | ||
2894 | // InternalProblem.g:974:1: ruleReal EOF | ||
2895 | { | ||
2896 | before(grammarAccess.getRealRule()); | ||
2897 | pushFollow(FOLLOW_1); | ||
2898 | ruleReal(); | ||
2899 | |||
2900 | state._fsp--; | ||
2901 | |||
2902 | after(grammarAccess.getRealRule()); | ||
2903 | match(input,EOF,FOLLOW_2); | ||
2904 | |||
2905 | } | ||
2906 | |||
2907 | } | ||
2908 | catch (RecognitionException re) { | ||
2909 | reportError(re); | ||
2910 | recover(input,re); | ||
2911 | } | ||
2912 | finally { | ||
2913 | |||
2914 | myHiddenTokenState.restore(); | ||
2915 | |||
2916 | } | ||
2917 | return ; | ||
2918 | } | ||
2919 | // $ANTLR end "entryRuleReal" | ||
2920 | |||
2921 | |||
2922 | // $ANTLR start "ruleReal" | ||
2923 | // InternalProblem.g:984:1: ruleReal : ( ( rule__Real__Group__0 ) ) ; | ||
2924 | public final void ruleReal() throws RecognitionException { | ||
2925 | |||
2926 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
2927 | int stackSize = keepStackSize(); | ||
2928 | |||
2929 | try { | ||
2930 | // InternalProblem.g:989:2: ( ( ( rule__Real__Group__0 ) ) ) | ||
2931 | // InternalProblem.g:990:2: ( ( rule__Real__Group__0 ) ) | ||
2932 | { | ||
2933 | // InternalProblem.g:990:2: ( ( rule__Real__Group__0 ) ) | ||
2934 | // InternalProblem.g:991:3: ( rule__Real__Group__0 ) | ||
2935 | { | ||
2936 | before(grammarAccess.getRealAccess().getGroup()); | ||
2937 | // InternalProblem.g:992:3: ( rule__Real__Group__0 ) | ||
2938 | // InternalProblem.g:992:4: rule__Real__Group__0 | ||
2939 | { | ||
2940 | pushFollow(FOLLOW_2); | ||
2941 | rule__Real__Group__0(); | ||
2942 | |||
2943 | state._fsp--; | ||
2944 | |||
2945 | |||
2946 | } | ||
2947 | |||
2948 | after(grammarAccess.getRealAccess().getGroup()); | ||
2949 | |||
2950 | } | ||
2951 | |||
2952 | |||
2953 | } | ||
2954 | |||
2955 | } | ||
2956 | catch (RecognitionException re) { | ||
2957 | reportError(re); | ||
2958 | recover(input,re); | ||
2959 | } | ||
2960 | finally { | ||
2961 | |||
2962 | restoreStackSize(stackSize); | ||
2963 | myHiddenTokenState.restore(); | ||
2964 | |||
2965 | } | ||
2966 | return ; | ||
2967 | } | ||
2968 | // $ANTLR end "ruleReal" | ||
2969 | |||
2970 | |||
2020 | // $ANTLR start "ruleLogicValue" | 2971 | // $ANTLR start "ruleLogicValue" |
2021 | // InternalProblem.g:678:1: ruleLogicValue : ( ( rule__LogicValue__Alternatives ) ) ; | 2972 | // InternalProblem.g:1002:1: ruleLogicValue : ( ( rule__LogicValue__Alternatives ) ) ; |
2022 | public final void ruleLogicValue() throws RecognitionException { | 2973 | public final void ruleLogicValue() throws RecognitionException { |
2023 | 2974 | ||
2024 | int stackSize = keepStackSize(); | 2975 | int stackSize = keepStackSize(); |
2025 | 2976 | ||
2026 | try { | 2977 | try { |
2027 | // InternalProblem.g:682:1: ( ( ( rule__LogicValue__Alternatives ) ) ) | 2978 | // InternalProblem.g:1006:1: ( ( ( rule__LogicValue__Alternatives ) ) ) |
2028 | // InternalProblem.g:683:2: ( ( rule__LogicValue__Alternatives ) ) | 2979 | // InternalProblem.g:1007:2: ( ( rule__LogicValue__Alternatives ) ) |
2029 | { | 2980 | { |
2030 | // InternalProblem.g:683:2: ( ( rule__LogicValue__Alternatives ) ) | 2981 | // InternalProblem.g:1007:2: ( ( rule__LogicValue__Alternatives ) ) |
2031 | // InternalProblem.g:684:3: ( rule__LogicValue__Alternatives ) | 2982 | // InternalProblem.g:1008:3: ( rule__LogicValue__Alternatives ) |
2032 | { | 2983 | { |
2033 | before(grammarAccess.getLogicValueAccess().getAlternatives()); | 2984 | before(grammarAccess.getLogicValueAccess().getAlternatives()); |
2034 | // InternalProblem.g:685:3: ( rule__LogicValue__Alternatives ) | 2985 | // InternalProblem.g:1009:3: ( rule__LogicValue__Alternatives ) |
2035 | // InternalProblem.g:685:4: rule__LogicValue__Alternatives | 2986 | // InternalProblem.g:1009:4: rule__LogicValue__Alternatives |
2036 | { | 2987 | { |
2037 | pushFollow(FOLLOW_2); | 2988 | pushFollow(FOLLOW_2); |
2038 | rule__LogicValue__Alternatives(); | 2989 | rule__LogicValue__Alternatives(); |
@@ -2065,21 +3016,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2065 | 3016 | ||
2066 | 3017 | ||
2067 | // $ANTLR start "ruleShortLogicValue" | 3018 | // $ANTLR start "ruleShortLogicValue" |
2068 | // InternalProblem.g:694:1: ruleShortLogicValue : ( ( rule__ShortLogicValue__Alternatives ) ) ; | 3019 | // InternalProblem.g:1018:1: ruleShortLogicValue : ( ( rule__ShortLogicValue__Alternatives ) ) ; |
2069 | public final void ruleShortLogicValue() throws RecognitionException { | 3020 | public final void ruleShortLogicValue() throws RecognitionException { |
2070 | 3021 | ||
2071 | int stackSize = keepStackSize(); | 3022 | int stackSize = keepStackSize(); |
2072 | 3023 | ||
2073 | try { | 3024 | try { |
2074 | // InternalProblem.g:698:1: ( ( ( rule__ShortLogicValue__Alternatives ) ) ) | 3025 | // InternalProblem.g:1022:1: ( ( ( rule__ShortLogicValue__Alternatives ) ) ) |
2075 | // InternalProblem.g:699:2: ( ( rule__ShortLogicValue__Alternatives ) ) | 3026 | // InternalProblem.g:1023:2: ( ( rule__ShortLogicValue__Alternatives ) ) |
2076 | { | 3027 | { |
2077 | // InternalProblem.g:699:2: ( ( rule__ShortLogicValue__Alternatives ) ) | 3028 | // InternalProblem.g:1023:2: ( ( rule__ShortLogicValue__Alternatives ) ) |
2078 | // InternalProblem.g:700:3: ( rule__ShortLogicValue__Alternatives ) | 3029 | // InternalProblem.g:1024:3: ( rule__ShortLogicValue__Alternatives ) |
2079 | { | 3030 | { |
2080 | before(grammarAccess.getShortLogicValueAccess().getAlternatives()); | 3031 | before(grammarAccess.getShortLogicValueAccess().getAlternatives()); |
2081 | // InternalProblem.g:701:3: ( rule__ShortLogicValue__Alternatives ) | 3032 | // InternalProblem.g:1025:3: ( rule__ShortLogicValue__Alternatives ) |
2082 | // InternalProblem.g:701:4: rule__ShortLogicValue__Alternatives | 3033 | // InternalProblem.g:1025:4: rule__ShortLogicValue__Alternatives |
2083 | { | 3034 | { |
2084 | pushFollow(FOLLOW_2); | 3035 | pushFollow(FOLLOW_2); |
2085 | rule__ShortLogicValue__Alternatives(); | 3036 | rule__ShortLogicValue__Alternatives(); |
@@ -2112,60 +3063,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2112 | 3063 | ||
2113 | 3064 | ||
2114 | // $ANTLR start "rule__Statement__Alternatives" | 3065 | // $ANTLR start "rule__Statement__Alternatives" |
2115 | // InternalProblem.g:709:1: rule__Statement__Alternatives : ( ( ruleClassDeclaration ) | ( ruleEnumDeclaration ) | ( rulePredicateDefinition ) | ( ruleAssertion ) | ( ruleScopeDeclaration ) ); | 3066 | // InternalProblem.g:1033:1: rule__Statement__Alternatives : ( ( ruleClassDeclaration ) | ( ruleEnumDeclaration ) | ( rulePredicateDefinition ) | ( ruleAssertion ) | ( ruleNodeValueAssertion ) | ( ruleScopeDeclaration ) ); |
2116 | public final void rule__Statement__Alternatives() throws RecognitionException { | 3067 | public final void rule__Statement__Alternatives() throws RecognitionException { |
2117 | 3068 | ||
2118 | int stackSize = keepStackSize(); | 3069 | int stackSize = keepStackSize(); |
2119 | 3070 | ||
2120 | try { | 3071 | try { |
2121 | // InternalProblem.g:713:1: ( ( ruleClassDeclaration ) | ( ruleEnumDeclaration ) | ( rulePredicateDefinition ) | ( ruleAssertion ) | ( ruleScopeDeclaration ) ) | 3072 | // InternalProblem.g:1037:1: ( ( ruleClassDeclaration ) | ( ruleEnumDeclaration ) | ( rulePredicateDefinition ) | ( ruleAssertion ) | ( ruleNodeValueAssertion ) | ( ruleScopeDeclaration ) ) |
2122 | int alt1=5; | 3073 | int alt1=6; |
2123 | switch ( input.LA(1) ) { | 3074 | alt1 = dfa1.predict(input); |
2124 | case 25: | ||
2125 | case 40: | ||
2126 | { | ||
2127 | alt1=1; | ||
2128 | } | ||
2129 | break; | ||
2130 | case 29: | ||
2131 | { | ||
2132 | alt1=2; | ||
2133 | } | ||
2134 | break; | ||
2135 | case 16: | ||
2136 | case 42: | ||
2137 | { | ||
2138 | alt1=3; | ||
2139 | } | ||
2140 | break; | ||
2141 | case RULE_QUOTED_ID: | ||
2142 | case RULE_ID: | ||
2143 | case 19: | ||
2144 | case 20: | ||
2145 | case 22: | ||
2146 | case 23: | ||
2147 | { | ||
2148 | alt1=4; | ||
2149 | } | ||
2150 | break; | ||
2151 | case 37: | ||
2152 | { | ||
2153 | alt1=5; | ||
2154 | } | ||
2155 | break; | ||
2156 | default: | ||
2157 | NoViableAltException nvae = | ||
2158 | new NoViableAltException("", 1, 0, input); | ||
2159 | |||
2160 | throw nvae; | ||
2161 | } | ||
2162 | |||
2163 | switch (alt1) { | 3075 | switch (alt1) { |
2164 | case 1 : | 3076 | case 1 : |
2165 | // InternalProblem.g:714:2: ( ruleClassDeclaration ) | 3077 | // InternalProblem.g:1038:2: ( ruleClassDeclaration ) |
2166 | { | 3078 | { |
2167 | // InternalProblem.g:714:2: ( ruleClassDeclaration ) | 3079 | // InternalProblem.g:1038:2: ( ruleClassDeclaration ) |
2168 | // InternalProblem.g:715:3: ruleClassDeclaration | 3080 | // InternalProblem.g:1039:3: ruleClassDeclaration |
2169 | { | 3081 | { |
2170 | before(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_0()); | 3082 | before(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_0()); |
2171 | pushFollow(FOLLOW_2); | 3083 | pushFollow(FOLLOW_2); |
@@ -2181,10 +3093,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2181 | } | 3093 | } |
2182 | break; | 3094 | break; |
2183 | case 2 : | 3095 | case 2 : |
2184 | // InternalProblem.g:720:2: ( ruleEnumDeclaration ) | 3096 | // InternalProblem.g:1044:2: ( ruleEnumDeclaration ) |
2185 | { | 3097 | { |
2186 | // InternalProblem.g:720:2: ( ruleEnumDeclaration ) | 3098 | // InternalProblem.g:1044:2: ( ruleEnumDeclaration ) |
2187 | // InternalProblem.g:721:3: ruleEnumDeclaration | 3099 | // InternalProblem.g:1045:3: ruleEnumDeclaration |
2188 | { | 3100 | { |
2189 | before(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_1()); | 3101 | before(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_1()); |
2190 | pushFollow(FOLLOW_2); | 3102 | pushFollow(FOLLOW_2); |
@@ -2200,10 +3112,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2200 | } | 3112 | } |
2201 | break; | 3113 | break; |
2202 | case 3 : | 3114 | case 3 : |
2203 | // InternalProblem.g:726:2: ( rulePredicateDefinition ) | 3115 | // InternalProblem.g:1050:2: ( rulePredicateDefinition ) |
2204 | { | 3116 | { |
2205 | // InternalProblem.g:726:2: ( rulePredicateDefinition ) | 3117 | // InternalProblem.g:1050:2: ( rulePredicateDefinition ) |
2206 | // InternalProblem.g:727:3: rulePredicateDefinition | 3118 | // InternalProblem.g:1051:3: rulePredicateDefinition |
2207 | { | 3119 | { |
2208 | before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_2()); | 3120 | before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_2()); |
2209 | pushFollow(FOLLOW_2); | 3121 | pushFollow(FOLLOW_2); |
@@ -2219,10 +3131,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2219 | } | 3131 | } |
2220 | break; | 3132 | break; |
2221 | case 4 : | 3133 | case 4 : |
2222 | // InternalProblem.g:732:2: ( ruleAssertion ) | 3134 | // InternalProblem.g:1056:2: ( ruleAssertion ) |
2223 | { | 3135 | { |
2224 | // InternalProblem.g:732:2: ( ruleAssertion ) | 3136 | // InternalProblem.g:1056:2: ( ruleAssertion ) |
2225 | // InternalProblem.g:733:3: ruleAssertion | 3137 | // InternalProblem.g:1057:3: ruleAssertion |
2226 | { | 3138 | { |
2227 | before(grammarAccess.getStatementAccess().getAssertionParserRuleCall_3()); | 3139 | before(grammarAccess.getStatementAccess().getAssertionParserRuleCall_3()); |
2228 | pushFollow(FOLLOW_2); | 3140 | pushFollow(FOLLOW_2); |
@@ -2238,18 +3150,37 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2238 | } | 3150 | } |
2239 | break; | 3151 | break; |
2240 | case 5 : | 3152 | case 5 : |
2241 | // InternalProblem.g:738:2: ( ruleScopeDeclaration ) | 3153 | // InternalProblem.g:1062:2: ( ruleNodeValueAssertion ) |
2242 | { | 3154 | { |
2243 | // InternalProblem.g:738:2: ( ruleScopeDeclaration ) | 3155 | // InternalProblem.g:1062:2: ( ruleNodeValueAssertion ) |
2244 | // InternalProblem.g:739:3: ruleScopeDeclaration | 3156 | // InternalProblem.g:1063:3: ruleNodeValueAssertion |
2245 | { | 3157 | { |
2246 | before(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); | 3158 | before(grammarAccess.getStatementAccess().getNodeValueAssertionParserRuleCall_4()); |
3159 | pushFollow(FOLLOW_2); | ||
3160 | ruleNodeValueAssertion(); | ||
3161 | |||
3162 | state._fsp--; | ||
3163 | |||
3164 | after(grammarAccess.getStatementAccess().getNodeValueAssertionParserRuleCall_4()); | ||
3165 | |||
3166 | } | ||
3167 | |||
3168 | |||
3169 | } | ||
3170 | break; | ||
3171 | case 6 : | ||
3172 | // InternalProblem.g:1068:2: ( ruleScopeDeclaration ) | ||
3173 | { | ||
3174 | // InternalProblem.g:1068:2: ( ruleScopeDeclaration ) | ||
3175 | // InternalProblem.g:1069:3: ruleScopeDeclaration | ||
3176 | { | ||
3177 | before(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_5()); | ||
2247 | pushFollow(FOLLOW_2); | 3178 | pushFollow(FOLLOW_2); |
2248 | ruleScopeDeclaration(); | 3179 | ruleScopeDeclaration(); |
2249 | 3180 | ||
2250 | state._fsp--; | 3181 | state._fsp--; |
2251 | 3182 | ||
2252 | after(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); | 3183 | after(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_5()); |
2253 | 3184 | ||
2254 | } | 3185 | } |
2255 | 3186 | ||
@@ -2274,17 +3205,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2274 | 3205 | ||
2275 | 3206 | ||
2276 | // $ANTLR start "rule__ClassDeclaration__Alternatives_4" | 3207 | // $ANTLR start "rule__ClassDeclaration__Alternatives_4" |
2277 | // InternalProblem.g:748:1: rule__ClassDeclaration__Alternatives_4 : ( ( ( rule__ClassDeclaration__Group_4_0__0 ) ) | ( '.' ) ); | 3208 | // InternalProblem.g:1078:1: rule__ClassDeclaration__Alternatives_4 : ( ( ( rule__ClassDeclaration__Group_4_0__0 ) ) | ( '.' ) ); |
2278 | public final void rule__ClassDeclaration__Alternatives_4() throws RecognitionException { | 3209 | public final void rule__ClassDeclaration__Alternatives_4() throws RecognitionException { |
2279 | 3210 | ||
2280 | int stackSize = keepStackSize(); | 3211 | int stackSize = keepStackSize(); |
2281 | 3212 | ||
2282 | try { | 3213 | try { |
2283 | // InternalProblem.g:752:1: ( ( ( rule__ClassDeclaration__Group_4_0__0 ) ) | ( '.' ) ) | 3214 | // InternalProblem.g:1082:1: ( ( ( rule__ClassDeclaration__Group_4_0__0 ) ) | ( '.' ) ) |
2284 | int alt2=2; | 3215 | int alt2=2; |
2285 | int LA2_0 = input.LA(1); | 3216 | int LA2_0 = input.LA(1); |
2286 | 3217 | ||
2287 | if ( (LA2_0==27) ) { | 3218 | if ( (LA2_0==31) ) { |
2288 | alt2=1; | 3219 | alt2=1; |
2289 | } | 3220 | } |
2290 | else if ( (LA2_0==12) ) { | 3221 | else if ( (LA2_0==12) ) { |
@@ -2298,14 +3229,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2298 | } | 3229 | } |
2299 | switch (alt2) { | 3230 | switch (alt2) { |
2300 | case 1 : | 3231 | case 1 : |
2301 | // InternalProblem.g:753:2: ( ( rule__ClassDeclaration__Group_4_0__0 ) ) | 3232 | // InternalProblem.g:1083:2: ( ( rule__ClassDeclaration__Group_4_0__0 ) ) |
2302 | { | 3233 | { |
2303 | // InternalProblem.g:753:2: ( ( rule__ClassDeclaration__Group_4_0__0 ) ) | 3234 | // InternalProblem.g:1083:2: ( ( rule__ClassDeclaration__Group_4_0__0 ) ) |
2304 | // InternalProblem.g:754:3: ( rule__ClassDeclaration__Group_4_0__0 ) | 3235 | // InternalProblem.g:1084:3: ( rule__ClassDeclaration__Group_4_0__0 ) |
2305 | { | 3236 | { |
2306 | before(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); | 3237 | before(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); |
2307 | // InternalProblem.g:755:3: ( rule__ClassDeclaration__Group_4_0__0 ) | 3238 | // InternalProblem.g:1085:3: ( rule__ClassDeclaration__Group_4_0__0 ) |
2308 | // InternalProblem.g:755:4: rule__ClassDeclaration__Group_4_0__0 | 3239 | // InternalProblem.g:1085:4: rule__ClassDeclaration__Group_4_0__0 |
2309 | { | 3240 | { |
2310 | pushFollow(FOLLOW_2); | 3241 | pushFollow(FOLLOW_2); |
2311 | rule__ClassDeclaration__Group_4_0__0(); | 3242 | rule__ClassDeclaration__Group_4_0__0(); |
@@ -2323,10 +3254,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2323 | } | 3254 | } |
2324 | break; | 3255 | break; |
2325 | case 2 : | 3256 | case 2 : |
2326 | // InternalProblem.g:759:2: ( '.' ) | 3257 | // InternalProblem.g:1089:2: ( '.' ) |
2327 | { | 3258 | { |
2328 | // InternalProblem.g:759:2: ( '.' ) | 3259 | // InternalProblem.g:1089:2: ( '.' ) |
2329 | // InternalProblem.g:760:3: '.' | 3260 | // InternalProblem.g:1090:3: '.' |
2330 | { | 3261 | { |
2331 | before(grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1()); | 3262 | before(grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1()); |
2332 | match(input,12,FOLLOW_2); | 3263 | match(input,12,FOLLOW_2); |
@@ -2355,17 +3286,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2355 | 3286 | ||
2356 | 3287 | ||
2357 | // $ANTLR start "rule__EnumDeclaration__Alternatives_2" | 3288 | // $ANTLR start "rule__EnumDeclaration__Alternatives_2" |
2358 | // InternalProblem.g:769:1: rule__EnumDeclaration__Alternatives_2 : ( ( ( rule__EnumDeclaration__Group_2_0__0 ) ) | ( '.' ) ); | 3289 | // InternalProblem.g:1099:1: rule__EnumDeclaration__Alternatives_2 : ( ( ( rule__EnumDeclaration__Group_2_0__0 ) ) | ( '.' ) ); |
2359 | public final void rule__EnumDeclaration__Alternatives_2() throws RecognitionException { | 3290 | public final void rule__EnumDeclaration__Alternatives_2() throws RecognitionException { |
2360 | 3291 | ||
2361 | int stackSize = keepStackSize(); | 3292 | int stackSize = keepStackSize(); |
2362 | 3293 | ||
2363 | try { | 3294 | try { |
2364 | // InternalProblem.g:773:1: ( ( ( rule__EnumDeclaration__Group_2_0__0 ) ) | ( '.' ) ) | 3295 | // InternalProblem.g:1103:1: ( ( ( rule__EnumDeclaration__Group_2_0__0 ) ) | ( '.' ) ) |
2365 | int alt3=2; | 3296 | int alt3=2; |
2366 | int LA3_0 = input.LA(1); | 3297 | int LA3_0 = input.LA(1); |
2367 | 3298 | ||
2368 | if ( (LA3_0==27) ) { | 3299 | if ( (LA3_0==31) ) { |
2369 | alt3=1; | 3300 | alt3=1; |
2370 | } | 3301 | } |
2371 | else if ( (LA3_0==12) ) { | 3302 | else if ( (LA3_0==12) ) { |
@@ -2379,14 +3310,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2379 | } | 3310 | } |
2380 | switch (alt3) { | 3311 | switch (alt3) { |
2381 | case 1 : | 3312 | case 1 : |
2382 | // InternalProblem.g:774:2: ( ( rule__EnumDeclaration__Group_2_0__0 ) ) | 3313 | // InternalProblem.g:1104:2: ( ( rule__EnumDeclaration__Group_2_0__0 ) ) |
2383 | { | 3314 | { |
2384 | // InternalProblem.g:774:2: ( ( rule__EnumDeclaration__Group_2_0__0 ) ) | 3315 | // InternalProblem.g:1104:2: ( ( rule__EnumDeclaration__Group_2_0__0 ) ) |
2385 | // InternalProblem.g:775:3: ( rule__EnumDeclaration__Group_2_0__0 ) | 3316 | // InternalProblem.g:1105:3: ( rule__EnumDeclaration__Group_2_0__0 ) |
2386 | { | 3317 | { |
2387 | before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); | 3318 | before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); |
2388 | // InternalProblem.g:776:3: ( rule__EnumDeclaration__Group_2_0__0 ) | 3319 | // InternalProblem.g:1106:3: ( rule__EnumDeclaration__Group_2_0__0 ) |
2389 | // InternalProblem.g:776:4: rule__EnumDeclaration__Group_2_0__0 | 3320 | // InternalProblem.g:1106:4: rule__EnumDeclaration__Group_2_0__0 |
2390 | { | 3321 | { |
2391 | pushFollow(FOLLOW_2); | 3322 | pushFollow(FOLLOW_2); |
2392 | rule__EnumDeclaration__Group_2_0__0(); | 3323 | rule__EnumDeclaration__Group_2_0__0(); |
@@ -2404,10 +3335,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2404 | } | 3335 | } |
2405 | break; | 3336 | break; |
2406 | case 2 : | 3337 | case 2 : |
2407 | // InternalProblem.g:780:2: ( '.' ) | 3338 | // InternalProblem.g:1110:2: ( '.' ) |
2408 | { | 3339 | { |
2409 | // InternalProblem.g:780:2: ( '.' ) | 3340 | // InternalProblem.g:1110:2: ( '.' ) |
2410 | // InternalProblem.g:781:3: '.' | 3341 | // InternalProblem.g:1111:3: '.' |
2411 | { | 3342 | { |
2412 | before(grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1()); | 3343 | before(grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1()); |
2413 | match(input,12,FOLLOW_2); | 3344 | match(input,12,FOLLOW_2); |
@@ -2436,13 +3367,13 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2436 | 3367 | ||
2437 | 3368 | ||
2438 | // $ANTLR start "rule__EnumDeclaration__Alternatives_2_0_1_2" | 3369 | // $ANTLR start "rule__EnumDeclaration__Alternatives_2_0_1_2" |
2439 | // InternalProblem.g:790:1: rule__EnumDeclaration__Alternatives_2_0_1_2 : ( ( ',' ) | ( ';' ) ); | 3370 | // InternalProblem.g:1120:1: rule__EnumDeclaration__Alternatives_2_0_1_2 : ( ( ',' ) | ( ';' ) ); |
2440 | public final void rule__EnumDeclaration__Alternatives_2_0_1_2() throws RecognitionException { | 3371 | public final void rule__EnumDeclaration__Alternatives_2_0_1_2() throws RecognitionException { |
2441 | 3372 | ||
2442 | int stackSize = keepStackSize(); | 3373 | int stackSize = keepStackSize(); |
2443 | 3374 | ||
2444 | try { | 3375 | try { |
2445 | // InternalProblem.g:794:1: ( ( ',' ) | ( ';' ) ) | 3376 | // InternalProblem.g:1124:1: ( ( ',' ) | ( ';' ) ) |
2446 | int alt4=2; | 3377 | int alt4=2; |
2447 | int LA4_0 = input.LA(1); | 3378 | int LA4_0 = input.LA(1); |
2448 | 3379 | ||
@@ -2460,10 +3391,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2460 | } | 3391 | } |
2461 | switch (alt4) { | 3392 | switch (alt4) { |
2462 | case 1 : | 3393 | case 1 : |
2463 | // InternalProblem.g:795:2: ( ',' ) | 3394 | // InternalProblem.g:1125:2: ( ',' ) |
2464 | { | 3395 | { |
2465 | // InternalProblem.g:795:2: ( ',' ) | 3396 | // InternalProblem.g:1125:2: ( ',' ) |
2466 | // InternalProblem.g:796:3: ',' | 3397 | // InternalProblem.g:1126:3: ',' |
2467 | { | 3398 | { |
2468 | before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()); | 3399 | before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()); |
2469 | match(input,13,FOLLOW_2); | 3400 | match(input,13,FOLLOW_2); |
@@ -2475,10 +3406,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2475 | } | 3406 | } |
2476 | break; | 3407 | break; |
2477 | case 2 : | 3408 | case 2 : |
2478 | // InternalProblem.g:801:2: ( ';' ) | 3409 | // InternalProblem.g:1131:2: ( ';' ) |
2479 | { | 3410 | { |
2480 | // InternalProblem.g:801:2: ( ';' ) | 3411 | // InternalProblem.g:1131:2: ( ';' ) |
2481 | // InternalProblem.g:802:3: ';' | 3412 | // InternalProblem.g:1132:3: ';' |
2482 | { | 3413 | { |
2483 | before(grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1()); | 3414 | before(grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1()); |
2484 | match(input,14,FOLLOW_2); | 3415 | match(input,14,FOLLOW_2); |
@@ -2507,17 +3438,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2507 | 3438 | ||
2508 | 3439 | ||
2509 | // $ANTLR start "rule__ReferenceDeclaration__Alternatives_0" | 3440 | // $ANTLR start "rule__ReferenceDeclaration__Alternatives_0" |
2510 | // InternalProblem.g:811:1: rule__ReferenceDeclaration__Alternatives_0 : ( ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) | ( 'refers' ) ); | 3441 | // InternalProblem.g:1141:1: rule__ReferenceDeclaration__Alternatives_0 : ( ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) | ( 'refers' ) ); |
2511 | public final void rule__ReferenceDeclaration__Alternatives_0() throws RecognitionException { | 3442 | public final void rule__ReferenceDeclaration__Alternatives_0() throws RecognitionException { |
2512 | 3443 | ||
2513 | int stackSize = keepStackSize(); | 3444 | int stackSize = keepStackSize(); |
2514 | 3445 | ||
2515 | try { | 3446 | try { |
2516 | // InternalProblem.g:815:1: ( ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) | ( 'refers' ) ) | 3447 | // InternalProblem.g:1145:1: ( ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) | ( 'refers' ) ) |
2517 | int alt5=2; | 3448 | int alt5=2; |
2518 | int LA5_0 = input.LA(1); | 3449 | int LA5_0 = input.LA(1); |
2519 | 3450 | ||
2520 | if ( (LA5_0==41) ) { | 3451 | if ( (LA5_0==45) ) { |
2521 | alt5=1; | 3452 | alt5=1; |
2522 | } | 3453 | } |
2523 | else if ( (LA5_0==15) ) { | 3454 | else if ( (LA5_0==15) ) { |
@@ -2531,14 +3462,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2531 | } | 3462 | } |
2532 | switch (alt5) { | 3463 | switch (alt5) { |
2533 | case 1 : | 3464 | case 1 : |
2534 | // InternalProblem.g:816:2: ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) | 3465 | // InternalProblem.g:1146:2: ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) |
2535 | { | 3466 | { |
2536 | // InternalProblem.g:816:2: ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) | 3467 | // InternalProblem.g:1146:2: ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) |
2537 | // InternalProblem.g:817:3: ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) | 3468 | // InternalProblem.g:1147:3: ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) |
2538 | { | 3469 | { |
2539 | before(grammarAccess.getReferenceDeclarationAccess().getContainmentAssignment_0_0()); | 3470 | before(grammarAccess.getReferenceDeclarationAccess().getContainmentAssignment_0_0()); |
2540 | // InternalProblem.g:818:3: ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) | 3471 | // InternalProblem.g:1148:3: ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) |
2541 | // InternalProblem.g:818:4: rule__ReferenceDeclaration__ContainmentAssignment_0_0 | 3472 | // InternalProblem.g:1148:4: rule__ReferenceDeclaration__ContainmentAssignment_0_0 |
2542 | { | 3473 | { |
2543 | pushFollow(FOLLOW_2); | 3474 | pushFollow(FOLLOW_2); |
2544 | rule__ReferenceDeclaration__ContainmentAssignment_0_0(); | 3475 | rule__ReferenceDeclaration__ContainmentAssignment_0_0(); |
@@ -2556,10 +3487,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2556 | } | 3487 | } |
2557 | break; | 3488 | break; |
2558 | case 2 : | 3489 | case 2 : |
2559 | // InternalProblem.g:822:2: ( 'refers' ) | 3490 | // InternalProblem.g:1152:2: ( 'refers' ) |
2560 | { | 3491 | { |
2561 | // InternalProblem.g:822:2: ( 'refers' ) | 3492 | // InternalProblem.g:1152:2: ( 'refers' ) |
2562 | // InternalProblem.g:823:3: 'refers' | 3493 | // InternalProblem.g:1153:3: 'refers' |
2563 | { | 3494 | { |
2564 | before(grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); | 3495 | before(grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); |
2565 | match(input,15,FOLLOW_2); | 3496 | match(input,15,FOLLOW_2); |
@@ -2588,17 +3519,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2588 | 3519 | ||
2589 | 3520 | ||
2590 | // $ANTLR start "rule__PredicateDefinition__Alternatives_0" | 3521 | // $ANTLR start "rule__PredicateDefinition__Alternatives_0" |
2591 | // InternalProblem.g:832:1: rule__PredicateDefinition__Alternatives_0 : ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( 'pred' ) ); | 3522 | // InternalProblem.g:1162:1: rule__PredicateDefinition__Alternatives_0 : ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( 'pred' ) ); |
2592 | public final void rule__PredicateDefinition__Alternatives_0() throws RecognitionException { | 3523 | public final void rule__PredicateDefinition__Alternatives_0() throws RecognitionException { |
2593 | 3524 | ||
2594 | int stackSize = keepStackSize(); | 3525 | int stackSize = keepStackSize(); |
2595 | 3526 | ||
2596 | try { | 3527 | try { |
2597 | // InternalProblem.g:836:1: ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( 'pred' ) ) | 3528 | // InternalProblem.g:1166:1: ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( 'pred' ) ) |
2598 | int alt6=2; | 3529 | int alt6=2; |
2599 | int LA6_0 = input.LA(1); | 3530 | int LA6_0 = input.LA(1); |
2600 | 3531 | ||
2601 | if ( (LA6_0==42) ) { | 3532 | if ( (LA6_0==46) ) { |
2602 | alt6=1; | 3533 | alt6=1; |
2603 | } | 3534 | } |
2604 | else if ( (LA6_0==16) ) { | 3535 | else if ( (LA6_0==16) ) { |
@@ -2612,14 +3543,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2612 | } | 3543 | } |
2613 | switch (alt6) { | 3544 | switch (alt6) { |
2614 | case 1 : | 3545 | case 1 : |
2615 | // InternalProblem.g:837:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | 3546 | // InternalProblem.g:1167:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) ) |
2616 | { | 3547 | { |
2617 | // InternalProblem.g:837:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | 3548 | // InternalProblem.g:1167:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) ) |
2618 | // InternalProblem.g:838:3: ( rule__PredicateDefinition__Group_0_0__0 ) | 3549 | // InternalProblem.g:1168:3: ( rule__PredicateDefinition__Group_0_0__0 ) |
2619 | { | 3550 | { |
2620 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); | 3551 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); |
2621 | // InternalProblem.g:839:3: ( rule__PredicateDefinition__Group_0_0__0 ) | 3552 | // InternalProblem.g:1169:3: ( rule__PredicateDefinition__Group_0_0__0 ) |
2622 | // InternalProblem.g:839:4: rule__PredicateDefinition__Group_0_0__0 | 3553 | // InternalProblem.g:1169:4: rule__PredicateDefinition__Group_0_0__0 |
2623 | { | 3554 | { |
2624 | pushFollow(FOLLOW_2); | 3555 | pushFollow(FOLLOW_2); |
2625 | rule__PredicateDefinition__Group_0_0__0(); | 3556 | rule__PredicateDefinition__Group_0_0__0(); |
@@ -2637,10 +3568,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2637 | } | 3568 | } |
2638 | break; | 3569 | break; |
2639 | case 2 : | 3570 | case 2 : |
2640 | // InternalProblem.g:843:2: ( 'pred' ) | 3571 | // InternalProblem.g:1173:2: ( 'pred' ) |
2641 | { | 3572 | { |
2642 | // InternalProblem.g:843:2: ( 'pred' ) | 3573 | // InternalProblem.g:1173:2: ( 'pred' ) |
2643 | // InternalProblem.g:844:3: 'pred' | 3574 | // InternalProblem.g:1174:3: 'pred' |
2644 | { | 3575 | { |
2645 | before(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_1()); | 3576 | before(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_1()); |
2646 | match(input,16,FOLLOW_2); | 3577 | match(input,16,FOLLOW_2); |
@@ -2669,20 +3600,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2669 | 3600 | ||
2670 | 3601 | ||
2671 | // $ANTLR start "rule__Literal__Alternatives" | 3602 | // $ANTLR start "rule__Literal__Alternatives" |
2672 | // InternalProblem.g:853:1: rule__Literal__Alternatives : ( ( ruleAtom ) | ( ruleNegativeLiteral ) ); | 3603 | // InternalProblem.g:1183:1: rule__Literal__Alternatives : ( ( ruleAtom ) | ( ruleNegativeLiteral ) ); |
2673 | public final void rule__Literal__Alternatives() throws RecognitionException { | 3604 | public final void rule__Literal__Alternatives() throws RecognitionException { |
2674 | 3605 | ||
2675 | int stackSize = keepStackSize(); | 3606 | int stackSize = keepStackSize(); |
2676 | 3607 | ||
2677 | try { | 3608 | try { |
2678 | // InternalProblem.g:857:1: ( ( ruleAtom ) | ( ruleNegativeLiteral ) ) | 3609 | // InternalProblem.g:1187:1: ( ( ruleAtom ) | ( ruleNegativeLiteral ) ) |
2679 | int alt7=2; | 3610 | int alt7=2; |
2680 | int LA7_0 = input.LA(1); | 3611 | int LA7_0 = input.LA(1); |
2681 | 3612 | ||
2682 | if ( ((LA7_0>=RULE_QUOTED_ID && LA7_0<=RULE_ID)||(LA7_0>=19 && LA7_0<=20)) ) { | 3613 | if ( ((LA7_0>=RULE_QUOTED_ID && LA7_0<=RULE_ID)||(LA7_0>=19 && LA7_0<=22)) ) { |
2683 | alt7=1; | 3614 | alt7=1; |
2684 | } | 3615 | } |
2685 | else if ( (LA7_0==22) ) { | 3616 | else if ( (LA7_0==26) ) { |
2686 | alt7=2; | 3617 | alt7=2; |
2687 | } | 3618 | } |
2688 | else { | 3619 | else { |
@@ -2693,10 +3624,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2693 | } | 3624 | } |
2694 | switch (alt7) { | 3625 | switch (alt7) { |
2695 | case 1 : | 3626 | case 1 : |
2696 | // InternalProblem.g:858:2: ( ruleAtom ) | 3627 | // InternalProblem.g:1188:2: ( ruleAtom ) |
2697 | { | 3628 | { |
2698 | // InternalProblem.g:858:2: ( ruleAtom ) | 3629 | // InternalProblem.g:1188:2: ( ruleAtom ) |
2699 | // InternalProblem.g:859:3: ruleAtom | 3630 | // InternalProblem.g:1189:3: ruleAtom |
2700 | { | 3631 | { |
2701 | before(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); | 3632 | before(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); |
2702 | pushFollow(FOLLOW_2); | 3633 | pushFollow(FOLLOW_2); |
@@ -2712,10 +3643,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2712 | } | 3643 | } |
2713 | break; | 3644 | break; |
2714 | case 2 : | 3645 | case 2 : |
2715 | // InternalProblem.g:864:2: ( ruleNegativeLiteral ) | 3646 | // InternalProblem.g:1194:2: ( ruleNegativeLiteral ) |
2716 | { | 3647 | { |
2717 | // InternalProblem.g:864:2: ( ruleNegativeLiteral ) | 3648 | // InternalProblem.g:1194:2: ( ruleNegativeLiteral ) |
2718 | // InternalProblem.g:865:3: ruleNegativeLiteral | 3649 | // InternalProblem.g:1195:3: ruleNegativeLiteral |
2719 | { | 3650 | { |
2720 | before(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); | 3651 | before(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); |
2721 | pushFollow(FOLLOW_2); | 3652 | pushFollow(FOLLOW_2); |
@@ -2747,26 +3678,105 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2747 | // $ANTLR end "rule__Literal__Alternatives" | 3678 | // $ANTLR end "rule__Literal__Alternatives" |
2748 | 3679 | ||
2749 | 3680 | ||
2750 | // $ANTLR start "rule__Assertion__Alternatives_0" | 3681 | // $ANTLR start "rule__Argument__Alternatives" |
2751 | // InternalProblem.g:874:1: rule__Assertion__Alternatives_0 : ( ( ( rule__Assertion__Group_0_0__0 ) ) | ( ( rule__Assertion__Group_0_1__0 ) ) ); | 3682 | // InternalProblem.g:1204:1: rule__Argument__Alternatives : ( ( ruleVariableOrNodeArgument ) | ( ruleConstantArgument ) ); |
2752 | public final void rule__Assertion__Alternatives_0() throws RecognitionException { | 3683 | public final void rule__Argument__Alternatives() throws RecognitionException { |
2753 | 3684 | ||
2754 | int stackSize = keepStackSize(); | 3685 | int stackSize = keepStackSize(); |
2755 | 3686 | ||
2756 | try { | 3687 | try { |
2757 | // InternalProblem.g:878:1: ( ( ( rule__Assertion__Group_0_0__0 ) ) | ( ( rule__Assertion__Group_0_1__0 ) ) ) | 3688 | // InternalProblem.g:1208:1: ( ( ruleVariableOrNodeArgument ) | ( ruleConstantArgument ) ) |
2758 | int alt8=2; | 3689 | int alt8=2; |
2759 | alt8 = dfa8.predict(input); | 3690 | int LA8_0 = input.LA(1); |
3691 | |||
3692 | if ( ((LA8_0>=RULE_QUOTED_ID && LA8_0<=RULE_ID)||(LA8_0>=19 && LA8_0<=22)) ) { | ||
3693 | alt8=1; | ||
3694 | } | ||
3695 | else if ( (LA8_0==RULE_INT||LA8_0==RULE_STRING||LA8_0==23) ) { | ||
3696 | alt8=2; | ||
3697 | } | ||
3698 | else { | ||
3699 | NoViableAltException nvae = | ||
3700 | new NoViableAltException("", 8, 0, input); | ||
3701 | |||
3702 | throw nvae; | ||
3703 | } | ||
2760 | switch (alt8) { | 3704 | switch (alt8) { |
2761 | case 1 : | 3705 | case 1 : |
2762 | // InternalProblem.g:879:2: ( ( rule__Assertion__Group_0_0__0 ) ) | 3706 | // InternalProblem.g:1209:2: ( ruleVariableOrNodeArgument ) |
3707 | { | ||
3708 | // InternalProblem.g:1209:2: ( ruleVariableOrNodeArgument ) | ||
3709 | // InternalProblem.g:1210:3: ruleVariableOrNodeArgument | ||
3710 | { | ||
3711 | before(grammarAccess.getArgumentAccess().getVariableOrNodeArgumentParserRuleCall_0()); | ||
3712 | pushFollow(FOLLOW_2); | ||
3713 | ruleVariableOrNodeArgument(); | ||
3714 | |||
3715 | state._fsp--; | ||
3716 | |||
3717 | after(grammarAccess.getArgumentAccess().getVariableOrNodeArgumentParserRuleCall_0()); | ||
3718 | |||
3719 | } | ||
3720 | |||
3721 | |||
3722 | } | ||
3723 | break; | ||
3724 | case 2 : | ||
3725 | // InternalProblem.g:1215:2: ( ruleConstantArgument ) | ||
3726 | { | ||
3727 | // InternalProblem.g:1215:2: ( ruleConstantArgument ) | ||
3728 | // InternalProblem.g:1216:3: ruleConstantArgument | ||
3729 | { | ||
3730 | before(grammarAccess.getArgumentAccess().getConstantArgumentParserRuleCall_1()); | ||
3731 | pushFollow(FOLLOW_2); | ||
3732 | ruleConstantArgument(); | ||
3733 | |||
3734 | state._fsp--; | ||
3735 | |||
3736 | after(grammarAccess.getArgumentAccess().getConstantArgumentParserRuleCall_1()); | ||
3737 | |||
3738 | } | ||
3739 | |||
3740 | |||
3741 | } | ||
3742 | break; | ||
3743 | |||
3744 | } | ||
3745 | } | ||
3746 | catch (RecognitionException re) { | ||
3747 | reportError(re); | ||
3748 | recover(input,re); | ||
3749 | } | ||
3750 | finally { | ||
3751 | |||
3752 | restoreStackSize(stackSize); | ||
3753 | |||
3754 | } | ||
3755 | return ; | ||
3756 | } | ||
3757 | // $ANTLR end "rule__Argument__Alternatives" | ||
3758 | |||
3759 | |||
3760 | // $ANTLR start "rule__Assertion__Alternatives_0" | ||
3761 | // InternalProblem.g:1225:1: rule__Assertion__Alternatives_0 : ( ( ( rule__Assertion__Group_0_0__0 ) ) | ( ( rule__Assertion__Group_0_1__0 ) ) ); | ||
3762 | public final void rule__Assertion__Alternatives_0() throws RecognitionException { | ||
3763 | |||
3764 | int stackSize = keepStackSize(); | ||
3765 | |||
3766 | try { | ||
3767 | // InternalProblem.g:1229:1: ( ( ( rule__Assertion__Group_0_0__0 ) ) | ( ( rule__Assertion__Group_0_1__0 ) ) ) | ||
3768 | int alt9=2; | ||
3769 | alt9 = dfa9.predict(input); | ||
3770 | switch (alt9) { | ||
3771 | case 1 : | ||
3772 | // InternalProblem.g:1230:2: ( ( rule__Assertion__Group_0_0__0 ) ) | ||
2763 | { | 3773 | { |
2764 | // InternalProblem.g:879:2: ( ( rule__Assertion__Group_0_0__0 ) ) | 3774 | // InternalProblem.g:1230:2: ( ( rule__Assertion__Group_0_0__0 ) ) |
2765 | // InternalProblem.g:880:3: ( rule__Assertion__Group_0_0__0 ) | 3775 | // InternalProblem.g:1231:3: ( rule__Assertion__Group_0_0__0 ) |
2766 | { | 3776 | { |
2767 | before(grammarAccess.getAssertionAccess().getGroup_0_0()); | 3777 | before(grammarAccess.getAssertionAccess().getGroup_0_0()); |
2768 | // InternalProblem.g:881:3: ( rule__Assertion__Group_0_0__0 ) | 3778 | // InternalProblem.g:1232:3: ( rule__Assertion__Group_0_0__0 ) |
2769 | // InternalProblem.g:881:4: rule__Assertion__Group_0_0__0 | 3779 | // InternalProblem.g:1232:4: rule__Assertion__Group_0_0__0 |
2770 | { | 3780 | { |
2771 | pushFollow(FOLLOW_2); | 3781 | pushFollow(FOLLOW_2); |
2772 | rule__Assertion__Group_0_0__0(); | 3782 | rule__Assertion__Group_0_0__0(); |
@@ -2784,14 +3794,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2784 | } | 3794 | } |
2785 | break; | 3795 | break; |
2786 | case 2 : | 3796 | case 2 : |
2787 | // InternalProblem.g:885:2: ( ( rule__Assertion__Group_0_1__0 ) ) | 3797 | // InternalProblem.g:1236:2: ( ( rule__Assertion__Group_0_1__0 ) ) |
2788 | { | 3798 | { |
2789 | // InternalProblem.g:885:2: ( ( rule__Assertion__Group_0_1__0 ) ) | 3799 | // InternalProblem.g:1236:2: ( ( rule__Assertion__Group_0_1__0 ) ) |
2790 | // InternalProblem.g:886:3: ( rule__Assertion__Group_0_1__0 ) | 3800 | // InternalProblem.g:1237:3: ( rule__Assertion__Group_0_1__0 ) |
2791 | { | 3801 | { |
2792 | before(grammarAccess.getAssertionAccess().getGroup_0_1()); | 3802 | before(grammarAccess.getAssertionAccess().getGroup_0_1()); |
2793 | // InternalProblem.g:887:3: ( rule__Assertion__Group_0_1__0 ) | 3803 | // InternalProblem.g:1238:3: ( rule__Assertion__Group_0_1__0 ) |
2794 | // InternalProblem.g:887:4: rule__Assertion__Group_0_1__0 | 3804 | // InternalProblem.g:1238:4: rule__Assertion__Group_0_1__0 |
2795 | { | 3805 | { |
2796 | pushFollow(FOLLOW_2); | 3806 | pushFollow(FOLLOW_2); |
2797 | rule__Assertion__Group_0_1__0(); | 3807 | rule__Assertion__Group_0_1__0(); |
@@ -2825,39 +3835,311 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2825 | // $ANTLR end "rule__Assertion__Alternatives_0" | 3835 | // $ANTLR end "rule__Assertion__Alternatives_0" |
2826 | 3836 | ||
2827 | 3837 | ||
3838 | // $ANTLR start "rule__AssertionArgument__Alternatives" | ||
3839 | // InternalProblem.g:1246:1: rule__AssertionArgument__Alternatives : ( ( ruleNodeAssertionArgument ) | ( ruleConstantAssertionArgument ) ); | ||
3840 | public final void rule__AssertionArgument__Alternatives() throws RecognitionException { | ||
3841 | |||
3842 | int stackSize = keepStackSize(); | ||
3843 | |||
3844 | try { | ||
3845 | // InternalProblem.g:1250:1: ( ( ruleNodeAssertionArgument ) | ( ruleConstantAssertionArgument ) ) | ||
3846 | int alt10=2; | ||
3847 | int LA10_0 = input.LA(1); | ||
3848 | |||
3849 | if ( ((LA10_0>=RULE_QUOTED_ID && LA10_0<=RULE_ID)||(LA10_0>=19 && LA10_0<=22)) ) { | ||
3850 | alt10=1; | ||
3851 | } | ||
3852 | else if ( (LA10_0==RULE_INT||LA10_0==RULE_STRING||LA10_0==23) ) { | ||
3853 | alt10=2; | ||
3854 | } | ||
3855 | else { | ||
3856 | NoViableAltException nvae = | ||
3857 | new NoViableAltException("", 10, 0, input); | ||
3858 | |||
3859 | throw nvae; | ||
3860 | } | ||
3861 | switch (alt10) { | ||
3862 | case 1 : | ||
3863 | // InternalProblem.g:1251:2: ( ruleNodeAssertionArgument ) | ||
3864 | { | ||
3865 | // InternalProblem.g:1251:2: ( ruleNodeAssertionArgument ) | ||
3866 | // InternalProblem.g:1252:3: ruleNodeAssertionArgument | ||
3867 | { | ||
3868 | before(grammarAccess.getAssertionArgumentAccess().getNodeAssertionArgumentParserRuleCall_0()); | ||
3869 | pushFollow(FOLLOW_2); | ||
3870 | ruleNodeAssertionArgument(); | ||
3871 | |||
3872 | state._fsp--; | ||
3873 | |||
3874 | after(grammarAccess.getAssertionArgumentAccess().getNodeAssertionArgumentParserRuleCall_0()); | ||
3875 | |||
3876 | } | ||
3877 | |||
3878 | |||
3879 | } | ||
3880 | break; | ||
3881 | case 2 : | ||
3882 | // InternalProblem.g:1257:2: ( ruleConstantAssertionArgument ) | ||
3883 | { | ||
3884 | // InternalProblem.g:1257:2: ( ruleConstantAssertionArgument ) | ||
3885 | // InternalProblem.g:1258:3: ruleConstantAssertionArgument | ||
3886 | { | ||
3887 | before(grammarAccess.getAssertionArgumentAccess().getConstantAssertionArgumentParserRuleCall_1()); | ||
3888 | pushFollow(FOLLOW_2); | ||
3889 | ruleConstantAssertionArgument(); | ||
3890 | |||
3891 | state._fsp--; | ||
3892 | |||
3893 | after(grammarAccess.getAssertionArgumentAccess().getConstantAssertionArgumentParserRuleCall_1()); | ||
3894 | |||
3895 | } | ||
3896 | |||
3897 | |||
3898 | } | ||
3899 | break; | ||
3900 | |||
3901 | } | ||
3902 | } | ||
3903 | catch (RecognitionException re) { | ||
3904 | reportError(re); | ||
3905 | recover(input,re); | ||
3906 | } | ||
3907 | finally { | ||
3908 | |||
3909 | restoreStackSize(stackSize); | ||
3910 | |||
3911 | } | ||
3912 | return ; | ||
3913 | } | ||
3914 | // $ANTLR end "rule__AssertionArgument__Alternatives" | ||
3915 | |||
3916 | |||
3917 | // $ANTLR start "rule__Constant__Alternatives" | ||
3918 | // InternalProblem.g:1267:1: rule__Constant__Alternatives : ( ( ruleIntConstant ) | ( ruleRealConstant ) | ( ruleStringConstant ) ); | ||
3919 | public final void rule__Constant__Alternatives() throws RecognitionException { | ||
3920 | |||
3921 | int stackSize = keepStackSize(); | ||
3922 | |||
3923 | try { | ||
3924 | // InternalProblem.g:1271:1: ( ( ruleIntConstant ) | ( ruleRealConstant ) | ( ruleStringConstant ) ) | ||
3925 | int alt11=3; | ||
3926 | switch ( input.LA(1) ) { | ||
3927 | case 23: | ||
3928 | { | ||
3929 | int LA11_1 = input.LA(2); | ||
3930 | |||
3931 | if ( (LA11_1==RULE_INT) ) { | ||
3932 | switch ( input.LA(3) ) { | ||
3933 | case 12: | ||
3934 | { | ||
3935 | int LA11_4 = input.LA(4); | ||
3936 | |||
3937 | if ( (LA11_4==RULE_INT) ) { | ||
3938 | alt11=2; | ||
3939 | } | ||
3940 | else if ( (LA11_4==EOF||(LA11_4>=RULE_QUOTED_ID && LA11_4<=RULE_ID)||LA11_4==16||(LA11_4>=19 && LA11_4<=22)||(LA11_4>=26 && LA11_4<=27)||LA11_4==29||LA11_4==33||LA11_4==41||LA11_4==44||LA11_4==46) ) { | ||
3941 | alt11=1; | ||
3942 | } | ||
3943 | else { | ||
3944 | NoViableAltException nvae = | ||
3945 | new NoViableAltException("", 11, 4, input); | ||
3946 | |||
3947 | throw nvae; | ||
3948 | } | ||
3949 | } | ||
3950 | break; | ||
3951 | case 21: | ||
3952 | case 22: | ||
3953 | { | ||
3954 | alt11=2; | ||
3955 | } | ||
3956 | break; | ||
3957 | case EOF: | ||
3958 | case 13: | ||
3959 | case 38: | ||
3960 | { | ||
3961 | alt11=1; | ||
3962 | } | ||
3963 | break; | ||
3964 | default: | ||
3965 | NoViableAltException nvae = | ||
3966 | new NoViableAltException("", 11, 2, input); | ||
3967 | |||
3968 | throw nvae; | ||
3969 | } | ||
3970 | |||
3971 | } | ||
3972 | else { | ||
3973 | NoViableAltException nvae = | ||
3974 | new NoViableAltException("", 11, 1, input); | ||
3975 | |||
3976 | throw nvae; | ||
3977 | } | ||
3978 | } | ||
3979 | break; | ||
3980 | case RULE_INT: | ||
3981 | { | ||
3982 | switch ( input.LA(2) ) { | ||
3983 | case 12: | ||
3984 | { | ||
3985 | int LA11_4 = input.LA(3); | ||
3986 | |||
3987 | if ( (LA11_4==RULE_INT) ) { | ||
3988 | alt11=2; | ||
3989 | } | ||
3990 | else if ( (LA11_4==EOF||(LA11_4>=RULE_QUOTED_ID && LA11_4<=RULE_ID)||LA11_4==16||(LA11_4>=19 && LA11_4<=22)||(LA11_4>=26 && LA11_4<=27)||LA11_4==29||LA11_4==33||LA11_4==41||LA11_4==44||LA11_4==46) ) { | ||
3991 | alt11=1; | ||
3992 | } | ||
3993 | else { | ||
3994 | NoViableAltException nvae = | ||
3995 | new NoViableAltException("", 11, 4, input); | ||
3996 | |||
3997 | throw nvae; | ||
3998 | } | ||
3999 | } | ||
4000 | break; | ||
4001 | case 21: | ||
4002 | case 22: | ||
4003 | { | ||
4004 | alt11=2; | ||
4005 | } | ||
4006 | break; | ||
4007 | case EOF: | ||
4008 | case 13: | ||
4009 | case 38: | ||
4010 | { | ||
4011 | alt11=1; | ||
4012 | } | ||
4013 | break; | ||
4014 | default: | ||
4015 | NoViableAltException nvae = | ||
4016 | new NoViableAltException("", 11, 2, input); | ||
4017 | |||
4018 | throw nvae; | ||
4019 | } | ||
4020 | |||
4021 | } | ||
4022 | break; | ||
4023 | case RULE_STRING: | ||
4024 | { | ||
4025 | alt11=3; | ||
4026 | } | ||
4027 | break; | ||
4028 | default: | ||
4029 | NoViableAltException nvae = | ||
4030 | new NoViableAltException("", 11, 0, input); | ||
4031 | |||
4032 | throw nvae; | ||
4033 | } | ||
4034 | |||
4035 | switch (alt11) { | ||
4036 | case 1 : | ||
4037 | // InternalProblem.g:1272:2: ( ruleIntConstant ) | ||
4038 | { | ||
4039 | // InternalProblem.g:1272:2: ( ruleIntConstant ) | ||
4040 | // InternalProblem.g:1273:3: ruleIntConstant | ||
4041 | { | ||
4042 | before(grammarAccess.getConstantAccess().getIntConstantParserRuleCall_0()); | ||
4043 | pushFollow(FOLLOW_2); | ||
4044 | ruleIntConstant(); | ||
4045 | |||
4046 | state._fsp--; | ||
4047 | |||
4048 | after(grammarAccess.getConstantAccess().getIntConstantParserRuleCall_0()); | ||
4049 | |||
4050 | } | ||
4051 | |||
4052 | |||
4053 | } | ||
4054 | break; | ||
4055 | case 2 : | ||
4056 | // InternalProblem.g:1278:2: ( ruleRealConstant ) | ||
4057 | { | ||
4058 | // InternalProblem.g:1278:2: ( ruleRealConstant ) | ||
4059 | // InternalProblem.g:1279:3: ruleRealConstant | ||
4060 | { | ||
4061 | before(grammarAccess.getConstantAccess().getRealConstantParserRuleCall_1()); | ||
4062 | pushFollow(FOLLOW_2); | ||
4063 | ruleRealConstant(); | ||
4064 | |||
4065 | state._fsp--; | ||
4066 | |||
4067 | after(grammarAccess.getConstantAccess().getRealConstantParserRuleCall_1()); | ||
4068 | |||
4069 | } | ||
4070 | |||
4071 | |||
4072 | } | ||
4073 | break; | ||
4074 | case 3 : | ||
4075 | // InternalProblem.g:1284:2: ( ruleStringConstant ) | ||
4076 | { | ||
4077 | // InternalProblem.g:1284:2: ( ruleStringConstant ) | ||
4078 | // InternalProblem.g:1285:3: ruleStringConstant | ||
4079 | { | ||
4080 | before(grammarAccess.getConstantAccess().getStringConstantParserRuleCall_2()); | ||
4081 | pushFollow(FOLLOW_2); | ||
4082 | ruleStringConstant(); | ||
4083 | |||
4084 | state._fsp--; | ||
4085 | |||
4086 | after(grammarAccess.getConstantAccess().getStringConstantParserRuleCall_2()); | ||
4087 | |||
4088 | } | ||
4089 | |||
4090 | |||
4091 | } | ||
4092 | break; | ||
4093 | |||
4094 | } | ||
4095 | } | ||
4096 | catch (RecognitionException re) { | ||
4097 | reportError(re); | ||
4098 | recover(input,re); | ||
4099 | } | ||
4100 | finally { | ||
4101 | |||
4102 | restoreStackSize(stackSize); | ||
4103 | |||
4104 | } | ||
4105 | return ; | ||
4106 | } | ||
4107 | // $ANTLR end "rule__Constant__Alternatives" | ||
4108 | |||
4109 | |||
2828 | // $ANTLR start "rule__TypeScope__Alternatives_1" | 4110 | // $ANTLR start "rule__TypeScope__Alternatives_1" |
2829 | // InternalProblem.g:895:1: rule__TypeScope__Alternatives_1 : ( ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) | ( '=' ) ); | 4111 | // InternalProblem.g:1294:1: rule__TypeScope__Alternatives_1 : ( ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) | ( '=' ) ); |
2830 | public final void rule__TypeScope__Alternatives_1() throws RecognitionException { | 4112 | public final void rule__TypeScope__Alternatives_1() throws RecognitionException { |
2831 | 4113 | ||
2832 | int stackSize = keepStackSize(); | 4114 | int stackSize = keepStackSize(); |
2833 | 4115 | ||
2834 | try { | 4116 | try { |
2835 | // InternalProblem.g:899:1: ( ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) | ( '=' ) ) | 4117 | // InternalProblem.g:1298:1: ( ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) | ( '=' ) ) |
2836 | int alt9=2; | 4118 | int alt12=2; |
2837 | int LA9_0 = input.LA(1); | 4119 | int LA12_0 = input.LA(1); |
2838 | 4120 | ||
2839 | if ( (LA9_0==44) ) { | 4121 | if ( (LA12_0==47) ) { |
2840 | alt9=1; | 4122 | alt12=1; |
2841 | } | 4123 | } |
2842 | else if ( (LA9_0==17) ) { | 4124 | else if ( (LA12_0==17) ) { |
2843 | alt9=2; | 4125 | alt12=2; |
2844 | } | 4126 | } |
2845 | else { | 4127 | else { |
2846 | NoViableAltException nvae = | 4128 | NoViableAltException nvae = |
2847 | new NoViableAltException("", 9, 0, input); | 4129 | new NoViableAltException("", 12, 0, input); |
2848 | 4130 | ||
2849 | throw nvae; | 4131 | throw nvae; |
2850 | } | 4132 | } |
2851 | switch (alt9) { | 4133 | switch (alt12) { |
2852 | case 1 : | 4134 | case 1 : |
2853 | // InternalProblem.g:900:2: ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) | 4135 | // InternalProblem.g:1299:2: ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) |
2854 | { | 4136 | { |
2855 | // InternalProblem.g:900:2: ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) | 4137 | // InternalProblem.g:1299:2: ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) |
2856 | // InternalProblem.g:901:3: ( rule__TypeScope__IncrementAssignment_1_0 ) | 4138 | // InternalProblem.g:1300:3: ( rule__TypeScope__IncrementAssignment_1_0 ) |
2857 | { | 4139 | { |
2858 | before(grammarAccess.getTypeScopeAccess().getIncrementAssignment_1_0()); | 4140 | before(grammarAccess.getTypeScopeAccess().getIncrementAssignment_1_0()); |
2859 | // InternalProblem.g:902:3: ( rule__TypeScope__IncrementAssignment_1_0 ) | 4141 | // InternalProblem.g:1301:3: ( rule__TypeScope__IncrementAssignment_1_0 ) |
2860 | // InternalProblem.g:902:4: rule__TypeScope__IncrementAssignment_1_0 | 4142 | // InternalProblem.g:1301:4: rule__TypeScope__IncrementAssignment_1_0 |
2861 | { | 4143 | { |
2862 | pushFollow(FOLLOW_2); | 4144 | pushFollow(FOLLOW_2); |
2863 | rule__TypeScope__IncrementAssignment_1_0(); | 4145 | rule__TypeScope__IncrementAssignment_1_0(); |
@@ -2875,10 +4157,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2875 | } | 4157 | } |
2876 | break; | 4158 | break; |
2877 | case 2 : | 4159 | case 2 : |
2878 | // InternalProblem.g:906:2: ( '=' ) | 4160 | // InternalProblem.g:1305:2: ( '=' ) |
2879 | { | 4161 | { |
2880 | // InternalProblem.g:906:2: ( '=' ) | 4162 | // InternalProblem.g:1305:2: ( '=' ) |
2881 | // InternalProblem.g:907:3: '=' | 4163 | // InternalProblem.g:1306:3: '=' |
2882 | { | 4164 | { |
2883 | before(grammarAccess.getTypeScopeAccess().getEqualsSignKeyword_1_1()); | 4165 | before(grammarAccess.getTypeScopeAccess().getEqualsSignKeyword_1_1()); |
2884 | match(input,17,FOLLOW_2); | 4166 | match(input,17,FOLLOW_2); |
@@ -2907,34 +4189,34 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2907 | 4189 | ||
2908 | 4190 | ||
2909 | // $ANTLR start "rule__Multiplicity__Alternatives" | 4191 | // $ANTLR start "rule__Multiplicity__Alternatives" |
2910 | // InternalProblem.g:916:1: rule__Multiplicity__Alternatives : ( ( ruleUnboundedMultiplicity ) | ( ruleDefiniteMultiplicity ) ); | 4192 | // InternalProblem.g:1315:1: rule__Multiplicity__Alternatives : ( ( ruleUnboundedMultiplicity ) | ( ruleDefiniteMultiplicity ) ); |
2911 | public final void rule__Multiplicity__Alternatives() throws RecognitionException { | 4193 | public final void rule__Multiplicity__Alternatives() throws RecognitionException { |
2912 | 4194 | ||
2913 | int stackSize = keepStackSize(); | 4195 | int stackSize = keepStackSize(); |
2914 | 4196 | ||
2915 | try { | 4197 | try { |
2916 | // InternalProblem.g:920:1: ( ( ruleUnboundedMultiplicity ) | ( ruleDefiniteMultiplicity ) ) | 4198 | // InternalProblem.g:1319:1: ( ( ruleUnboundedMultiplicity ) | ( ruleDefiniteMultiplicity ) ) |
2917 | int alt10=2; | 4199 | int alt13=2; |
2918 | int LA10_0 = input.LA(1); | 4200 | int LA13_0 = input.LA(1); |
2919 | 4201 | ||
2920 | if ( (LA10_0==EOF||LA10_0==31) ) { | 4202 | if ( (LA13_0==EOF||LA13_0==35) ) { |
2921 | alt10=1; | 4203 | alt13=1; |
2922 | } | 4204 | } |
2923 | else if ( (LA10_0==RULE_INT) ) { | 4205 | else if ( (LA13_0==RULE_INT) ) { |
2924 | alt10=2; | 4206 | alt13=2; |
2925 | } | 4207 | } |
2926 | else { | 4208 | else { |
2927 | NoViableAltException nvae = | 4209 | NoViableAltException nvae = |
2928 | new NoViableAltException("", 10, 0, input); | 4210 | new NoViableAltException("", 13, 0, input); |
2929 | 4211 | ||
2930 | throw nvae; | 4212 | throw nvae; |
2931 | } | 4213 | } |
2932 | switch (alt10) { | 4214 | switch (alt13) { |
2933 | case 1 : | 4215 | case 1 : |
2934 | // InternalProblem.g:921:2: ( ruleUnboundedMultiplicity ) | 4216 | // InternalProblem.g:1320:2: ( ruleUnboundedMultiplicity ) |
2935 | { | 4217 | { |
2936 | // InternalProblem.g:921:2: ( ruleUnboundedMultiplicity ) | 4218 | // InternalProblem.g:1320:2: ( ruleUnboundedMultiplicity ) |
2937 | // InternalProblem.g:922:3: ruleUnboundedMultiplicity | 4219 | // InternalProblem.g:1321:3: ruleUnboundedMultiplicity |
2938 | { | 4220 | { |
2939 | before(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); | 4221 | before(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); |
2940 | pushFollow(FOLLOW_2); | 4222 | pushFollow(FOLLOW_2); |
@@ -2950,10 +4232,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2950 | } | 4232 | } |
2951 | break; | 4233 | break; |
2952 | case 2 : | 4234 | case 2 : |
2953 | // InternalProblem.g:927:2: ( ruleDefiniteMultiplicity ) | 4235 | // InternalProblem.g:1326:2: ( ruleDefiniteMultiplicity ) |
2954 | { | 4236 | { |
2955 | // InternalProblem.g:927:2: ( ruleDefiniteMultiplicity ) | 4237 | // InternalProblem.g:1326:2: ( ruleDefiniteMultiplicity ) |
2956 | // InternalProblem.g:928:3: ruleDefiniteMultiplicity | 4238 | // InternalProblem.g:1327:3: ruleDefiniteMultiplicity |
2957 | { | 4239 | { |
2958 | before(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); | 4240 | before(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); |
2959 | pushFollow(FOLLOW_2); | 4241 | pushFollow(FOLLOW_2); |
@@ -2986,44 +4268,44 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
2986 | 4268 | ||
2987 | 4269 | ||
2988 | // $ANTLR start "rule__DefiniteMultiplicity__Alternatives" | 4270 | // $ANTLR start "rule__DefiniteMultiplicity__Alternatives" |
2989 | // InternalProblem.g:937:1: rule__DefiniteMultiplicity__Alternatives : ( ( ruleRangeMultiplicity ) | ( ruleExactMultiplicity ) ); | 4271 | // InternalProblem.g:1336:1: rule__DefiniteMultiplicity__Alternatives : ( ( ruleRangeMultiplicity ) | ( ruleExactMultiplicity ) ); |
2990 | public final void rule__DefiniteMultiplicity__Alternatives() throws RecognitionException { | 4272 | public final void rule__DefiniteMultiplicity__Alternatives() throws RecognitionException { |
2991 | 4273 | ||
2992 | int stackSize = keepStackSize(); | 4274 | int stackSize = keepStackSize(); |
2993 | 4275 | ||
2994 | try { | 4276 | try { |
2995 | // InternalProblem.g:941:1: ( ( ruleRangeMultiplicity ) | ( ruleExactMultiplicity ) ) | 4277 | // InternalProblem.g:1340:1: ( ( ruleRangeMultiplicity ) | ( ruleExactMultiplicity ) ) |
2996 | int alt11=2; | 4278 | int alt14=2; |
2997 | int LA11_0 = input.LA(1); | 4279 | int LA14_0 = input.LA(1); |
2998 | 4280 | ||
2999 | if ( (LA11_0==RULE_INT) ) { | 4281 | if ( (LA14_0==RULE_INT) ) { |
3000 | int LA11_1 = input.LA(2); | 4282 | int LA14_1 = input.LA(2); |
3001 | 4283 | ||
3002 | if ( (LA11_1==38) ) { | 4284 | if ( (LA14_1==42) ) { |
3003 | alt11=1; | 4285 | alt14=1; |
3004 | } | 4286 | } |
3005 | else if ( (LA11_1==EOF||(LA11_1>=12 && LA11_1<=13)||LA11_1==31) ) { | 4287 | else if ( (LA14_1==EOF||(LA14_1>=12 && LA14_1<=13)||LA14_1==35) ) { |
3006 | alt11=2; | 4288 | alt14=2; |
3007 | } | 4289 | } |
3008 | else { | 4290 | else { |
3009 | NoViableAltException nvae = | 4291 | NoViableAltException nvae = |
3010 | new NoViableAltException("", 11, 1, input); | 4292 | new NoViableAltException("", 14, 1, input); |
3011 | 4293 | ||
3012 | throw nvae; | 4294 | throw nvae; |
3013 | } | 4295 | } |
3014 | } | 4296 | } |
3015 | else { | 4297 | else { |
3016 | NoViableAltException nvae = | 4298 | NoViableAltException nvae = |
3017 | new NoViableAltException("", 11, 0, input); | 4299 | new NoViableAltException("", 14, 0, input); |
3018 | 4300 | ||
3019 | throw nvae; | 4301 | throw nvae; |
3020 | } | 4302 | } |
3021 | switch (alt11) { | 4303 | switch (alt14) { |
3022 | case 1 : | 4304 | case 1 : |
3023 | // InternalProblem.g:942:2: ( ruleRangeMultiplicity ) | 4305 | // InternalProblem.g:1341:2: ( ruleRangeMultiplicity ) |
3024 | { | 4306 | { |
3025 | // InternalProblem.g:942:2: ( ruleRangeMultiplicity ) | 4307 | // InternalProblem.g:1341:2: ( ruleRangeMultiplicity ) |
3026 | // InternalProblem.g:943:3: ruleRangeMultiplicity | 4308 | // InternalProblem.g:1342:3: ruleRangeMultiplicity |
3027 | { | 4309 | { |
3028 | before(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); | 4310 | before(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); |
3029 | pushFollow(FOLLOW_2); | 4311 | pushFollow(FOLLOW_2); |
@@ -3039,10 +4321,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3039 | } | 4321 | } |
3040 | break; | 4322 | break; |
3041 | case 2 : | 4323 | case 2 : |
3042 | // InternalProblem.g:948:2: ( ruleExactMultiplicity ) | 4324 | // InternalProblem.g:1347:2: ( ruleExactMultiplicity ) |
3043 | { | 4325 | { |
3044 | // InternalProblem.g:948:2: ( ruleExactMultiplicity ) | 4326 | // InternalProblem.g:1347:2: ( ruleExactMultiplicity ) |
3045 | // InternalProblem.g:949:3: ruleExactMultiplicity | 4327 | // InternalProblem.g:1348:3: ruleExactMultiplicity |
3046 | { | 4328 | { |
3047 | before(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); | 4329 | before(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); |
3048 | pushFollow(FOLLOW_2); | 4330 | pushFollow(FOLLOW_2); |
@@ -3075,34 +4357,34 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3075 | 4357 | ||
3076 | 4358 | ||
3077 | // $ANTLR start "rule__UpperBound__Alternatives" | 4359 | // $ANTLR start "rule__UpperBound__Alternatives" |
3078 | // InternalProblem.g:958:1: rule__UpperBound__Alternatives : ( ( RULE_INT ) | ( '*' ) ); | 4360 | // InternalProblem.g:1357:1: rule__UpperBound__Alternatives : ( ( RULE_INT ) | ( '*' ) ); |
3079 | public final void rule__UpperBound__Alternatives() throws RecognitionException { | 4361 | public final void rule__UpperBound__Alternatives() throws RecognitionException { |
3080 | 4362 | ||
3081 | int stackSize = keepStackSize(); | 4363 | int stackSize = keepStackSize(); |
3082 | 4364 | ||
3083 | try { | 4365 | try { |
3084 | // InternalProblem.g:962:1: ( ( RULE_INT ) | ( '*' ) ) | 4366 | // InternalProblem.g:1361:1: ( ( RULE_INT ) | ( '*' ) ) |
3085 | int alt12=2; | 4367 | int alt15=2; |
3086 | int LA12_0 = input.LA(1); | 4368 | int LA15_0 = input.LA(1); |
3087 | 4369 | ||
3088 | if ( (LA12_0==RULE_INT) ) { | 4370 | if ( (LA15_0==RULE_INT) ) { |
3089 | alt12=1; | 4371 | alt15=1; |
3090 | } | 4372 | } |
3091 | else if ( (LA12_0==18) ) { | 4373 | else if ( (LA15_0==18) ) { |
3092 | alt12=2; | 4374 | alt15=2; |
3093 | } | 4375 | } |
3094 | else { | 4376 | else { |
3095 | NoViableAltException nvae = | 4377 | NoViableAltException nvae = |
3096 | new NoViableAltException("", 12, 0, input); | 4378 | new NoViableAltException("", 15, 0, input); |
3097 | 4379 | ||
3098 | throw nvae; | 4380 | throw nvae; |
3099 | } | 4381 | } |
3100 | switch (alt12) { | 4382 | switch (alt15) { |
3101 | case 1 : | 4383 | case 1 : |
3102 | // InternalProblem.g:963:2: ( RULE_INT ) | 4384 | // InternalProblem.g:1362:2: ( RULE_INT ) |
3103 | { | 4385 | { |
3104 | // InternalProblem.g:963:2: ( RULE_INT ) | 4386 | // InternalProblem.g:1362:2: ( RULE_INT ) |
3105 | // InternalProblem.g:964:3: RULE_INT | 4387 | // InternalProblem.g:1363:3: RULE_INT |
3106 | { | 4388 | { |
3107 | before(grammarAccess.getUpperBoundAccess().getINTTerminalRuleCall_0()); | 4389 | before(grammarAccess.getUpperBoundAccess().getINTTerminalRuleCall_0()); |
3108 | match(input,RULE_INT,FOLLOW_2); | 4390 | match(input,RULE_INT,FOLLOW_2); |
@@ -3114,10 +4396,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3114 | } | 4396 | } |
3115 | break; | 4397 | break; |
3116 | case 2 : | 4398 | case 2 : |
3117 | // InternalProblem.g:969:2: ( '*' ) | 4399 | // InternalProblem.g:1368:2: ( '*' ) |
3118 | { | 4400 | { |
3119 | // InternalProblem.g:969:2: ( '*' ) | 4401 | // InternalProblem.g:1368:2: ( '*' ) |
3120 | // InternalProblem.g:970:3: '*' | 4402 | // InternalProblem.g:1369:3: '*' |
3121 | { | 4403 | { |
3122 | before(grammarAccess.getUpperBoundAccess().getAsteriskKeyword_1()); | 4404 | before(grammarAccess.getUpperBoundAccess().getAsteriskKeyword_1()); |
3123 | match(input,18,FOLLOW_2); | 4405 | match(input,18,FOLLOW_2); |
@@ -3146,34 +4428,34 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3146 | 4428 | ||
3147 | 4429 | ||
3148 | // $ANTLR start "rule__QuotedOrUnquotedId__Alternatives" | 4430 | // $ANTLR start "rule__QuotedOrUnquotedId__Alternatives" |
3149 | // InternalProblem.g:979:1: rule__QuotedOrUnquotedId__Alternatives : ( ( RULE_QUOTED_ID ) | ( ruleIdentifier ) ); | 4431 | // InternalProblem.g:1378:1: rule__QuotedOrUnquotedId__Alternatives : ( ( RULE_QUOTED_ID ) | ( ruleIdentifier ) ); |
3150 | public final void rule__QuotedOrUnquotedId__Alternatives() throws RecognitionException { | 4432 | public final void rule__QuotedOrUnquotedId__Alternatives() throws RecognitionException { |
3151 | 4433 | ||
3152 | int stackSize = keepStackSize(); | 4434 | int stackSize = keepStackSize(); |
3153 | 4435 | ||
3154 | try { | 4436 | try { |
3155 | // InternalProblem.g:983:1: ( ( RULE_QUOTED_ID ) | ( ruleIdentifier ) ) | 4437 | // InternalProblem.g:1382:1: ( ( RULE_QUOTED_ID ) | ( ruleIdentifier ) ) |
3156 | int alt13=2; | 4438 | int alt16=2; |
3157 | int LA13_0 = input.LA(1); | 4439 | int LA16_0 = input.LA(1); |
3158 | 4440 | ||
3159 | if ( (LA13_0==RULE_QUOTED_ID) ) { | 4441 | if ( (LA16_0==RULE_QUOTED_ID) ) { |
3160 | alt13=1; | 4442 | alt16=1; |
3161 | } | 4443 | } |
3162 | else if ( (LA13_0==RULE_ID||(LA13_0>=19 && LA13_0<=20)) ) { | 4444 | else if ( (LA16_0==RULE_ID||(LA16_0>=19 && LA16_0<=22)) ) { |
3163 | alt13=2; | 4445 | alt16=2; |
3164 | } | 4446 | } |
3165 | else { | 4447 | else { |
3166 | NoViableAltException nvae = | 4448 | NoViableAltException nvae = |
3167 | new NoViableAltException("", 13, 0, input); | 4449 | new NoViableAltException("", 16, 0, input); |
3168 | 4450 | ||
3169 | throw nvae; | 4451 | throw nvae; |
3170 | } | 4452 | } |
3171 | switch (alt13) { | 4453 | switch (alt16) { |
3172 | case 1 : | 4454 | case 1 : |
3173 | // InternalProblem.g:984:2: ( RULE_QUOTED_ID ) | 4455 | // InternalProblem.g:1383:2: ( RULE_QUOTED_ID ) |
3174 | { | 4456 | { |
3175 | // InternalProblem.g:984:2: ( RULE_QUOTED_ID ) | 4457 | // InternalProblem.g:1383:2: ( RULE_QUOTED_ID ) |
3176 | // InternalProblem.g:985:3: RULE_QUOTED_ID | 4458 | // InternalProblem.g:1384:3: RULE_QUOTED_ID |
3177 | { | 4459 | { |
3178 | before(grammarAccess.getQuotedOrUnquotedIdAccess().getQUOTED_IDTerminalRuleCall_0()); | 4460 | before(grammarAccess.getQuotedOrUnquotedIdAccess().getQUOTED_IDTerminalRuleCall_0()); |
3179 | match(input,RULE_QUOTED_ID,FOLLOW_2); | 4461 | match(input,RULE_QUOTED_ID,FOLLOW_2); |
@@ -3185,10 +4467,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3185 | } | 4467 | } |
3186 | break; | 4468 | break; |
3187 | case 2 : | 4469 | case 2 : |
3188 | // InternalProblem.g:990:2: ( ruleIdentifier ) | 4470 | // InternalProblem.g:1389:2: ( ruleIdentifier ) |
3189 | { | 4471 | { |
3190 | // InternalProblem.g:990:2: ( ruleIdentifier ) | 4472 | // InternalProblem.g:1389:2: ( ruleIdentifier ) |
3191 | // InternalProblem.g:991:3: ruleIdentifier | 4473 | // InternalProblem.g:1390:3: ruleIdentifier |
3192 | { | 4474 | { |
3193 | before(grammarAccess.getQuotedOrUnquotedIdAccess().getIdentifierParserRuleCall_1()); | 4475 | before(grammarAccess.getQuotedOrUnquotedIdAccess().getIdentifierParserRuleCall_1()); |
3194 | pushFollow(FOLLOW_2); | 4476 | pushFollow(FOLLOW_2); |
@@ -3221,34 +4503,34 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3221 | 4503 | ||
3222 | 4504 | ||
3223 | // $ANTLR start "rule__QualifiedName__Alternatives" | 4505 | // $ANTLR start "rule__QualifiedName__Alternatives" |
3224 | // InternalProblem.g:1000:1: rule__QualifiedName__Alternatives : ( ( RULE_QUOTED_ID ) | ( ( rule__QualifiedName__Group_1__0 ) ) ); | 4506 | // InternalProblem.g:1399:1: rule__QualifiedName__Alternatives : ( ( RULE_QUOTED_ID ) | ( ( rule__QualifiedName__Group_1__0 ) ) ); |
3225 | public final void rule__QualifiedName__Alternatives() throws RecognitionException { | 4507 | public final void rule__QualifiedName__Alternatives() throws RecognitionException { |
3226 | 4508 | ||
3227 | int stackSize = keepStackSize(); | 4509 | int stackSize = keepStackSize(); |
3228 | 4510 | ||
3229 | try { | 4511 | try { |
3230 | // InternalProblem.g:1004:1: ( ( RULE_QUOTED_ID ) | ( ( rule__QualifiedName__Group_1__0 ) ) ) | 4512 | // InternalProblem.g:1403:1: ( ( RULE_QUOTED_ID ) | ( ( rule__QualifiedName__Group_1__0 ) ) ) |
3231 | int alt14=2; | 4513 | int alt17=2; |
3232 | int LA14_0 = input.LA(1); | 4514 | int LA17_0 = input.LA(1); |
3233 | 4515 | ||
3234 | if ( (LA14_0==RULE_QUOTED_ID) ) { | 4516 | if ( (LA17_0==RULE_QUOTED_ID) ) { |
3235 | alt14=1; | 4517 | alt17=1; |
3236 | } | 4518 | } |
3237 | else if ( (LA14_0==RULE_ID||(LA14_0>=19 && LA14_0<=20)) ) { | 4519 | else if ( (LA17_0==RULE_ID||(LA17_0>=19 && LA17_0<=22)) ) { |
3238 | alt14=2; | 4520 | alt17=2; |
3239 | } | 4521 | } |
3240 | else { | 4522 | else { |
3241 | NoViableAltException nvae = | 4523 | NoViableAltException nvae = |
3242 | new NoViableAltException("", 14, 0, input); | 4524 | new NoViableAltException("", 17, 0, input); |
3243 | 4525 | ||
3244 | throw nvae; | 4526 | throw nvae; |
3245 | } | 4527 | } |
3246 | switch (alt14) { | 4528 | switch (alt17) { |
3247 | case 1 : | 4529 | case 1 : |
3248 | // InternalProblem.g:1005:2: ( RULE_QUOTED_ID ) | 4530 | // InternalProblem.g:1404:2: ( RULE_QUOTED_ID ) |
3249 | { | 4531 | { |
3250 | // InternalProblem.g:1005:2: ( RULE_QUOTED_ID ) | 4532 | // InternalProblem.g:1404:2: ( RULE_QUOTED_ID ) |
3251 | // InternalProblem.g:1006:3: RULE_QUOTED_ID | 4533 | // InternalProblem.g:1405:3: RULE_QUOTED_ID |
3252 | { | 4534 | { |
3253 | before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_0()); | 4535 | before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_0()); |
3254 | match(input,RULE_QUOTED_ID,FOLLOW_2); | 4536 | match(input,RULE_QUOTED_ID,FOLLOW_2); |
@@ -3260,14 +4542,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3260 | } | 4542 | } |
3261 | break; | 4543 | break; |
3262 | case 2 : | 4544 | case 2 : |
3263 | // InternalProblem.g:1011:2: ( ( rule__QualifiedName__Group_1__0 ) ) | 4545 | // InternalProblem.g:1410:2: ( ( rule__QualifiedName__Group_1__0 ) ) |
3264 | { | 4546 | { |
3265 | // InternalProblem.g:1011:2: ( ( rule__QualifiedName__Group_1__0 ) ) | 4547 | // InternalProblem.g:1410:2: ( ( rule__QualifiedName__Group_1__0 ) ) |
3266 | // InternalProblem.g:1012:3: ( rule__QualifiedName__Group_1__0 ) | 4548 | // InternalProblem.g:1411:3: ( rule__QualifiedName__Group_1__0 ) |
3267 | { | 4549 | { |
3268 | before(grammarAccess.getQualifiedNameAccess().getGroup_1()); | 4550 | before(grammarAccess.getQualifiedNameAccess().getGroup_1()); |
3269 | // InternalProblem.g:1013:3: ( rule__QualifiedName__Group_1__0 ) | 4551 | // InternalProblem.g:1412:3: ( rule__QualifiedName__Group_1__0 ) |
3270 | // InternalProblem.g:1013:4: rule__QualifiedName__Group_1__0 | 4552 | // InternalProblem.g:1412:4: rule__QualifiedName__Group_1__0 |
3271 | { | 4553 | { |
3272 | pushFollow(FOLLOW_2); | 4554 | pushFollow(FOLLOW_2); |
3273 | rule__QualifiedName__Group_1__0(); | 4555 | rule__QualifiedName__Group_1__0(); |
@@ -3302,43 +4584,53 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3302 | 4584 | ||
3303 | 4585 | ||
3304 | // $ANTLR start "rule__Identifier__Alternatives" | 4586 | // $ANTLR start "rule__Identifier__Alternatives" |
3305 | // InternalProblem.g:1021:1: rule__Identifier__Alternatives : ( ( RULE_ID ) | ( 'true' ) | ( 'false' ) ); | 4587 | // InternalProblem.g:1420:1: rule__Identifier__Alternatives : ( ( RULE_ID ) | ( 'true' ) | ( 'false' ) | ( 'e' ) | ( 'E' ) ); |
3306 | public final void rule__Identifier__Alternatives() throws RecognitionException { | 4588 | public final void rule__Identifier__Alternatives() throws RecognitionException { |
3307 | 4589 | ||
3308 | int stackSize = keepStackSize(); | 4590 | int stackSize = keepStackSize(); |
3309 | 4591 | ||
3310 | try { | 4592 | try { |
3311 | // InternalProblem.g:1025:1: ( ( RULE_ID ) | ( 'true' ) | ( 'false' ) ) | 4593 | // InternalProblem.g:1424:1: ( ( RULE_ID ) | ( 'true' ) | ( 'false' ) | ( 'e' ) | ( 'E' ) ) |
3312 | int alt15=3; | 4594 | int alt18=5; |
3313 | switch ( input.LA(1) ) { | 4595 | switch ( input.LA(1) ) { |
3314 | case RULE_ID: | 4596 | case RULE_ID: |
3315 | { | 4597 | { |
3316 | alt15=1; | 4598 | alt18=1; |
3317 | } | 4599 | } |
3318 | break; | 4600 | break; |
3319 | case 19: | 4601 | case 19: |
3320 | { | 4602 | { |
3321 | alt15=2; | 4603 | alt18=2; |
3322 | } | 4604 | } |
3323 | break; | 4605 | break; |
3324 | case 20: | 4606 | case 20: |
3325 | { | 4607 | { |
3326 | alt15=3; | 4608 | alt18=3; |
4609 | } | ||
4610 | break; | ||
4611 | case 21: | ||
4612 | { | ||
4613 | alt18=4; | ||
4614 | } | ||
4615 | break; | ||
4616 | case 22: | ||
4617 | { | ||
4618 | alt18=5; | ||
3327 | } | 4619 | } |
3328 | break; | 4620 | break; |
3329 | default: | 4621 | default: |
3330 | NoViableAltException nvae = | 4622 | NoViableAltException nvae = |
3331 | new NoViableAltException("", 15, 0, input); | 4623 | new NoViableAltException("", 18, 0, input); |
3332 | 4624 | ||
3333 | throw nvae; | 4625 | throw nvae; |
3334 | } | 4626 | } |
3335 | 4627 | ||
3336 | switch (alt15) { | 4628 | switch (alt18) { |
3337 | case 1 : | 4629 | case 1 : |
3338 | // InternalProblem.g:1026:2: ( RULE_ID ) | 4630 | // InternalProblem.g:1425:2: ( RULE_ID ) |
3339 | { | 4631 | { |
3340 | // InternalProblem.g:1026:2: ( RULE_ID ) | 4632 | // InternalProblem.g:1425:2: ( RULE_ID ) |
3341 | // InternalProblem.g:1027:3: RULE_ID | 4633 | // InternalProblem.g:1426:3: RULE_ID |
3342 | { | 4634 | { |
3343 | before(grammarAccess.getIdentifierAccess().getIDTerminalRuleCall_0()); | 4635 | before(grammarAccess.getIdentifierAccess().getIDTerminalRuleCall_0()); |
3344 | match(input,RULE_ID,FOLLOW_2); | 4636 | match(input,RULE_ID,FOLLOW_2); |
@@ -3350,10 +4642,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3350 | } | 4642 | } |
3351 | break; | 4643 | break; |
3352 | case 2 : | 4644 | case 2 : |
3353 | // InternalProblem.g:1032:2: ( 'true' ) | 4645 | // InternalProblem.g:1431:2: ( 'true' ) |
3354 | { | 4646 | { |
3355 | // InternalProblem.g:1032:2: ( 'true' ) | 4647 | // InternalProblem.g:1431:2: ( 'true' ) |
3356 | // InternalProblem.g:1033:3: 'true' | 4648 | // InternalProblem.g:1432:3: 'true' |
3357 | { | 4649 | { |
3358 | before(grammarAccess.getIdentifierAccess().getTrueKeyword_1()); | 4650 | before(grammarAccess.getIdentifierAccess().getTrueKeyword_1()); |
3359 | match(input,19,FOLLOW_2); | 4651 | match(input,19,FOLLOW_2); |
@@ -3365,10 +4657,10 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3365 | } | 4657 | } |
3366 | break; | 4658 | break; |
3367 | case 3 : | 4659 | case 3 : |
3368 | // InternalProblem.g:1038:2: ( 'false' ) | 4660 | // InternalProblem.g:1437:2: ( 'false' ) |
3369 | { | 4661 | { |
3370 | // InternalProblem.g:1038:2: ( 'false' ) | 4662 | // InternalProblem.g:1437:2: ( 'false' ) |
3371 | // InternalProblem.g:1039:3: 'false' | 4663 | // InternalProblem.g:1438:3: 'false' |
3372 | { | 4664 | { |
3373 | before(grammarAccess.getIdentifierAccess().getFalseKeyword_2()); | 4665 | before(grammarAccess.getIdentifierAccess().getFalseKeyword_2()); |
3374 | match(input,20,FOLLOW_2); | 4666 | match(input,20,FOLLOW_2); |
@@ -3379,6 +4671,36 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3379 | 4671 | ||
3380 | } | 4672 | } |
3381 | break; | 4673 | break; |
4674 | case 4 : | ||
4675 | // InternalProblem.g:1443:2: ( 'e' ) | ||
4676 | { | ||
4677 | // InternalProblem.g:1443:2: ( 'e' ) | ||
4678 | // InternalProblem.g:1444:3: 'e' | ||
4679 | { | ||
4680 | before(grammarAccess.getIdentifierAccess().getEKeyword_3()); | ||
4681 | match(input,21,FOLLOW_2); | ||
4682 | after(grammarAccess.getIdentifierAccess().getEKeyword_3()); | ||
4683 | |||
4684 | } | ||
4685 | |||
4686 | |||
4687 | } | ||
4688 | break; | ||
4689 | case 5 : | ||
4690 | // InternalProblem.g:1449:2: ( 'E' ) | ||
4691 | { | ||
4692 | // InternalProblem.g:1449:2: ( 'E' ) | ||
4693 | // InternalProblem.g:1450:3: 'E' | ||
4694 | { | ||
4695 | before(grammarAccess.getIdentifierAccess().getEKeyword_4()); | ||
4696 | match(input,22,FOLLOW_2); | ||
4697 | after(grammarAccess.getIdentifierAccess().getEKeyword_4()); | ||
4698 | |||
4699 | } | ||
4700 | |||
4701 | |||
4702 | } | ||
4703 | break; | ||
3382 | 4704 | ||
3383 | } | 4705 | } |
3384 | } | 4706 | } |
@@ -3396,48 +4718,304 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3396 | // $ANTLR end "rule__Identifier__Alternatives" | 4718 | // $ANTLR end "rule__Identifier__Alternatives" |
3397 | 4719 | ||
3398 | 4720 | ||
4721 | // $ANTLR start "rule__Real__Alternatives_2" | ||
4722 | // InternalProblem.g:1459:1: rule__Real__Alternatives_2 : ( ( ( rule__Real__Group_2_0__0 ) ) | ( ( rule__Real__Group_2_1__0 ) ) ); | ||
4723 | public final void rule__Real__Alternatives_2() throws RecognitionException { | ||
4724 | |||
4725 | int stackSize = keepStackSize(); | ||
4726 | |||
4727 | try { | ||
4728 | // InternalProblem.g:1463:1: ( ( ( rule__Real__Group_2_0__0 ) ) | ( ( rule__Real__Group_2_1__0 ) ) ) | ||
4729 | int alt19=2; | ||
4730 | int LA19_0 = input.LA(1); | ||
4731 | |||
4732 | if ( (LA19_0==12) ) { | ||
4733 | int LA19_1 = input.LA(2); | ||
4734 | |||
4735 | if ( (LA19_1==RULE_INT) ) { | ||
4736 | int LA19_3 = input.LA(3); | ||
4737 | |||
4738 | if ( ((LA19_3>=21 && LA19_3<=22)) ) { | ||
4739 | alt19=2; | ||
4740 | } | ||
4741 | else if ( (LA19_3==EOF||(LA19_3>=12 && LA19_3<=13)||LA19_3==38) ) { | ||
4742 | alt19=1; | ||
4743 | } | ||
4744 | else { | ||
4745 | NoViableAltException nvae = | ||
4746 | new NoViableAltException("", 19, 3, input); | ||
4747 | |||
4748 | throw nvae; | ||
4749 | } | ||
4750 | } | ||
4751 | else { | ||
4752 | NoViableAltException nvae = | ||
4753 | new NoViableAltException("", 19, 1, input); | ||
4754 | |||
4755 | throw nvae; | ||
4756 | } | ||
4757 | } | ||
4758 | else if ( ((LA19_0>=21 && LA19_0<=22)) ) { | ||
4759 | alt19=2; | ||
4760 | } | ||
4761 | else { | ||
4762 | NoViableAltException nvae = | ||
4763 | new NoViableAltException("", 19, 0, input); | ||
4764 | |||
4765 | throw nvae; | ||
4766 | } | ||
4767 | switch (alt19) { | ||
4768 | case 1 : | ||
4769 | // InternalProblem.g:1464:2: ( ( rule__Real__Group_2_0__0 ) ) | ||
4770 | { | ||
4771 | // InternalProblem.g:1464:2: ( ( rule__Real__Group_2_0__0 ) ) | ||
4772 | // InternalProblem.g:1465:3: ( rule__Real__Group_2_0__0 ) | ||
4773 | { | ||
4774 | before(grammarAccess.getRealAccess().getGroup_2_0()); | ||
4775 | // InternalProblem.g:1466:3: ( rule__Real__Group_2_0__0 ) | ||
4776 | // InternalProblem.g:1466:4: rule__Real__Group_2_0__0 | ||
4777 | { | ||
4778 | pushFollow(FOLLOW_2); | ||
4779 | rule__Real__Group_2_0__0(); | ||
4780 | |||
4781 | state._fsp--; | ||
4782 | |||
4783 | |||
4784 | } | ||
4785 | |||
4786 | after(grammarAccess.getRealAccess().getGroup_2_0()); | ||
4787 | |||
4788 | } | ||
4789 | |||
4790 | |||
4791 | } | ||
4792 | break; | ||
4793 | case 2 : | ||
4794 | // InternalProblem.g:1470:2: ( ( rule__Real__Group_2_1__0 ) ) | ||
4795 | { | ||
4796 | // InternalProblem.g:1470:2: ( ( rule__Real__Group_2_1__0 ) ) | ||
4797 | // InternalProblem.g:1471:3: ( rule__Real__Group_2_1__0 ) | ||
4798 | { | ||
4799 | before(grammarAccess.getRealAccess().getGroup_2_1()); | ||
4800 | // InternalProblem.g:1472:3: ( rule__Real__Group_2_1__0 ) | ||
4801 | // InternalProblem.g:1472:4: rule__Real__Group_2_1__0 | ||
4802 | { | ||
4803 | pushFollow(FOLLOW_2); | ||
4804 | rule__Real__Group_2_1__0(); | ||
4805 | |||
4806 | state._fsp--; | ||
4807 | |||
4808 | |||
4809 | } | ||
4810 | |||
4811 | after(grammarAccess.getRealAccess().getGroup_2_1()); | ||
4812 | |||
4813 | } | ||
4814 | |||
4815 | |||
4816 | } | ||
4817 | break; | ||
4818 | |||
4819 | } | ||
4820 | } | ||
4821 | catch (RecognitionException re) { | ||
4822 | reportError(re); | ||
4823 | recover(input,re); | ||
4824 | } | ||
4825 | finally { | ||
4826 | |||
4827 | restoreStackSize(stackSize); | ||
4828 | |||
4829 | } | ||
4830 | return ; | ||
4831 | } | ||
4832 | // $ANTLR end "rule__Real__Alternatives_2" | ||
4833 | |||
4834 | |||
4835 | // $ANTLR start "rule__Real__Alternatives_2_1_1" | ||
4836 | // InternalProblem.g:1480:1: rule__Real__Alternatives_2_1_1 : ( ( 'e' ) | ( 'E' ) ); | ||
4837 | public final void rule__Real__Alternatives_2_1_1() throws RecognitionException { | ||
4838 | |||
4839 | int stackSize = keepStackSize(); | ||
4840 | |||
4841 | try { | ||
4842 | // InternalProblem.g:1484:1: ( ( 'e' ) | ( 'E' ) ) | ||
4843 | int alt20=2; | ||
4844 | int LA20_0 = input.LA(1); | ||
4845 | |||
4846 | if ( (LA20_0==21) ) { | ||
4847 | alt20=1; | ||
4848 | } | ||
4849 | else if ( (LA20_0==22) ) { | ||
4850 | alt20=2; | ||
4851 | } | ||
4852 | else { | ||
4853 | NoViableAltException nvae = | ||
4854 | new NoViableAltException("", 20, 0, input); | ||
4855 | |||
4856 | throw nvae; | ||
4857 | } | ||
4858 | switch (alt20) { | ||
4859 | case 1 : | ||
4860 | // InternalProblem.g:1485:2: ( 'e' ) | ||
4861 | { | ||
4862 | // InternalProblem.g:1485:2: ( 'e' ) | ||
4863 | // InternalProblem.g:1486:3: 'e' | ||
4864 | { | ||
4865 | before(grammarAccess.getRealAccess().getEKeyword_2_1_1_0()); | ||
4866 | match(input,21,FOLLOW_2); | ||
4867 | after(grammarAccess.getRealAccess().getEKeyword_2_1_1_0()); | ||
4868 | |||
4869 | } | ||
4870 | |||
4871 | |||
4872 | } | ||
4873 | break; | ||
4874 | case 2 : | ||
4875 | // InternalProblem.g:1491:2: ( 'E' ) | ||
4876 | { | ||
4877 | // InternalProblem.g:1491:2: ( 'E' ) | ||
4878 | // InternalProblem.g:1492:3: 'E' | ||
4879 | { | ||
4880 | before(grammarAccess.getRealAccess().getEKeyword_2_1_1_1()); | ||
4881 | match(input,22,FOLLOW_2); | ||
4882 | after(grammarAccess.getRealAccess().getEKeyword_2_1_1_1()); | ||
4883 | |||
4884 | } | ||
4885 | |||
4886 | |||
4887 | } | ||
4888 | break; | ||
4889 | |||
4890 | } | ||
4891 | } | ||
4892 | catch (RecognitionException re) { | ||
4893 | reportError(re); | ||
4894 | recover(input,re); | ||
4895 | } | ||
4896 | finally { | ||
4897 | |||
4898 | restoreStackSize(stackSize); | ||
4899 | |||
4900 | } | ||
4901 | return ; | ||
4902 | } | ||
4903 | // $ANTLR end "rule__Real__Alternatives_2_1_1" | ||
4904 | |||
4905 | |||
4906 | // $ANTLR start "rule__Real__Alternatives_2_1_2" | ||
4907 | // InternalProblem.g:1501:1: rule__Real__Alternatives_2_1_2 : ( ( '-' ) | ( '+' ) ); | ||
4908 | public final void rule__Real__Alternatives_2_1_2() throws RecognitionException { | ||
4909 | |||
4910 | int stackSize = keepStackSize(); | ||
4911 | |||
4912 | try { | ||
4913 | // InternalProblem.g:1505:1: ( ( '-' ) | ( '+' ) ) | ||
4914 | int alt21=2; | ||
4915 | int LA21_0 = input.LA(1); | ||
4916 | |||
4917 | if ( (LA21_0==23) ) { | ||
4918 | alt21=1; | ||
4919 | } | ||
4920 | else if ( (LA21_0==24) ) { | ||
4921 | alt21=2; | ||
4922 | } | ||
4923 | else { | ||
4924 | NoViableAltException nvae = | ||
4925 | new NoViableAltException("", 21, 0, input); | ||
4926 | |||
4927 | throw nvae; | ||
4928 | } | ||
4929 | switch (alt21) { | ||
4930 | case 1 : | ||
4931 | // InternalProblem.g:1506:2: ( '-' ) | ||
4932 | { | ||
4933 | // InternalProblem.g:1506:2: ( '-' ) | ||
4934 | // InternalProblem.g:1507:3: '-' | ||
4935 | { | ||
4936 | before(grammarAccess.getRealAccess().getHyphenMinusKeyword_2_1_2_0()); | ||
4937 | match(input,23,FOLLOW_2); | ||
4938 | after(grammarAccess.getRealAccess().getHyphenMinusKeyword_2_1_2_0()); | ||
4939 | |||
4940 | } | ||
4941 | |||
4942 | |||
4943 | } | ||
4944 | break; | ||
4945 | case 2 : | ||
4946 | // InternalProblem.g:1512:2: ( '+' ) | ||
4947 | { | ||
4948 | // InternalProblem.g:1512:2: ( '+' ) | ||
4949 | // InternalProblem.g:1513:3: '+' | ||
4950 | { | ||
4951 | before(grammarAccess.getRealAccess().getPlusSignKeyword_2_1_2_1()); | ||
4952 | match(input,24,FOLLOW_2); | ||
4953 | after(grammarAccess.getRealAccess().getPlusSignKeyword_2_1_2_1()); | ||
4954 | |||
4955 | } | ||
4956 | |||
4957 | |||
4958 | } | ||
4959 | break; | ||
4960 | |||
4961 | } | ||
4962 | } | ||
4963 | catch (RecognitionException re) { | ||
4964 | reportError(re); | ||
4965 | recover(input,re); | ||
4966 | } | ||
4967 | finally { | ||
4968 | |||
4969 | restoreStackSize(stackSize); | ||
4970 | |||
4971 | } | ||
4972 | return ; | ||
4973 | } | ||
4974 | // $ANTLR end "rule__Real__Alternatives_2_1_2" | ||
4975 | |||
4976 | |||
3399 | // $ANTLR start "rule__LogicValue__Alternatives" | 4977 | // $ANTLR start "rule__LogicValue__Alternatives" |
3400 | // InternalProblem.g:1048:1: rule__LogicValue__Alternatives : ( ( ( 'true' ) ) | ( ( 'false' ) ) | ( ( 'unknown' ) ) ); | 4978 | // InternalProblem.g:1522:1: rule__LogicValue__Alternatives : ( ( ( 'true' ) ) | ( ( 'false' ) ) | ( ( 'unknown' ) ) ); |
3401 | public final void rule__LogicValue__Alternatives() throws RecognitionException { | 4979 | public final void rule__LogicValue__Alternatives() throws RecognitionException { |
3402 | 4980 | ||
3403 | int stackSize = keepStackSize(); | 4981 | int stackSize = keepStackSize(); |
3404 | 4982 | ||
3405 | try { | 4983 | try { |
3406 | // InternalProblem.g:1052:1: ( ( ( 'true' ) ) | ( ( 'false' ) ) | ( ( 'unknown' ) ) ) | 4984 | // InternalProblem.g:1526:1: ( ( ( 'true' ) ) | ( ( 'false' ) ) | ( ( 'unknown' ) ) ) |
3407 | int alt16=3; | 4985 | int alt22=3; |
3408 | switch ( input.LA(1) ) { | 4986 | switch ( input.LA(1) ) { |
3409 | case 19: | 4987 | case 19: |
3410 | { | 4988 | { |
3411 | alt16=1; | 4989 | alt22=1; |
3412 | } | 4990 | } |
3413 | break; | 4991 | break; |
3414 | case 20: | 4992 | case 20: |
3415 | { | 4993 | { |
3416 | alt16=2; | 4994 | alt22=2; |
3417 | } | 4995 | } |
3418 | break; | 4996 | break; |
3419 | case 21: | 4997 | case 25: |
3420 | { | 4998 | { |
3421 | alt16=3; | 4999 | alt22=3; |
3422 | } | 5000 | } |
3423 | break; | 5001 | break; |
3424 | default: | 5002 | default: |
3425 | NoViableAltException nvae = | 5003 | NoViableAltException nvae = |
3426 | new NoViableAltException("", 16, 0, input); | 5004 | new NoViableAltException("", 22, 0, input); |
3427 | 5005 | ||
3428 | throw nvae; | 5006 | throw nvae; |
3429 | } | 5007 | } |
3430 | 5008 | ||
3431 | switch (alt16) { | 5009 | switch (alt22) { |
3432 | case 1 : | 5010 | case 1 : |
3433 | // InternalProblem.g:1053:2: ( ( 'true' ) ) | 5011 | // InternalProblem.g:1527:2: ( ( 'true' ) ) |
3434 | { | 5012 | { |
3435 | // InternalProblem.g:1053:2: ( ( 'true' ) ) | 5013 | // InternalProblem.g:1527:2: ( ( 'true' ) ) |
3436 | // InternalProblem.g:1054:3: ( 'true' ) | 5014 | // InternalProblem.g:1528:3: ( 'true' ) |
3437 | { | 5015 | { |
3438 | before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | 5016 | before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); |
3439 | // InternalProblem.g:1055:3: ( 'true' ) | 5017 | // InternalProblem.g:1529:3: ( 'true' ) |
3440 | // InternalProblem.g:1055:4: 'true' | 5018 | // InternalProblem.g:1529:4: 'true' |
3441 | { | 5019 | { |
3442 | match(input,19,FOLLOW_2); | 5020 | match(input,19,FOLLOW_2); |
3443 | 5021 | ||
@@ -3451,14 +5029,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3451 | } | 5029 | } |
3452 | break; | 5030 | break; |
3453 | case 2 : | 5031 | case 2 : |
3454 | // InternalProblem.g:1059:2: ( ( 'false' ) ) | 5032 | // InternalProblem.g:1533:2: ( ( 'false' ) ) |
3455 | { | 5033 | { |
3456 | // InternalProblem.g:1059:2: ( ( 'false' ) ) | 5034 | // InternalProblem.g:1533:2: ( ( 'false' ) ) |
3457 | // InternalProblem.g:1060:3: ( 'false' ) | 5035 | // InternalProblem.g:1534:3: ( 'false' ) |
3458 | { | 5036 | { |
3459 | before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | 5037 | before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); |
3460 | // InternalProblem.g:1061:3: ( 'false' ) | 5038 | // InternalProblem.g:1535:3: ( 'false' ) |
3461 | // InternalProblem.g:1061:4: 'false' | 5039 | // InternalProblem.g:1535:4: 'false' |
3462 | { | 5040 | { |
3463 | match(input,20,FOLLOW_2); | 5041 | match(input,20,FOLLOW_2); |
3464 | 5042 | ||
@@ -3472,16 +5050,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3472 | } | 5050 | } |
3473 | break; | 5051 | break; |
3474 | case 3 : | 5052 | case 3 : |
3475 | // InternalProblem.g:1065:2: ( ( 'unknown' ) ) | 5053 | // InternalProblem.g:1539:2: ( ( 'unknown' ) ) |
3476 | { | 5054 | { |
3477 | // InternalProblem.g:1065:2: ( ( 'unknown' ) ) | 5055 | // InternalProblem.g:1539:2: ( ( 'unknown' ) ) |
3478 | // InternalProblem.g:1066:3: ( 'unknown' ) | 5056 | // InternalProblem.g:1540:3: ( 'unknown' ) |
3479 | { | 5057 | { |
3480 | before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | 5058 | before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); |
3481 | // InternalProblem.g:1067:3: ( 'unknown' ) | 5059 | // InternalProblem.g:1541:3: ( 'unknown' ) |
3482 | // InternalProblem.g:1067:4: 'unknown' | 5060 | // InternalProblem.g:1541:4: 'unknown' |
3483 | { | 5061 | { |
3484 | match(input,21,FOLLOW_2); | 5062 | match(input,25,FOLLOW_2); |
3485 | 5063 | ||
3486 | } | 5064 | } |
3487 | 5065 | ||
@@ -3510,40 +5088,40 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3510 | 5088 | ||
3511 | 5089 | ||
3512 | // $ANTLR start "rule__ShortLogicValue__Alternatives" | 5090 | // $ANTLR start "rule__ShortLogicValue__Alternatives" |
3513 | // InternalProblem.g:1075:1: rule__ShortLogicValue__Alternatives : ( ( ( '!' ) ) | ( ( '?' ) ) ); | 5091 | // InternalProblem.g:1549:1: rule__ShortLogicValue__Alternatives : ( ( ( '!' ) ) | ( ( '?' ) ) ); |
3514 | public final void rule__ShortLogicValue__Alternatives() throws RecognitionException { | 5092 | public final void rule__ShortLogicValue__Alternatives() throws RecognitionException { |
3515 | 5093 | ||
3516 | int stackSize = keepStackSize(); | 5094 | int stackSize = keepStackSize(); |
3517 | 5095 | ||
3518 | try { | 5096 | try { |
3519 | // InternalProblem.g:1079:1: ( ( ( '!' ) ) | ( ( '?' ) ) ) | 5097 | // InternalProblem.g:1553:1: ( ( ( '!' ) ) | ( ( '?' ) ) ) |
3520 | int alt17=2; | 5098 | int alt23=2; |
3521 | int LA17_0 = input.LA(1); | 5099 | int LA23_0 = input.LA(1); |
3522 | 5100 | ||
3523 | if ( (LA17_0==22) ) { | 5101 | if ( (LA23_0==26) ) { |
3524 | alt17=1; | 5102 | alt23=1; |
3525 | } | 5103 | } |
3526 | else if ( (LA17_0==23) ) { | 5104 | else if ( (LA23_0==27) ) { |
3527 | alt17=2; | 5105 | alt23=2; |
3528 | } | 5106 | } |
3529 | else { | 5107 | else { |
3530 | NoViableAltException nvae = | 5108 | NoViableAltException nvae = |
3531 | new NoViableAltException("", 17, 0, input); | 5109 | new NoViableAltException("", 23, 0, input); |
3532 | 5110 | ||
3533 | throw nvae; | 5111 | throw nvae; |
3534 | } | 5112 | } |
3535 | switch (alt17) { | 5113 | switch (alt23) { |
3536 | case 1 : | 5114 | case 1 : |
3537 | // InternalProblem.g:1080:2: ( ( '!' ) ) | 5115 | // InternalProblem.g:1554:2: ( ( '!' ) ) |
3538 | { | 5116 | { |
3539 | // InternalProblem.g:1080:2: ( ( '!' ) ) | 5117 | // InternalProblem.g:1554:2: ( ( '!' ) ) |
3540 | // InternalProblem.g:1081:3: ( '!' ) | 5118 | // InternalProblem.g:1555:3: ( '!' ) |
3541 | { | 5119 | { |
3542 | before(grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0()); | 5120 | before(grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0()); |
3543 | // InternalProblem.g:1082:3: ( '!' ) | 5121 | // InternalProblem.g:1556:3: ( '!' ) |
3544 | // InternalProblem.g:1082:4: '!' | 5122 | // InternalProblem.g:1556:4: '!' |
3545 | { | 5123 | { |
3546 | match(input,22,FOLLOW_2); | 5124 | match(input,26,FOLLOW_2); |
3547 | 5125 | ||
3548 | } | 5126 | } |
3549 | 5127 | ||
@@ -3555,16 +5133,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3555 | } | 5133 | } |
3556 | break; | 5134 | break; |
3557 | case 2 : | 5135 | case 2 : |
3558 | // InternalProblem.g:1086:2: ( ( '?' ) ) | 5136 | // InternalProblem.g:1560:2: ( ( '?' ) ) |
3559 | { | 5137 | { |
3560 | // InternalProblem.g:1086:2: ( ( '?' ) ) | 5138 | // InternalProblem.g:1560:2: ( ( '?' ) ) |
3561 | // InternalProblem.g:1087:3: ( '?' ) | 5139 | // InternalProblem.g:1561:3: ( '?' ) |
3562 | { | 5140 | { |
3563 | before(grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); | 5141 | before(grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); |
3564 | // InternalProblem.g:1088:3: ( '?' ) | 5142 | // InternalProblem.g:1562:3: ( '?' ) |
3565 | // InternalProblem.g:1088:4: '?' | 5143 | // InternalProblem.g:1562:4: '?' |
3566 | { | 5144 | { |
3567 | match(input,23,FOLLOW_2); | 5145 | match(input,27,FOLLOW_2); |
3568 | 5146 | ||
3569 | } | 5147 | } |
3570 | 5148 | ||
@@ -3593,14 +5171,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3593 | 5171 | ||
3594 | 5172 | ||
3595 | // $ANTLR start "rule__Problem__Group__0" | 5173 | // $ANTLR start "rule__Problem__Group__0" |
3596 | // InternalProblem.g:1096:1: rule__Problem__Group__0 : rule__Problem__Group__0__Impl rule__Problem__Group__1 ; | 5174 | // InternalProblem.g:1570:1: rule__Problem__Group__0 : rule__Problem__Group__0__Impl rule__Problem__Group__1 ; |
3597 | public final void rule__Problem__Group__0() throws RecognitionException { | 5175 | public final void rule__Problem__Group__0() throws RecognitionException { |
3598 | 5176 | ||
3599 | int stackSize = keepStackSize(); | 5177 | int stackSize = keepStackSize(); |
3600 | 5178 | ||
3601 | try { | 5179 | try { |
3602 | // InternalProblem.g:1100:1: ( rule__Problem__Group__0__Impl rule__Problem__Group__1 ) | 5180 | // InternalProblem.g:1574:1: ( rule__Problem__Group__0__Impl rule__Problem__Group__1 ) |
3603 | // InternalProblem.g:1101:2: rule__Problem__Group__0__Impl rule__Problem__Group__1 | 5181 | // InternalProblem.g:1575:2: rule__Problem__Group__0__Impl rule__Problem__Group__1 |
3604 | { | 5182 | { |
3605 | pushFollow(FOLLOW_3); | 5183 | pushFollow(FOLLOW_3); |
3606 | rule__Problem__Group__0__Impl(); | 5184 | rule__Problem__Group__0__Impl(); |
@@ -3631,29 +5209,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3631 | 5209 | ||
3632 | 5210 | ||
3633 | // $ANTLR start "rule__Problem__Group__0__Impl" | 5211 | // $ANTLR start "rule__Problem__Group__0__Impl" |
3634 | // InternalProblem.g:1108:1: rule__Problem__Group__0__Impl : ( ( rule__Problem__Group_0__0 )? ) ; | 5212 | // InternalProblem.g:1582:1: rule__Problem__Group__0__Impl : ( ( rule__Problem__Group_0__0 )? ) ; |
3635 | public final void rule__Problem__Group__0__Impl() throws RecognitionException { | 5213 | public final void rule__Problem__Group__0__Impl() throws RecognitionException { |
3636 | 5214 | ||
3637 | int stackSize = keepStackSize(); | 5215 | int stackSize = keepStackSize(); |
3638 | 5216 | ||
3639 | try { | 5217 | try { |
3640 | // InternalProblem.g:1112:1: ( ( ( rule__Problem__Group_0__0 )? ) ) | 5218 | // InternalProblem.g:1586:1: ( ( ( rule__Problem__Group_0__0 )? ) ) |
3641 | // InternalProblem.g:1113:1: ( ( rule__Problem__Group_0__0 )? ) | 5219 | // InternalProblem.g:1587:1: ( ( rule__Problem__Group_0__0 )? ) |
3642 | { | 5220 | { |
3643 | // InternalProblem.g:1113:1: ( ( rule__Problem__Group_0__0 )? ) | 5221 | // InternalProblem.g:1587:1: ( ( rule__Problem__Group_0__0 )? ) |
3644 | // InternalProblem.g:1114:2: ( rule__Problem__Group_0__0 )? | 5222 | // InternalProblem.g:1588:2: ( rule__Problem__Group_0__0 )? |
3645 | { | 5223 | { |
3646 | before(grammarAccess.getProblemAccess().getGroup_0()); | 5224 | before(grammarAccess.getProblemAccess().getGroup_0()); |
3647 | // InternalProblem.g:1115:2: ( rule__Problem__Group_0__0 )? | 5225 | // InternalProblem.g:1589:2: ( rule__Problem__Group_0__0 )? |
3648 | int alt18=2; | 5226 | int alt24=2; |
3649 | int LA18_0 = input.LA(1); | 5227 | int LA24_0 = input.LA(1); |
3650 | 5228 | ||
3651 | if ( (LA18_0==24) ) { | 5229 | if ( (LA24_0==28) ) { |
3652 | alt18=1; | 5230 | alt24=1; |
3653 | } | 5231 | } |
3654 | switch (alt18) { | 5232 | switch (alt24) { |
3655 | case 1 : | 5233 | case 1 : |
3656 | // InternalProblem.g:1115:3: rule__Problem__Group_0__0 | 5234 | // InternalProblem.g:1589:3: rule__Problem__Group_0__0 |
3657 | { | 5235 | { |
3658 | pushFollow(FOLLOW_2); | 5236 | pushFollow(FOLLOW_2); |
3659 | rule__Problem__Group_0__0(); | 5237 | rule__Problem__Group_0__0(); |
@@ -3689,14 +5267,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3689 | 5267 | ||
3690 | 5268 | ||
3691 | // $ANTLR start "rule__Problem__Group__1" | 5269 | // $ANTLR start "rule__Problem__Group__1" |
3692 | // InternalProblem.g:1123:1: rule__Problem__Group__1 : rule__Problem__Group__1__Impl ; | 5270 | // InternalProblem.g:1597:1: rule__Problem__Group__1 : rule__Problem__Group__1__Impl ; |
3693 | public final void rule__Problem__Group__1() throws RecognitionException { | 5271 | public final void rule__Problem__Group__1() throws RecognitionException { |
3694 | 5272 | ||
3695 | int stackSize = keepStackSize(); | 5273 | int stackSize = keepStackSize(); |
3696 | 5274 | ||
3697 | try { | 5275 | try { |
3698 | // InternalProblem.g:1127:1: ( rule__Problem__Group__1__Impl ) | 5276 | // InternalProblem.g:1601:1: ( rule__Problem__Group__1__Impl ) |
3699 | // InternalProblem.g:1128:2: rule__Problem__Group__1__Impl | 5277 | // InternalProblem.g:1602:2: rule__Problem__Group__1__Impl |
3700 | { | 5278 | { |
3701 | pushFollow(FOLLOW_2); | 5279 | pushFollow(FOLLOW_2); |
3702 | rule__Problem__Group__1__Impl(); | 5280 | rule__Problem__Group__1__Impl(); |
@@ -3722,33 +5300,33 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3722 | 5300 | ||
3723 | 5301 | ||
3724 | // $ANTLR start "rule__Problem__Group__1__Impl" | 5302 | // $ANTLR start "rule__Problem__Group__1__Impl" |
3725 | // InternalProblem.g:1134:1: rule__Problem__Group__1__Impl : ( ( rule__Problem__StatementsAssignment_1 )* ) ; | 5303 | // InternalProblem.g:1608:1: rule__Problem__Group__1__Impl : ( ( rule__Problem__StatementsAssignment_1 )* ) ; |
3726 | public final void rule__Problem__Group__1__Impl() throws RecognitionException { | 5304 | public final void rule__Problem__Group__1__Impl() throws RecognitionException { |
3727 | 5305 | ||
3728 | int stackSize = keepStackSize(); | 5306 | int stackSize = keepStackSize(); |
3729 | 5307 | ||
3730 | try { | 5308 | try { |
3731 | // InternalProblem.g:1138:1: ( ( ( rule__Problem__StatementsAssignment_1 )* ) ) | 5309 | // InternalProblem.g:1612:1: ( ( ( rule__Problem__StatementsAssignment_1 )* ) ) |
3732 | // InternalProblem.g:1139:1: ( ( rule__Problem__StatementsAssignment_1 )* ) | 5310 | // InternalProblem.g:1613:1: ( ( rule__Problem__StatementsAssignment_1 )* ) |
3733 | { | 5311 | { |
3734 | // InternalProblem.g:1139:1: ( ( rule__Problem__StatementsAssignment_1 )* ) | 5312 | // InternalProblem.g:1613:1: ( ( rule__Problem__StatementsAssignment_1 )* ) |
3735 | // InternalProblem.g:1140:2: ( rule__Problem__StatementsAssignment_1 )* | 5313 | // InternalProblem.g:1614:2: ( rule__Problem__StatementsAssignment_1 )* |
3736 | { | 5314 | { |
3737 | before(grammarAccess.getProblemAccess().getStatementsAssignment_1()); | 5315 | before(grammarAccess.getProblemAccess().getStatementsAssignment_1()); |
3738 | // InternalProblem.g:1141:2: ( rule__Problem__StatementsAssignment_1 )* | 5316 | // InternalProblem.g:1615:2: ( rule__Problem__StatementsAssignment_1 )* |
3739 | loop19: | 5317 | loop25: |
3740 | do { | 5318 | do { |
3741 | int alt19=2; | 5319 | int alt25=2; |
3742 | int LA19_0 = input.LA(1); | 5320 | int LA25_0 = input.LA(1); |
3743 | 5321 | ||
3744 | if ( ((LA19_0>=RULE_QUOTED_ID && LA19_0<=RULE_ID)||LA19_0==16||(LA19_0>=19 && LA19_0<=20)||(LA19_0>=22 && LA19_0<=23)||LA19_0==25||LA19_0==29||LA19_0==37||LA19_0==40||LA19_0==42) ) { | 5322 | if ( ((LA25_0>=RULE_QUOTED_ID && LA25_0<=RULE_ID)||LA25_0==16||(LA25_0>=19 && LA25_0<=22)||(LA25_0>=26 && LA25_0<=27)||LA25_0==29||LA25_0==33||LA25_0==41||LA25_0==44||LA25_0==46) ) { |
3745 | alt19=1; | 5323 | alt25=1; |
3746 | } | 5324 | } |
3747 | 5325 | ||
3748 | 5326 | ||
3749 | switch (alt19) { | 5327 | switch (alt25) { |
3750 | case 1 : | 5328 | case 1 : |
3751 | // InternalProblem.g:1141:3: rule__Problem__StatementsAssignment_1 | 5329 | // InternalProblem.g:1615:3: rule__Problem__StatementsAssignment_1 |
3752 | { | 5330 | { |
3753 | pushFollow(FOLLOW_4); | 5331 | pushFollow(FOLLOW_4); |
3754 | rule__Problem__StatementsAssignment_1(); | 5332 | rule__Problem__StatementsAssignment_1(); |
@@ -3760,7 +5338,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3760 | break; | 5338 | break; |
3761 | 5339 | ||
3762 | default : | 5340 | default : |
3763 | break loop19; | 5341 | break loop25; |
3764 | } | 5342 | } |
3765 | } while (true); | 5343 | } while (true); |
3766 | 5344 | ||
@@ -3787,14 +5365,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3787 | 5365 | ||
3788 | 5366 | ||
3789 | // $ANTLR start "rule__Problem__Group_0__0" | 5367 | // $ANTLR start "rule__Problem__Group_0__0" |
3790 | // InternalProblem.g:1150:1: rule__Problem__Group_0__0 : rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 ; | 5368 | // InternalProblem.g:1624:1: rule__Problem__Group_0__0 : rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 ; |
3791 | public final void rule__Problem__Group_0__0() throws RecognitionException { | 5369 | public final void rule__Problem__Group_0__0() throws RecognitionException { |
3792 | 5370 | ||
3793 | int stackSize = keepStackSize(); | 5371 | int stackSize = keepStackSize(); |
3794 | 5372 | ||
3795 | try { | 5373 | try { |
3796 | // InternalProblem.g:1154:1: ( rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 ) | 5374 | // InternalProblem.g:1628:1: ( rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 ) |
3797 | // InternalProblem.g:1155:2: rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 | 5375 | // InternalProblem.g:1629:2: rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 |
3798 | { | 5376 | { |
3799 | pushFollow(FOLLOW_5); | 5377 | pushFollow(FOLLOW_5); |
3800 | rule__Problem__Group_0__0__Impl(); | 5378 | rule__Problem__Group_0__0__Impl(); |
@@ -3825,20 +5403,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3825 | 5403 | ||
3826 | 5404 | ||
3827 | // $ANTLR start "rule__Problem__Group_0__0__Impl" | 5405 | // $ANTLR start "rule__Problem__Group_0__0__Impl" |
3828 | // InternalProblem.g:1162:1: rule__Problem__Group_0__0__Impl : ( 'problem' ) ; | 5406 | // InternalProblem.g:1636:1: rule__Problem__Group_0__0__Impl : ( 'problem' ) ; |
3829 | public final void rule__Problem__Group_0__0__Impl() throws RecognitionException { | 5407 | public final void rule__Problem__Group_0__0__Impl() throws RecognitionException { |
3830 | 5408 | ||
3831 | int stackSize = keepStackSize(); | 5409 | int stackSize = keepStackSize(); |
3832 | 5410 | ||
3833 | try { | 5411 | try { |
3834 | // InternalProblem.g:1166:1: ( ( 'problem' ) ) | 5412 | // InternalProblem.g:1640:1: ( ( 'problem' ) ) |
3835 | // InternalProblem.g:1167:1: ( 'problem' ) | 5413 | // InternalProblem.g:1641:1: ( 'problem' ) |
3836 | { | 5414 | { |
3837 | // InternalProblem.g:1167:1: ( 'problem' ) | 5415 | // InternalProblem.g:1641:1: ( 'problem' ) |
3838 | // InternalProblem.g:1168:2: 'problem' | 5416 | // InternalProblem.g:1642:2: 'problem' |
3839 | { | 5417 | { |
3840 | before(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); | 5418 | before(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); |
3841 | match(input,24,FOLLOW_2); | 5419 | match(input,28,FOLLOW_2); |
3842 | after(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); | 5420 | after(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); |
3843 | 5421 | ||
3844 | } | 5422 | } |
@@ -3862,14 +5440,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3862 | 5440 | ||
3863 | 5441 | ||
3864 | // $ANTLR start "rule__Problem__Group_0__1" | 5442 | // $ANTLR start "rule__Problem__Group_0__1" |
3865 | // InternalProblem.g:1177:1: rule__Problem__Group_0__1 : rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 ; | 5443 | // InternalProblem.g:1651:1: rule__Problem__Group_0__1 : rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 ; |
3866 | public final void rule__Problem__Group_0__1() throws RecognitionException { | 5444 | public final void rule__Problem__Group_0__1() throws RecognitionException { |
3867 | 5445 | ||
3868 | int stackSize = keepStackSize(); | 5446 | int stackSize = keepStackSize(); |
3869 | 5447 | ||
3870 | try { | 5448 | try { |
3871 | // InternalProblem.g:1181:1: ( rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 ) | 5449 | // InternalProblem.g:1655:1: ( rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 ) |
3872 | // InternalProblem.g:1182:2: rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 | 5450 | // InternalProblem.g:1656:2: rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 |
3873 | { | 5451 | { |
3874 | pushFollow(FOLLOW_6); | 5452 | pushFollow(FOLLOW_6); |
3875 | rule__Problem__Group_0__1__Impl(); | 5453 | rule__Problem__Group_0__1__Impl(); |
@@ -3900,21 +5478,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3900 | 5478 | ||
3901 | 5479 | ||
3902 | // $ANTLR start "rule__Problem__Group_0__1__Impl" | 5480 | // $ANTLR start "rule__Problem__Group_0__1__Impl" |
3903 | // InternalProblem.g:1189:1: rule__Problem__Group_0__1__Impl : ( ( rule__Problem__NameAssignment_0_1 ) ) ; | 5481 | // InternalProblem.g:1663:1: rule__Problem__Group_0__1__Impl : ( ( rule__Problem__NameAssignment_0_1 ) ) ; |
3904 | public final void rule__Problem__Group_0__1__Impl() throws RecognitionException { | 5482 | public final void rule__Problem__Group_0__1__Impl() throws RecognitionException { |
3905 | 5483 | ||
3906 | int stackSize = keepStackSize(); | 5484 | int stackSize = keepStackSize(); |
3907 | 5485 | ||
3908 | try { | 5486 | try { |
3909 | // InternalProblem.g:1193:1: ( ( ( rule__Problem__NameAssignment_0_1 ) ) ) | 5487 | // InternalProblem.g:1667:1: ( ( ( rule__Problem__NameAssignment_0_1 ) ) ) |
3910 | // InternalProblem.g:1194:1: ( ( rule__Problem__NameAssignment_0_1 ) ) | 5488 | // InternalProblem.g:1668:1: ( ( rule__Problem__NameAssignment_0_1 ) ) |
3911 | { | 5489 | { |
3912 | // InternalProblem.g:1194:1: ( ( rule__Problem__NameAssignment_0_1 ) ) | 5490 | // InternalProblem.g:1668:1: ( ( rule__Problem__NameAssignment_0_1 ) ) |
3913 | // InternalProblem.g:1195:2: ( rule__Problem__NameAssignment_0_1 ) | 5491 | // InternalProblem.g:1669:2: ( rule__Problem__NameAssignment_0_1 ) |
3914 | { | 5492 | { |
3915 | before(grammarAccess.getProblemAccess().getNameAssignment_0_1()); | 5493 | before(grammarAccess.getProblemAccess().getNameAssignment_0_1()); |
3916 | // InternalProblem.g:1196:2: ( rule__Problem__NameAssignment_0_1 ) | 5494 | // InternalProblem.g:1670:2: ( rule__Problem__NameAssignment_0_1 ) |
3917 | // InternalProblem.g:1196:3: rule__Problem__NameAssignment_0_1 | 5495 | // InternalProblem.g:1670:3: rule__Problem__NameAssignment_0_1 |
3918 | { | 5496 | { |
3919 | pushFollow(FOLLOW_2); | 5497 | pushFollow(FOLLOW_2); |
3920 | rule__Problem__NameAssignment_0_1(); | 5498 | rule__Problem__NameAssignment_0_1(); |
@@ -3947,14 +5525,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3947 | 5525 | ||
3948 | 5526 | ||
3949 | // $ANTLR start "rule__Problem__Group_0__2" | 5527 | // $ANTLR start "rule__Problem__Group_0__2" |
3950 | // InternalProblem.g:1204:1: rule__Problem__Group_0__2 : rule__Problem__Group_0__2__Impl ; | 5528 | // InternalProblem.g:1678:1: rule__Problem__Group_0__2 : rule__Problem__Group_0__2__Impl ; |
3951 | public final void rule__Problem__Group_0__2() throws RecognitionException { | 5529 | public final void rule__Problem__Group_0__2() throws RecognitionException { |
3952 | 5530 | ||
3953 | int stackSize = keepStackSize(); | 5531 | int stackSize = keepStackSize(); |
3954 | 5532 | ||
3955 | try { | 5533 | try { |
3956 | // InternalProblem.g:1208:1: ( rule__Problem__Group_0__2__Impl ) | 5534 | // InternalProblem.g:1682:1: ( rule__Problem__Group_0__2__Impl ) |
3957 | // InternalProblem.g:1209:2: rule__Problem__Group_0__2__Impl | 5535 | // InternalProblem.g:1683:2: rule__Problem__Group_0__2__Impl |
3958 | { | 5536 | { |
3959 | pushFollow(FOLLOW_2); | 5537 | pushFollow(FOLLOW_2); |
3960 | rule__Problem__Group_0__2__Impl(); | 5538 | rule__Problem__Group_0__2__Impl(); |
@@ -3980,17 +5558,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
3980 | 5558 | ||
3981 | 5559 | ||
3982 | // $ANTLR start "rule__Problem__Group_0__2__Impl" | 5560 | // $ANTLR start "rule__Problem__Group_0__2__Impl" |
3983 | // InternalProblem.g:1215:1: rule__Problem__Group_0__2__Impl : ( '.' ) ; | 5561 | // InternalProblem.g:1689:1: rule__Problem__Group_0__2__Impl : ( '.' ) ; |
3984 | public final void rule__Problem__Group_0__2__Impl() throws RecognitionException { | 5562 | public final void rule__Problem__Group_0__2__Impl() throws RecognitionException { |
3985 | 5563 | ||
3986 | int stackSize = keepStackSize(); | 5564 | int stackSize = keepStackSize(); |
3987 | 5565 | ||
3988 | try { | 5566 | try { |
3989 | // InternalProblem.g:1219:1: ( ( '.' ) ) | 5567 | // InternalProblem.g:1693:1: ( ( '.' ) ) |
3990 | // InternalProblem.g:1220:1: ( '.' ) | 5568 | // InternalProblem.g:1694:1: ( '.' ) |
3991 | { | 5569 | { |
3992 | // InternalProblem.g:1220:1: ( '.' ) | 5570 | // InternalProblem.g:1694:1: ( '.' ) |
3993 | // InternalProblem.g:1221:2: '.' | 5571 | // InternalProblem.g:1695:2: '.' |
3994 | { | 5572 | { |
3995 | before(grammarAccess.getProblemAccess().getFullStopKeyword_0_2()); | 5573 | before(grammarAccess.getProblemAccess().getFullStopKeyword_0_2()); |
3996 | match(input,12,FOLLOW_2); | 5574 | match(input,12,FOLLOW_2); |
@@ -4017,14 +5595,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4017 | 5595 | ||
4018 | 5596 | ||
4019 | // $ANTLR start "rule__ClassDeclaration__Group__0" | 5597 | // $ANTLR start "rule__ClassDeclaration__Group__0" |
4020 | // InternalProblem.g:1231:1: rule__ClassDeclaration__Group__0 : rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 ; | 5598 | // InternalProblem.g:1705:1: rule__ClassDeclaration__Group__0 : rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 ; |
4021 | public final void rule__ClassDeclaration__Group__0() throws RecognitionException { | 5599 | public final void rule__ClassDeclaration__Group__0() throws RecognitionException { |
4022 | 5600 | ||
4023 | int stackSize = keepStackSize(); | 5601 | int stackSize = keepStackSize(); |
4024 | 5602 | ||
4025 | try { | 5603 | try { |
4026 | // InternalProblem.g:1235:1: ( rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 ) | 5604 | // InternalProblem.g:1709:1: ( rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 ) |
4027 | // InternalProblem.g:1236:2: rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 | 5605 | // InternalProblem.g:1710:2: rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 |
4028 | { | 5606 | { |
4029 | pushFollow(FOLLOW_7); | 5607 | pushFollow(FOLLOW_7); |
4030 | rule__ClassDeclaration__Group__0__Impl(); | 5608 | rule__ClassDeclaration__Group__0__Impl(); |
@@ -4055,29 +5633,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4055 | 5633 | ||
4056 | 5634 | ||
4057 | // $ANTLR start "rule__ClassDeclaration__Group__0__Impl" | 5635 | // $ANTLR start "rule__ClassDeclaration__Group__0__Impl" |
4058 | // InternalProblem.g:1243:1: rule__ClassDeclaration__Group__0__Impl : ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) ; | 5636 | // InternalProblem.g:1717:1: rule__ClassDeclaration__Group__0__Impl : ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) ; |
4059 | public final void rule__ClassDeclaration__Group__0__Impl() throws RecognitionException { | 5637 | public final void rule__ClassDeclaration__Group__0__Impl() throws RecognitionException { |
4060 | 5638 | ||
4061 | int stackSize = keepStackSize(); | 5639 | int stackSize = keepStackSize(); |
4062 | 5640 | ||
4063 | try { | 5641 | try { |
4064 | // InternalProblem.g:1247:1: ( ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) ) | 5642 | // InternalProblem.g:1721:1: ( ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) ) |
4065 | // InternalProblem.g:1248:1: ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) | 5643 | // InternalProblem.g:1722:1: ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) |
4066 | { | 5644 | { |
4067 | // InternalProblem.g:1248:1: ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) | 5645 | // InternalProblem.g:1722:1: ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) |
4068 | // InternalProblem.g:1249:2: ( rule__ClassDeclaration__AbstractAssignment_0 )? | 5646 | // InternalProblem.g:1723:2: ( rule__ClassDeclaration__AbstractAssignment_0 )? |
4069 | { | 5647 | { |
4070 | before(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0()); | 5648 | before(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0()); |
4071 | // InternalProblem.g:1250:2: ( rule__ClassDeclaration__AbstractAssignment_0 )? | 5649 | // InternalProblem.g:1724:2: ( rule__ClassDeclaration__AbstractAssignment_0 )? |
4072 | int alt20=2; | 5650 | int alt26=2; |
4073 | int LA20_0 = input.LA(1); | 5651 | int LA26_0 = input.LA(1); |
4074 | 5652 | ||
4075 | if ( (LA20_0==40) ) { | 5653 | if ( (LA26_0==44) ) { |
4076 | alt20=1; | 5654 | alt26=1; |
4077 | } | 5655 | } |
4078 | switch (alt20) { | 5656 | switch (alt26) { |
4079 | case 1 : | 5657 | case 1 : |
4080 | // InternalProblem.g:1250:3: rule__ClassDeclaration__AbstractAssignment_0 | 5658 | // InternalProblem.g:1724:3: rule__ClassDeclaration__AbstractAssignment_0 |
4081 | { | 5659 | { |
4082 | pushFollow(FOLLOW_2); | 5660 | pushFollow(FOLLOW_2); |
4083 | rule__ClassDeclaration__AbstractAssignment_0(); | 5661 | rule__ClassDeclaration__AbstractAssignment_0(); |
@@ -4113,14 +5691,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4113 | 5691 | ||
4114 | 5692 | ||
4115 | // $ANTLR start "rule__ClassDeclaration__Group__1" | 5693 | // $ANTLR start "rule__ClassDeclaration__Group__1" |
4116 | // InternalProblem.g:1258:1: rule__ClassDeclaration__Group__1 : rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 ; | 5694 | // InternalProblem.g:1732:1: rule__ClassDeclaration__Group__1 : rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 ; |
4117 | public final void rule__ClassDeclaration__Group__1() throws RecognitionException { | 5695 | public final void rule__ClassDeclaration__Group__1() throws RecognitionException { |
4118 | 5696 | ||
4119 | int stackSize = keepStackSize(); | 5697 | int stackSize = keepStackSize(); |
4120 | 5698 | ||
4121 | try { | 5699 | try { |
4122 | // InternalProblem.g:1262:1: ( rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 ) | 5700 | // InternalProblem.g:1736:1: ( rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 ) |
4123 | // InternalProblem.g:1263:2: rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 | 5701 | // InternalProblem.g:1737:2: rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 |
4124 | { | 5702 | { |
4125 | pushFollow(FOLLOW_5); | 5703 | pushFollow(FOLLOW_5); |
4126 | rule__ClassDeclaration__Group__1__Impl(); | 5704 | rule__ClassDeclaration__Group__1__Impl(); |
@@ -4151,20 +5729,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4151 | 5729 | ||
4152 | 5730 | ||
4153 | // $ANTLR start "rule__ClassDeclaration__Group__1__Impl" | 5731 | // $ANTLR start "rule__ClassDeclaration__Group__1__Impl" |
4154 | // InternalProblem.g:1270:1: rule__ClassDeclaration__Group__1__Impl : ( 'class' ) ; | 5732 | // InternalProblem.g:1744:1: rule__ClassDeclaration__Group__1__Impl : ( 'class' ) ; |
4155 | public final void rule__ClassDeclaration__Group__1__Impl() throws RecognitionException { | 5733 | public final void rule__ClassDeclaration__Group__1__Impl() throws RecognitionException { |
4156 | 5734 | ||
4157 | int stackSize = keepStackSize(); | 5735 | int stackSize = keepStackSize(); |
4158 | 5736 | ||
4159 | try { | 5737 | try { |
4160 | // InternalProblem.g:1274:1: ( ( 'class' ) ) | 5738 | // InternalProblem.g:1748:1: ( ( 'class' ) ) |
4161 | // InternalProblem.g:1275:1: ( 'class' ) | 5739 | // InternalProblem.g:1749:1: ( 'class' ) |
4162 | { | 5740 | { |
4163 | // InternalProblem.g:1275:1: ( 'class' ) | 5741 | // InternalProblem.g:1749:1: ( 'class' ) |
4164 | // InternalProblem.g:1276:2: 'class' | 5742 | // InternalProblem.g:1750:2: 'class' |
4165 | { | 5743 | { |
4166 | before(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); | 5744 | before(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); |
4167 | match(input,25,FOLLOW_2); | 5745 | match(input,29,FOLLOW_2); |
4168 | after(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); | 5746 | after(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); |
4169 | 5747 | ||
4170 | } | 5748 | } |
@@ -4188,14 +5766,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4188 | 5766 | ||
4189 | 5767 | ||
4190 | // $ANTLR start "rule__ClassDeclaration__Group__2" | 5768 | // $ANTLR start "rule__ClassDeclaration__Group__2" |
4191 | // InternalProblem.g:1285:1: rule__ClassDeclaration__Group__2 : rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 ; | 5769 | // InternalProblem.g:1759:1: rule__ClassDeclaration__Group__2 : rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 ; |
4192 | public final void rule__ClassDeclaration__Group__2() throws RecognitionException { | 5770 | public final void rule__ClassDeclaration__Group__2() throws RecognitionException { |
4193 | 5771 | ||
4194 | int stackSize = keepStackSize(); | 5772 | int stackSize = keepStackSize(); |
4195 | 5773 | ||
4196 | try { | 5774 | try { |
4197 | // InternalProblem.g:1289:1: ( rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 ) | 5775 | // InternalProblem.g:1763:1: ( rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 ) |
4198 | // InternalProblem.g:1290:2: rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 | 5776 | // InternalProblem.g:1764:2: rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 |
4199 | { | 5777 | { |
4200 | pushFollow(FOLLOW_8); | 5778 | pushFollow(FOLLOW_8); |
4201 | rule__ClassDeclaration__Group__2__Impl(); | 5779 | rule__ClassDeclaration__Group__2__Impl(); |
@@ -4226,21 +5804,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4226 | 5804 | ||
4227 | 5805 | ||
4228 | // $ANTLR start "rule__ClassDeclaration__Group__2__Impl" | 5806 | // $ANTLR start "rule__ClassDeclaration__Group__2__Impl" |
4229 | // InternalProblem.g:1297:1: rule__ClassDeclaration__Group__2__Impl : ( ( rule__ClassDeclaration__NameAssignment_2 ) ) ; | 5807 | // InternalProblem.g:1771:1: rule__ClassDeclaration__Group__2__Impl : ( ( rule__ClassDeclaration__NameAssignment_2 ) ) ; |
4230 | public final void rule__ClassDeclaration__Group__2__Impl() throws RecognitionException { | 5808 | public final void rule__ClassDeclaration__Group__2__Impl() throws RecognitionException { |
4231 | 5809 | ||
4232 | int stackSize = keepStackSize(); | 5810 | int stackSize = keepStackSize(); |
4233 | 5811 | ||
4234 | try { | 5812 | try { |
4235 | // InternalProblem.g:1301:1: ( ( ( rule__ClassDeclaration__NameAssignment_2 ) ) ) | 5813 | // InternalProblem.g:1775:1: ( ( ( rule__ClassDeclaration__NameAssignment_2 ) ) ) |
4236 | // InternalProblem.g:1302:1: ( ( rule__ClassDeclaration__NameAssignment_2 ) ) | 5814 | // InternalProblem.g:1776:1: ( ( rule__ClassDeclaration__NameAssignment_2 ) ) |
4237 | { | 5815 | { |
4238 | // InternalProblem.g:1302:1: ( ( rule__ClassDeclaration__NameAssignment_2 ) ) | 5816 | // InternalProblem.g:1776:1: ( ( rule__ClassDeclaration__NameAssignment_2 ) ) |
4239 | // InternalProblem.g:1303:2: ( rule__ClassDeclaration__NameAssignment_2 ) | 5817 | // InternalProblem.g:1777:2: ( rule__ClassDeclaration__NameAssignment_2 ) |
4240 | { | 5818 | { |
4241 | before(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); | 5819 | before(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); |
4242 | // InternalProblem.g:1304:2: ( rule__ClassDeclaration__NameAssignment_2 ) | 5820 | // InternalProblem.g:1778:2: ( rule__ClassDeclaration__NameAssignment_2 ) |
4243 | // InternalProblem.g:1304:3: rule__ClassDeclaration__NameAssignment_2 | 5821 | // InternalProblem.g:1778:3: rule__ClassDeclaration__NameAssignment_2 |
4244 | { | 5822 | { |
4245 | pushFollow(FOLLOW_2); | 5823 | pushFollow(FOLLOW_2); |
4246 | rule__ClassDeclaration__NameAssignment_2(); | 5824 | rule__ClassDeclaration__NameAssignment_2(); |
@@ -4273,14 +5851,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4273 | 5851 | ||
4274 | 5852 | ||
4275 | // $ANTLR start "rule__ClassDeclaration__Group__3" | 5853 | // $ANTLR start "rule__ClassDeclaration__Group__3" |
4276 | // InternalProblem.g:1312:1: rule__ClassDeclaration__Group__3 : rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 ; | 5854 | // InternalProblem.g:1786:1: rule__ClassDeclaration__Group__3 : rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 ; |
4277 | public final void rule__ClassDeclaration__Group__3() throws RecognitionException { | 5855 | public final void rule__ClassDeclaration__Group__3() throws RecognitionException { |
4278 | 5856 | ||
4279 | int stackSize = keepStackSize(); | 5857 | int stackSize = keepStackSize(); |
4280 | 5858 | ||
4281 | try { | 5859 | try { |
4282 | // InternalProblem.g:1316:1: ( rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 ) | 5860 | // InternalProblem.g:1790:1: ( rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 ) |
4283 | // InternalProblem.g:1317:2: rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 | 5861 | // InternalProblem.g:1791:2: rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 |
4284 | { | 5862 | { |
4285 | pushFollow(FOLLOW_8); | 5863 | pushFollow(FOLLOW_8); |
4286 | rule__ClassDeclaration__Group__3__Impl(); | 5864 | rule__ClassDeclaration__Group__3__Impl(); |
@@ -4311,29 +5889,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4311 | 5889 | ||
4312 | 5890 | ||
4313 | // $ANTLR start "rule__ClassDeclaration__Group__3__Impl" | 5891 | // $ANTLR start "rule__ClassDeclaration__Group__3__Impl" |
4314 | // InternalProblem.g:1324:1: rule__ClassDeclaration__Group__3__Impl : ( ( rule__ClassDeclaration__Group_3__0 )? ) ; | 5892 | // InternalProblem.g:1798:1: rule__ClassDeclaration__Group__3__Impl : ( ( rule__ClassDeclaration__Group_3__0 )? ) ; |
4315 | public final void rule__ClassDeclaration__Group__3__Impl() throws RecognitionException { | 5893 | public final void rule__ClassDeclaration__Group__3__Impl() throws RecognitionException { |
4316 | 5894 | ||
4317 | int stackSize = keepStackSize(); | 5895 | int stackSize = keepStackSize(); |
4318 | 5896 | ||
4319 | try { | 5897 | try { |
4320 | // InternalProblem.g:1328:1: ( ( ( rule__ClassDeclaration__Group_3__0 )? ) ) | 5898 | // InternalProblem.g:1802:1: ( ( ( rule__ClassDeclaration__Group_3__0 )? ) ) |
4321 | // InternalProblem.g:1329:1: ( ( rule__ClassDeclaration__Group_3__0 )? ) | 5899 | // InternalProblem.g:1803:1: ( ( rule__ClassDeclaration__Group_3__0 )? ) |
4322 | { | 5900 | { |
4323 | // InternalProblem.g:1329:1: ( ( rule__ClassDeclaration__Group_3__0 )? ) | 5901 | // InternalProblem.g:1803:1: ( ( rule__ClassDeclaration__Group_3__0 )? ) |
4324 | // InternalProblem.g:1330:2: ( rule__ClassDeclaration__Group_3__0 )? | 5902 | // InternalProblem.g:1804:2: ( rule__ClassDeclaration__Group_3__0 )? |
4325 | { | 5903 | { |
4326 | before(grammarAccess.getClassDeclarationAccess().getGroup_3()); | 5904 | before(grammarAccess.getClassDeclarationAccess().getGroup_3()); |
4327 | // InternalProblem.g:1331:2: ( rule__ClassDeclaration__Group_3__0 )? | 5905 | // InternalProblem.g:1805:2: ( rule__ClassDeclaration__Group_3__0 )? |
4328 | int alt21=2; | 5906 | int alt27=2; |
4329 | int LA21_0 = input.LA(1); | 5907 | int LA27_0 = input.LA(1); |
4330 | 5908 | ||
4331 | if ( (LA21_0==26) ) { | 5909 | if ( (LA27_0==30) ) { |
4332 | alt21=1; | 5910 | alt27=1; |
4333 | } | 5911 | } |
4334 | switch (alt21) { | 5912 | switch (alt27) { |
4335 | case 1 : | 5913 | case 1 : |
4336 | // InternalProblem.g:1331:3: rule__ClassDeclaration__Group_3__0 | 5914 | // InternalProblem.g:1805:3: rule__ClassDeclaration__Group_3__0 |
4337 | { | 5915 | { |
4338 | pushFollow(FOLLOW_2); | 5916 | pushFollow(FOLLOW_2); |
4339 | rule__ClassDeclaration__Group_3__0(); | 5917 | rule__ClassDeclaration__Group_3__0(); |
@@ -4369,14 +5947,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4369 | 5947 | ||
4370 | 5948 | ||
4371 | // $ANTLR start "rule__ClassDeclaration__Group__4" | 5949 | // $ANTLR start "rule__ClassDeclaration__Group__4" |
4372 | // InternalProblem.g:1339:1: rule__ClassDeclaration__Group__4 : rule__ClassDeclaration__Group__4__Impl ; | 5950 | // InternalProblem.g:1813:1: rule__ClassDeclaration__Group__4 : rule__ClassDeclaration__Group__4__Impl ; |
4373 | public final void rule__ClassDeclaration__Group__4() throws RecognitionException { | 5951 | public final void rule__ClassDeclaration__Group__4() throws RecognitionException { |
4374 | 5952 | ||
4375 | int stackSize = keepStackSize(); | 5953 | int stackSize = keepStackSize(); |
4376 | 5954 | ||
4377 | try { | 5955 | try { |
4378 | // InternalProblem.g:1343:1: ( rule__ClassDeclaration__Group__4__Impl ) | 5956 | // InternalProblem.g:1817:1: ( rule__ClassDeclaration__Group__4__Impl ) |
4379 | // InternalProblem.g:1344:2: rule__ClassDeclaration__Group__4__Impl | 5957 | // InternalProblem.g:1818:2: rule__ClassDeclaration__Group__4__Impl |
4380 | { | 5958 | { |
4381 | pushFollow(FOLLOW_2); | 5959 | pushFollow(FOLLOW_2); |
4382 | rule__ClassDeclaration__Group__4__Impl(); | 5960 | rule__ClassDeclaration__Group__4__Impl(); |
@@ -4402,21 +5980,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4402 | 5980 | ||
4403 | 5981 | ||
4404 | // $ANTLR start "rule__ClassDeclaration__Group__4__Impl" | 5982 | // $ANTLR start "rule__ClassDeclaration__Group__4__Impl" |
4405 | // InternalProblem.g:1350:1: rule__ClassDeclaration__Group__4__Impl : ( ( rule__ClassDeclaration__Alternatives_4 ) ) ; | 5983 | // InternalProblem.g:1824:1: rule__ClassDeclaration__Group__4__Impl : ( ( rule__ClassDeclaration__Alternatives_4 ) ) ; |
4406 | public final void rule__ClassDeclaration__Group__4__Impl() throws RecognitionException { | 5984 | public final void rule__ClassDeclaration__Group__4__Impl() throws RecognitionException { |
4407 | 5985 | ||
4408 | int stackSize = keepStackSize(); | 5986 | int stackSize = keepStackSize(); |
4409 | 5987 | ||
4410 | try { | 5988 | try { |
4411 | // InternalProblem.g:1354:1: ( ( ( rule__ClassDeclaration__Alternatives_4 ) ) ) | 5989 | // InternalProblem.g:1828:1: ( ( ( rule__ClassDeclaration__Alternatives_4 ) ) ) |
4412 | // InternalProblem.g:1355:1: ( ( rule__ClassDeclaration__Alternatives_4 ) ) | 5990 | // InternalProblem.g:1829:1: ( ( rule__ClassDeclaration__Alternatives_4 ) ) |
4413 | { | 5991 | { |
4414 | // InternalProblem.g:1355:1: ( ( rule__ClassDeclaration__Alternatives_4 ) ) | 5992 | // InternalProblem.g:1829:1: ( ( rule__ClassDeclaration__Alternatives_4 ) ) |
4415 | // InternalProblem.g:1356:2: ( rule__ClassDeclaration__Alternatives_4 ) | 5993 | // InternalProblem.g:1830:2: ( rule__ClassDeclaration__Alternatives_4 ) |
4416 | { | 5994 | { |
4417 | before(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); | 5995 | before(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); |
4418 | // InternalProblem.g:1357:2: ( rule__ClassDeclaration__Alternatives_4 ) | 5996 | // InternalProblem.g:1831:2: ( rule__ClassDeclaration__Alternatives_4 ) |
4419 | // InternalProblem.g:1357:3: rule__ClassDeclaration__Alternatives_4 | 5997 | // InternalProblem.g:1831:3: rule__ClassDeclaration__Alternatives_4 |
4420 | { | 5998 | { |
4421 | pushFollow(FOLLOW_2); | 5999 | pushFollow(FOLLOW_2); |
4422 | rule__ClassDeclaration__Alternatives_4(); | 6000 | rule__ClassDeclaration__Alternatives_4(); |
@@ -4449,14 +6027,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4449 | 6027 | ||
4450 | 6028 | ||
4451 | // $ANTLR start "rule__ClassDeclaration__Group_3__0" | 6029 | // $ANTLR start "rule__ClassDeclaration__Group_3__0" |
4452 | // InternalProblem.g:1366:1: rule__ClassDeclaration__Group_3__0 : rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 ; | 6030 | // InternalProblem.g:1840:1: rule__ClassDeclaration__Group_3__0 : rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 ; |
4453 | public final void rule__ClassDeclaration__Group_3__0() throws RecognitionException { | 6031 | public final void rule__ClassDeclaration__Group_3__0() throws RecognitionException { |
4454 | 6032 | ||
4455 | int stackSize = keepStackSize(); | 6033 | int stackSize = keepStackSize(); |
4456 | 6034 | ||
4457 | try { | 6035 | try { |
4458 | // InternalProblem.g:1370:1: ( rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 ) | 6036 | // InternalProblem.g:1844:1: ( rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 ) |
4459 | // InternalProblem.g:1371:2: rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 | 6037 | // InternalProblem.g:1845:2: rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 |
4460 | { | 6038 | { |
4461 | pushFollow(FOLLOW_5); | 6039 | pushFollow(FOLLOW_5); |
4462 | rule__ClassDeclaration__Group_3__0__Impl(); | 6040 | rule__ClassDeclaration__Group_3__0__Impl(); |
@@ -4487,20 +6065,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4487 | 6065 | ||
4488 | 6066 | ||
4489 | // $ANTLR start "rule__ClassDeclaration__Group_3__0__Impl" | 6067 | // $ANTLR start "rule__ClassDeclaration__Group_3__0__Impl" |
4490 | // InternalProblem.g:1378:1: rule__ClassDeclaration__Group_3__0__Impl : ( 'extends' ) ; | 6068 | // InternalProblem.g:1852:1: rule__ClassDeclaration__Group_3__0__Impl : ( 'extends' ) ; |
4491 | public final void rule__ClassDeclaration__Group_3__0__Impl() throws RecognitionException { | 6069 | public final void rule__ClassDeclaration__Group_3__0__Impl() throws RecognitionException { |
4492 | 6070 | ||
4493 | int stackSize = keepStackSize(); | 6071 | int stackSize = keepStackSize(); |
4494 | 6072 | ||
4495 | try { | 6073 | try { |
4496 | // InternalProblem.g:1382:1: ( ( 'extends' ) ) | 6074 | // InternalProblem.g:1856:1: ( ( 'extends' ) ) |
4497 | // InternalProblem.g:1383:1: ( 'extends' ) | 6075 | // InternalProblem.g:1857:1: ( 'extends' ) |
4498 | { | 6076 | { |
4499 | // InternalProblem.g:1383:1: ( 'extends' ) | 6077 | // InternalProblem.g:1857:1: ( 'extends' ) |
4500 | // InternalProblem.g:1384:2: 'extends' | 6078 | // InternalProblem.g:1858:2: 'extends' |
4501 | { | 6079 | { |
4502 | before(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); | 6080 | before(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); |
4503 | match(input,26,FOLLOW_2); | 6081 | match(input,30,FOLLOW_2); |
4504 | after(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); | 6082 | after(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); |
4505 | 6083 | ||
4506 | } | 6084 | } |
@@ -4524,14 +6102,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4524 | 6102 | ||
4525 | 6103 | ||
4526 | // $ANTLR start "rule__ClassDeclaration__Group_3__1" | 6104 | // $ANTLR start "rule__ClassDeclaration__Group_3__1" |
4527 | // InternalProblem.g:1393:1: rule__ClassDeclaration__Group_3__1 : rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 ; | 6105 | // InternalProblem.g:1867:1: rule__ClassDeclaration__Group_3__1 : rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 ; |
4528 | public final void rule__ClassDeclaration__Group_3__1() throws RecognitionException { | 6106 | public final void rule__ClassDeclaration__Group_3__1() throws RecognitionException { |
4529 | 6107 | ||
4530 | int stackSize = keepStackSize(); | 6108 | int stackSize = keepStackSize(); |
4531 | 6109 | ||
4532 | try { | 6110 | try { |
4533 | // InternalProblem.g:1397:1: ( rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 ) | 6111 | // InternalProblem.g:1871:1: ( rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 ) |
4534 | // InternalProblem.g:1398:2: rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 | 6112 | // InternalProblem.g:1872:2: rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 |
4535 | { | 6113 | { |
4536 | pushFollow(FOLLOW_9); | 6114 | pushFollow(FOLLOW_9); |
4537 | rule__ClassDeclaration__Group_3__1__Impl(); | 6115 | rule__ClassDeclaration__Group_3__1__Impl(); |
@@ -4562,21 +6140,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4562 | 6140 | ||
4563 | 6141 | ||
4564 | // $ANTLR start "rule__ClassDeclaration__Group_3__1__Impl" | 6142 | // $ANTLR start "rule__ClassDeclaration__Group_3__1__Impl" |
4565 | // InternalProblem.g:1405:1: rule__ClassDeclaration__Group_3__1__Impl : ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) ; | 6143 | // InternalProblem.g:1879:1: rule__ClassDeclaration__Group_3__1__Impl : ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) ; |
4566 | public final void rule__ClassDeclaration__Group_3__1__Impl() throws RecognitionException { | 6144 | public final void rule__ClassDeclaration__Group_3__1__Impl() throws RecognitionException { |
4567 | 6145 | ||
4568 | int stackSize = keepStackSize(); | 6146 | int stackSize = keepStackSize(); |
4569 | 6147 | ||
4570 | try { | 6148 | try { |
4571 | // InternalProblem.g:1409:1: ( ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) ) | 6149 | // InternalProblem.g:1883:1: ( ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) ) |
4572 | // InternalProblem.g:1410:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) | 6150 | // InternalProblem.g:1884:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) |
4573 | { | 6151 | { |
4574 | // InternalProblem.g:1410:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) | 6152 | // InternalProblem.g:1884:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) |
4575 | // InternalProblem.g:1411:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) | 6153 | // InternalProblem.g:1885:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) |
4576 | { | 6154 | { |
4577 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_1()); | 6155 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_1()); |
4578 | // InternalProblem.g:1412:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) | 6156 | // InternalProblem.g:1886:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) |
4579 | // InternalProblem.g:1412:3: rule__ClassDeclaration__SuperTypesAssignment_3_1 | 6157 | // InternalProblem.g:1886:3: rule__ClassDeclaration__SuperTypesAssignment_3_1 |
4580 | { | 6158 | { |
4581 | pushFollow(FOLLOW_2); | 6159 | pushFollow(FOLLOW_2); |
4582 | rule__ClassDeclaration__SuperTypesAssignment_3_1(); | 6160 | rule__ClassDeclaration__SuperTypesAssignment_3_1(); |
@@ -4609,14 +6187,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4609 | 6187 | ||
4610 | 6188 | ||
4611 | // $ANTLR start "rule__ClassDeclaration__Group_3__2" | 6189 | // $ANTLR start "rule__ClassDeclaration__Group_3__2" |
4612 | // InternalProblem.g:1420:1: rule__ClassDeclaration__Group_3__2 : rule__ClassDeclaration__Group_3__2__Impl ; | 6190 | // InternalProblem.g:1894:1: rule__ClassDeclaration__Group_3__2 : rule__ClassDeclaration__Group_3__2__Impl ; |
4613 | public final void rule__ClassDeclaration__Group_3__2() throws RecognitionException { | 6191 | public final void rule__ClassDeclaration__Group_3__2() throws RecognitionException { |
4614 | 6192 | ||
4615 | int stackSize = keepStackSize(); | 6193 | int stackSize = keepStackSize(); |
4616 | 6194 | ||
4617 | try { | 6195 | try { |
4618 | // InternalProblem.g:1424:1: ( rule__ClassDeclaration__Group_3__2__Impl ) | 6196 | // InternalProblem.g:1898:1: ( rule__ClassDeclaration__Group_3__2__Impl ) |
4619 | // InternalProblem.g:1425:2: rule__ClassDeclaration__Group_3__2__Impl | 6197 | // InternalProblem.g:1899:2: rule__ClassDeclaration__Group_3__2__Impl |
4620 | { | 6198 | { |
4621 | pushFollow(FOLLOW_2); | 6199 | pushFollow(FOLLOW_2); |
4622 | rule__ClassDeclaration__Group_3__2__Impl(); | 6200 | rule__ClassDeclaration__Group_3__2__Impl(); |
@@ -4642,33 +6220,33 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4642 | 6220 | ||
4643 | 6221 | ||
4644 | // $ANTLR start "rule__ClassDeclaration__Group_3__2__Impl" | 6222 | // $ANTLR start "rule__ClassDeclaration__Group_3__2__Impl" |
4645 | // InternalProblem.g:1431:1: rule__ClassDeclaration__Group_3__2__Impl : ( ( rule__ClassDeclaration__Group_3_2__0 )* ) ; | 6223 | // InternalProblem.g:1905:1: rule__ClassDeclaration__Group_3__2__Impl : ( ( rule__ClassDeclaration__Group_3_2__0 )* ) ; |
4646 | public final void rule__ClassDeclaration__Group_3__2__Impl() throws RecognitionException { | 6224 | public final void rule__ClassDeclaration__Group_3__2__Impl() throws RecognitionException { |
4647 | 6225 | ||
4648 | int stackSize = keepStackSize(); | 6226 | int stackSize = keepStackSize(); |
4649 | 6227 | ||
4650 | try { | 6228 | try { |
4651 | // InternalProblem.g:1435:1: ( ( ( rule__ClassDeclaration__Group_3_2__0 )* ) ) | 6229 | // InternalProblem.g:1909:1: ( ( ( rule__ClassDeclaration__Group_3_2__0 )* ) ) |
4652 | // InternalProblem.g:1436:1: ( ( rule__ClassDeclaration__Group_3_2__0 )* ) | 6230 | // InternalProblem.g:1910:1: ( ( rule__ClassDeclaration__Group_3_2__0 )* ) |
4653 | { | 6231 | { |
4654 | // InternalProblem.g:1436:1: ( ( rule__ClassDeclaration__Group_3_2__0 )* ) | 6232 | // InternalProblem.g:1910:1: ( ( rule__ClassDeclaration__Group_3_2__0 )* ) |
4655 | // InternalProblem.g:1437:2: ( rule__ClassDeclaration__Group_3_2__0 )* | 6233 | // InternalProblem.g:1911:2: ( rule__ClassDeclaration__Group_3_2__0 )* |
4656 | { | 6234 | { |
4657 | before(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); | 6235 | before(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); |
4658 | // InternalProblem.g:1438:2: ( rule__ClassDeclaration__Group_3_2__0 )* | 6236 | // InternalProblem.g:1912:2: ( rule__ClassDeclaration__Group_3_2__0 )* |
4659 | loop22: | 6237 | loop28: |
4660 | do { | 6238 | do { |
4661 | int alt22=2; | 6239 | int alt28=2; |
4662 | int LA22_0 = input.LA(1); | 6240 | int LA28_0 = input.LA(1); |
4663 | 6241 | ||
4664 | if ( (LA22_0==13) ) { | 6242 | if ( (LA28_0==13) ) { |
4665 | alt22=1; | 6243 | alt28=1; |
4666 | } | 6244 | } |
4667 | 6245 | ||
4668 | 6246 | ||
4669 | switch (alt22) { | 6247 | switch (alt28) { |
4670 | case 1 : | 6248 | case 1 : |
4671 | // InternalProblem.g:1438:3: rule__ClassDeclaration__Group_3_2__0 | 6249 | // InternalProblem.g:1912:3: rule__ClassDeclaration__Group_3_2__0 |
4672 | { | 6250 | { |
4673 | pushFollow(FOLLOW_10); | 6251 | pushFollow(FOLLOW_10); |
4674 | rule__ClassDeclaration__Group_3_2__0(); | 6252 | rule__ClassDeclaration__Group_3_2__0(); |
@@ -4680,7 +6258,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4680 | break; | 6258 | break; |
4681 | 6259 | ||
4682 | default : | 6260 | default : |
4683 | break loop22; | 6261 | break loop28; |
4684 | } | 6262 | } |
4685 | } while (true); | 6263 | } while (true); |
4686 | 6264 | ||
@@ -4707,14 +6285,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4707 | 6285 | ||
4708 | 6286 | ||
4709 | // $ANTLR start "rule__ClassDeclaration__Group_3_2__0" | 6287 | // $ANTLR start "rule__ClassDeclaration__Group_3_2__0" |
4710 | // InternalProblem.g:1447:1: rule__ClassDeclaration__Group_3_2__0 : rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 ; | 6288 | // InternalProblem.g:1921:1: rule__ClassDeclaration__Group_3_2__0 : rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 ; |
4711 | public final void rule__ClassDeclaration__Group_3_2__0() throws RecognitionException { | 6289 | public final void rule__ClassDeclaration__Group_3_2__0() throws RecognitionException { |
4712 | 6290 | ||
4713 | int stackSize = keepStackSize(); | 6291 | int stackSize = keepStackSize(); |
4714 | 6292 | ||
4715 | try { | 6293 | try { |
4716 | // InternalProblem.g:1451:1: ( rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 ) | 6294 | // InternalProblem.g:1925:1: ( rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 ) |
4717 | // InternalProblem.g:1452:2: rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 | 6295 | // InternalProblem.g:1926:2: rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 |
4718 | { | 6296 | { |
4719 | pushFollow(FOLLOW_5); | 6297 | pushFollow(FOLLOW_5); |
4720 | rule__ClassDeclaration__Group_3_2__0__Impl(); | 6298 | rule__ClassDeclaration__Group_3_2__0__Impl(); |
@@ -4745,17 +6323,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4745 | 6323 | ||
4746 | 6324 | ||
4747 | // $ANTLR start "rule__ClassDeclaration__Group_3_2__0__Impl" | 6325 | // $ANTLR start "rule__ClassDeclaration__Group_3_2__0__Impl" |
4748 | // InternalProblem.g:1459:1: rule__ClassDeclaration__Group_3_2__0__Impl : ( ',' ) ; | 6326 | // InternalProblem.g:1933:1: rule__ClassDeclaration__Group_3_2__0__Impl : ( ',' ) ; |
4749 | public final void rule__ClassDeclaration__Group_3_2__0__Impl() throws RecognitionException { | 6327 | public final void rule__ClassDeclaration__Group_3_2__0__Impl() throws RecognitionException { |
4750 | 6328 | ||
4751 | int stackSize = keepStackSize(); | 6329 | int stackSize = keepStackSize(); |
4752 | 6330 | ||
4753 | try { | 6331 | try { |
4754 | // InternalProblem.g:1463:1: ( ( ',' ) ) | 6332 | // InternalProblem.g:1937:1: ( ( ',' ) ) |
4755 | // InternalProblem.g:1464:1: ( ',' ) | 6333 | // InternalProblem.g:1938:1: ( ',' ) |
4756 | { | 6334 | { |
4757 | // InternalProblem.g:1464:1: ( ',' ) | 6335 | // InternalProblem.g:1938:1: ( ',' ) |
4758 | // InternalProblem.g:1465:2: ',' | 6336 | // InternalProblem.g:1939:2: ',' |
4759 | { | 6337 | { |
4760 | before(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); | 6338 | before(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); |
4761 | match(input,13,FOLLOW_2); | 6339 | match(input,13,FOLLOW_2); |
@@ -4782,14 +6360,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4782 | 6360 | ||
4783 | 6361 | ||
4784 | // $ANTLR start "rule__ClassDeclaration__Group_3_2__1" | 6362 | // $ANTLR start "rule__ClassDeclaration__Group_3_2__1" |
4785 | // InternalProblem.g:1474:1: rule__ClassDeclaration__Group_3_2__1 : rule__ClassDeclaration__Group_3_2__1__Impl ; | 6363 | // InternalProblem.g:1948:1: rule__ClassDeclaration__Group_3_2__1 : rule__ClassDeclaration__Group_3_2__1__Impl ; |
4786 | public final void rule__ClassDeclaration__Group_3_2__1() throws RecognitionException { | 6364 | public final void rule__ClassDeclaration__Group_3_2__1() throws RecognitionException { |
4787 | 6365 | ||
4788 | int stackSize = keepStackSize(); | 6366 | int stackSize = keepStackSize(); |
4789 | 6367 | ||
4790 | try { | 6368 | try { |
4791 | // InternalProblem.g:1478:1: ( rule__ClassDeclaration__Group_3_2__1__Impl ) | 6369 | // InternalProblem.g:1952:1: ( rule__ClassDeclaration__Group_3_2__1__Impl ) |
4792 | // InternalProblem.g:1479:2: rule__ClassDeclaration__Group_3_2__1__Impl | 6370 | // InternalProblem.g:1953:2: rule__ClassDeclaration__Group_3_2__1__Impl |
4793 | { | 6371 | { |
4794 | pushFollow(FOLLOW_2); | 6372 | pushFollow(FOLLOW_2); |
4795 | rule__ClassDeclaration__Group_3_2__1__Impl(); | 6373 | rule__ClassDeclaration__Group_3_2__1__Impl(); |
@@ -4815,21 +6393,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4815 | 6393 | ||
4816 | 6394 | ||
4817 | // $ANTLR start "rule__ClassDeclaration__Group_3_2__1__Impl" | 6395 | // $ANTLR start "rule__ClassDeclaration__Group_3_2__1__Impl" |
4818 | // InternalProblem.g:1485:1: rule__ClassDeclaration__Group_3_2__1__Impl : ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) ; | 6396 | // InternalProblem.g:1959:1: rule__ClassDeclaration__Group_3_2__1__Impl : ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) ; |
4819 | public final void rule__ClassDeclaration__Group_3_2__1__Impl() throws RecognitionException { | 6397 | public final void rule__ClassDeclaration__Group_3_2__1__Impl() throws RecognitionException { |
4820 | 6398 | ||
4821 | int stackSize = keepStackSize(); | 6399 | int stackSize = keepStackSize(); |
4822 | 6400 | ||
4823 | try { | 6401 | try { |
4824 | // InternalProblem.g:1489:1: ( ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) ) | 6402 | // InternalProblem.g:1963:1: ( ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) ) |
4825 | // InternalProblem.g:1490:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) | 6403 | // InternalProblem.g:1964:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) |
4826 | { | 6404 | { |
4827 | // InternalProblem.g:1490:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) | 6405 | // InternalProblem.g:1964:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) |
4828 | // InternalProblem.g:1491:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) | 6406 | // InternalProblem.g:1965:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) |
4829 | { | 6407 | { |
4830 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_2_1()); | 6408 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_2_1()); |
4831 | // InternalProblem.g:1492:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) | 6409 | // InternalProblem.g:1966:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) |
4832 | // InternalProblem.g:1492:3: rule__ClassDeclaration__SuperTypesAssignment_3_2_1 | 6410 | // InternalProblem.g:1966:3: rule__ClassDeclaration__SuperTypesAssignment_3_2_1 |
4833 | { | 6411 | { |
4834 | pushFollow(FOLLOW_2); | 6412 | pushFollow(FOLLOW_2); |
4835 | rule__ClassDeclaration__SuperTypesAssignment_3_2_1(); | 6413 | rule__ClassDeclaration__SuperTypesAssignment_3_2_1(); |
@@ -4862,14 +6440,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4862 | 6440 | ||
4863 | 6441 | ||
4864 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__0" | 6442 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__0" |
4865 | // InternalProblem.g:1501:1: rule__ClassDeclaration__Group_4_0__0 : rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 ; | 6443 | // InternalProblem.g:1975:1: rule__ClassDeclaration__Group_4_0__0 : rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 ; |
4866 | public final void rule__ClassDeclaration__Group_4_0__0() throws RecognitionException { | 6444 | public final void rule__ClassDeclaration__Group_4_0__0() throws RecognitionException { |
4867 | 6445 | ||
4868 | int stackSize = keepStackSize(); | 6446 | int stackSize = keepStackSize(); |
4869 | 6447 | ||
4870 | try { | 6448 | try { |
4871 | // InternalProblem.g:1505:1: ( rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 ) | 6449 | // InternalProblem.g:1979:1: ( rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 ) |
4872 | // InternalProblem.g:1506:2: rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 | 6450 | // InternalProblem.g:1980:2: rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 |
4873 | { | 6451 | { |
4874 | pushFollow(FOLLOW_11); | 6452 | pushFollow(FOLLOW_11); |
4875 | rule__ClassDeclaration__Group_4_0__0__Impl(); | 6453 | rule__ClassDeclaration__Group_4_0__0__Impl(); |
@@ -4900,20 +6478,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4900 | 6478 | ||
4901 | 6479 | ||
4902 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__0__Impl" | 6480 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__0__Impl" |
4903 | // InternalProblem.g:1513:1: rule__ClassDeclaration__Group_4_0__0__Impl : ( '{' ) ; | 6481 | // InternalProblem.g:1987:1: rule__ClassDeclaration__Group_4_0__0__Impl : ( '{' ) ; |
4904 | public final void rule__ClassDeclaration__Group_4_0__0__Impl() throws RecognitionException { | 6482 | public final void rule__ClassDeclaration__Group_4_0__0__Impl() throws RecognitionException { |
4905 | 6483 | ||
4906 | int stackSize = keepStackSize(); | 6484 | int stackSize = keepStackSize(); |
4907 | 6485 | ||
4908 | try { | 6486 | try { |
4909 | // InternalProblem.g:1517:1: ( ( '{' ) ) | 6487 | // InternalProblem.g:1991:1: ( ( '{' ) ) |
4910 | // InternalProblem.g:1518:1: ( '{' ) | 6488 | // InternalProblem.g:1992:1: ( '{' ) |
4911 | { | 6489 | { |
4912 | // InternalProblem.g:1518:1: ( '{' ) | 6490 | // InternalProblem.g:1992:1: ( '{' ) |
4913 | // InternalProblem.g:1519:2: '{' | 6491 | // InternalProblem.g:1993:2: '{' |
4914 | { | 6492 | { |
4915 | before(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); | 6493 | before(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); |
4916 | match(input,27,FOLLOW_2); | 6494 | match(input,31,FOLLOW_2); |
4917 | after(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); | 6495 | after(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); |
4918 | 6496 | ||
4919 | } | 6497 | } |
@@ -4937,14 +6515,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4937 | 6515 | ||
4938 | 6516 | ||
4939 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__1" | 6517 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__1" |
4940 | // InternalProblem.g:1528:1: rule__ClassDeclaration__Group_4_0__1 : rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 ; | 6518 | // InternalProblem.g:2002:1: rule__ClassDeclaration__Group_4_0__1 : rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 ; |
4941 | public final void rule__ClassDeclaration__Group_4_0__1() throws RecognitionException { | 6519 | public final void rule__ClassDeclaration__Group_4_0__1() throws RecognitionException { |
4942 | 6520 | ||
4943 | int stackSize = keepStackSize(); | 6521 | int stackSize = keepStackSize(); |
4944 | 6522 | ||
4945 | try { | 6523 | try { |
4946 | // InternalProblem.g:1532:1: ( rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 ) | 6524 | // InternalProblem.g:2006:1: ( rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 ) |
4947 | // InternalProblem.g:1533:2: rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 | 6525 | // InternalProblem.g:2007:2: rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 |
4948 | { | 6526 | { |
4949 | pushFollow(FOLLOW_11); | 6527 | pushFollow(FOLLOW_11); |
4950 | rule__ClassDeclaration__Group_4_0__1__Impl(); | 6528 | rule__ClassDeclaration__Group_4_0__1__Impl(); |
@@ -4975,33 +6553,33 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
4975 | 6553 | ||
4976 | 6554 | ||
4977 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__1__Impl" | 6555 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__1__Impl" |
4978 | // InternalProblem.g:1540:1: rule__ClassDeclaration__Group_4_0__1__Impl : ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) ; | 6556 | // InternalProblem.g:2014:1: rule__ClassDeclaration__Group_4_0__1__Impl : ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) ; |
4979 | public final void rule__ClassDeclaration__Group_4_0__1__Impl() throws RecognitionException { | 6557 | public final void rule__ClassDeclaration__Group_4_0__1__Impl() throws RecognitionException { |
4980 | 6558 | ||
4981 | int stackSize = keepStackSize(); | 6559 | int stackSize = keepStackSize(); |
4982 | 6560 | ||
4983 | try { | 6561 | try { |
4984 | // InternalProblem.g:1544:1: ( ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) ) | 6562 | // InternalProblem.g:2018:1: ( ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) ) |
4985 | // InternalProblem.g:1545:1: ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) | 6563 | // InternalProblem.g:2019:1: ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) |
4986 | { | 6564 | { |
4987 | // InternalProblem.g:1545:1: ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) | 6565 | // InternalProblem.g:2019:1: ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) |
4988 | // InternalProblem.g:1546:2: ( rule__ClassDeclaration__Group_4_0_1__0 )* | 6566 | // InternalProblem.g:2020:2: ( rule__ClassDeclaration__Group_4_0_1__0 )* |
4989 | { | 6567 | { |
4990 | before(grammarAccess.getClassDeclarationAccess().getGroup_4_0_1()); | 6568 | before(grammarAccess.getClassDeclarationAccess().getGroup_4_0_1()); |
4991 | // InternalProblem.g:1547:2: ( rule__ClassDeclaration__Group_4_0_1__0 )* | 6569 | // InternalProblem.g:2021:2: ( rule__ClassDeclaration__Group_4_0_1__0 )* |
4992 | loop23: | 6570 | loop29: |
4993 | do { | 6571 | do { |
4994 | int alt23=2; | 6572 | int alt29=2; |
4995 | int LA23_0 = input.LA(1); | 6573 | int LA29_0 = input.LA(1); |
4996 | 6574 | ||
4997 | if ( ((LA23_0>=RULE_QUOTED_ID && LA23_0<=RULE_ID)||LA23_0==15||(LA23_0>=19 && LA23_0<=20)||LA23_0==41) ) { | 6575 | if ( ((LA29_0>=RULE_QUOTED_ID && LA29_0<=RULE_ID)||LA29_0==15||(LA29_0>=19 && LA29_0<=22)||LA29_0==45) ) { |
4998 | alt23=1; | 6576 | alt29=1; |
4999 | } | 6577 | } |
5000 | 6578 | ||
5001 | 6579 | ||
5002 | switch (alt23) { | 6580 | switch (alt29) { |
5003 | case 1 : | 6581 | case 1 : |
5004 | // InternalProblem.g:1547:3: rule__ClassDeclaration__Group_4_0_1__0 | 6582 | // InternalProblem.g:2021:3: rule__ClassDeclaration__Group_4_0_1__0 |
5005 | { | 6583 | { |
5006 | pushFollow(FOLLOW_12); | 6584 | pushFollow(FOLLOW_12); |
5007 | rule__ClassDeclaration__Group_4_0_1__0(); | 6585 | rule__ClassDeclaration__Group_4_0_1__0(); |
@@ -5013,7 +6591,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5013 | break; | 6591 | break; |
5014 | 6592 | ||
5015 | default : | 6593 | default : |
5016 | break loop23; | 6594 | break loop29; |
5017 | } | 6595 | } |
5018 | } while (true); | 6596 | } while (true); |
5019 | 6597 | ||
@@ -5040,14 +6618,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5040 | 6618 | ||
5041 | 6619 | ||
5042 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__2" | 6620 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__2" |
5043 | // InternalProblem.g:1555:1: rule__ClassDeclaration__Group_4_0__2 : rule__ClassDeclaration__Group_4_0__2__Impl ; | 6621 | // InternalProblem.g:2029:1: rule__ClassDeclaration__Group_4_0__2 : rule__ClassDeclaration__Group_4_0__2__Impl ; |
5044 | public final void rule__ClassDeclaration__Group_4_0__2() throws RecognitionException { | 6622 | public final void rule__ClassDeclaration__Group_4_0__2() throws RecognitionException { |
5045 | 6623 | ||
5046 | int stackSize = keepStackSize(); | 6624 | int stackSize = keepStackSize(); |
5047 | 6625 | ||
5048 | try { | 6626 | try { |
5049 | // InternalProblem.g:1559:1: ( rule__ClassDeclaration__Group_4_0__2__Impl ) | 6627 | // InternalProblem.g:2033:1: ( rule__ClassDeclaration__Group_4_0__2__Impl ) |
5050 | // InternalProblem.g:1560:2: rule__ClassDeclaration__Group_4_0__2__Impl | 6628 | // InternalProblem.g:2034:2: rule__ClassDeclaration__Group_4_0__2__Impl |
5051 | { | 6629 | { |
5052 | pushFollow(FOLLOW_2); | 6630 | pushFollow(FOLLOW_2); |
5053 | rule__ClassDeclaration__Group_4_0__2__Impl(); | 6631 | rule__ClassDeclaration__Group_4_0__2__Impl(); |
@@ -5073,20 +6651,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5073 | 6651 | ||
5074 | 6652 | ||
5075 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__2__Impl" | 6653 | // $ANTLR start "rule__ClassDeclaration__Group_4_0__2__Impl" |
5076 | // InternalProblem.g:1566:1: rule__ClassDeclaration__Group_4_0__2__Impl : ( '}' ) ; | 6654 | // InternalProblem.g:2040:1: rule__ClassDeclaration__Group_4_0__2__Impl : ( '}' ) ; |
5077 | public final void rule__ClassDeclaration__Group_4_0__2__Impl() throws RecognitionException { | 6655 | public final void rule__ClassDeclaration__Group_4_0__2__Impl() throws RecognitionException { |
5078 | 6656 | ||
5079 | int stackSize = keepStackSize(); | 6657 | int stackSize = keepStackSize(); |
5080 | 6658 | ||
5081 | try { | 6659 | try { |
5082 | // InternalProblem.g:1570:1: ( ( '}' ) ) | 6660 | // InternalProblem.g:2044:1: ( ( '}' ) ) |
5083 | // InternalProblem.g:1571:1: ( '}' ) | 6661 | // InternalProblem.g:2045:1: ( '}' ) |
5084 | { | 6662 | { |
5085 | // InternalProblem.g:1571:1: ( '}' ) | 6663 | // InternalProblem.g:2045:1: ( '}' ) |
5086 | // InternalProblem.g:1572:2: '}' | 6664 | // InternalProblem.g:2046:2: '}' |
5087 | { | 6665 | { |
5088 | before(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); | 6666 | before(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); |
5089 | match(input,28,FOLLOW_2); | 6667 | match(input,32,FOLLOW_2); |
5090 | after(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); | 6668 | after(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); |
5091 | 6669 | ||
5092 | } | 6670 | } |
@@ -5110,14 +6688,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5110 | 6688 | ||
5111 | 6689 | ||
5112 | // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__0" | 6690 | // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__0" |
5113 | // InternalProblem.g:1582:1: rule__ClassDeclaration__Group_4_0_1__0 : rule__ClassDeclaration__Group_4_0_1__0__Impl rule__ClassDeclaration__Group_4_0_1__1 ; | 6691 | // InternalProblem.g:2056:1: rule__ClassDeclaration__Group_4_0_1__0 : rule__ClassDeclaration__Group_4_0_1__0__Impl rule__ClassDeclaration__Group_4_0_1__1 ; |
5114 | public final void rule__ClassDeclaration__Group_4_0_1__0() throws RecognitionException { | 6692 | public final void rule__ClassDeclaration__Group_4_0_1__0() throws RecognitionException { |
5115 | 6693 | ||
5116 | int stackSize = keepStackSize(); | 6694 | int stackSize = keepStackSize(); |
5117 | 6695 | ||
5118 | try { | 6696 | try { |
5119 | // InternalProblem.g:1586:1: ( rule__ClassDeclaration__Group_4_0_1__0__Impl rule__ClassDeclaration__Group_4_0_1__1 ) | 6697 | // InternalProblem.g:2060:1: ( rule__ClassDeclaration__Group_4_0_1__0__Impl rule__ClassDeclaration__Group_4_0_1__1 ) |
5120 | // InternalProblem.g:1587:2: rule__ClassDeclaration__Group_4_0_1__0__Impl rule__ClassDeclaration__Group_4_0_1__1 | 6698 | // InternalProblem.g:2061:2: rule__ClassDeclaration__Group_4_0_1__0__Impl rule__ClassDeclaration__Group_4_0_1__1 |
5121 | { | 6699 | { |
5122 | pushFollow(FOLLOW_13); | 6700 | pushFollow(FOLLOW_13); |
5123 | rule__ClassDeclaration__Group_4_0_1__0__Impl(); | 6701 | rule__ClassDeclaration__Group_4_0_1__0__Impl(); |
@@ -5148,21 +6726,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5148 | 6726 | ||
5149 | 6727 | ||
5150 | // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__0__Impl" | 6728 | // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__0__Impl" |
5151 | // InternalProblem.g:1594:1: rule__ClassDeclaration__Group_4_0_1__0__Impl : ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) ; | 6729 | // InternalProblem.g:2068:1: rule__ClassDeclaration__Group_4_0_1__0__Impl : ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) ; |
5152 | public final void rule__ClassDeclaration__Group_4_0_1__0__Impl() throws RecognitionException { | 6730 | public final void rule__ClassDeclaration__Group_4_0_1__0__Impl() throws RecognitionException { |
5153 | 6731 | ||
5154 | int stackSize = keepStackSize(); | 6732 | int stackSize = keepStackSize(); |
5155 | 6733 | ||
5156 | try { | 6734 | try { |
5157 | // InternalProblem.g:1598:1: ( ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) ) | 6735 | // InternalProblem.g:2072:1: ( ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) ) |
5158 | // InternalProblem.g:1599:1: ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) | 6736 | // InternalProblem.g:2073:1: ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) |
5159 | { | 6737 | { |
5160 | // InternalProblem.g:1599:1: ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) | 6738 | // InternalProblem.g:2073:1: ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) |
5161 | // InternalProblem.g:1600:2: ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) | 6739 | // InternalProblem.g:2074:2: ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) |
5162 | { | 6740 | { |
5163 | before(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsAssignment_4_0_1_0()); | 6741 | before(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsAssignment_4_0_1_0()); |
5164 | // InternalProblem.g:1601:2: ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) | 6742 | // InternalProblem.g:2075:2: ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) |
5165 | // InternalProblem.g:1601:3: rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 | 6743 | // InternalProblem.g:2075:3: rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 |
5166 | { | 6744 | { |
5167 | pushFollow(FOLLOW_2); | 6745 | pushFollow(FOLLOW_2); |
5168 | rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0(); | 6746 | rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0(); |
@@ -5195,14 +6773,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5195 | 6773 | ||
5196 | 6774 | ||
5197 | // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__1" | 6775 | // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__1" |
5198 | // InternalProblem.g:1609:1: rule__ClassDeclaration__Group_4_0_1__1 : rule__ClassDeclaration__Group_4_0_1__1__Impl ; | 6776 | // InternalProblem.g:2083:1: rule__ClassDeclaration__Group_4_0_1__1 : rule__ClassDeclaration__Group_4_0_1__1__Impl ; |
5199 | public final void rule__ClassDeclaration__Group_4_0_1__1() throws RecognitionException { | 6777 | public final void rule__ClassDeclaration__Group_4_0_1__1() throws RecognitionException { |
5200 | 6778 | ||
5201 | int stackSize = keepStackSize(); | 6779 | int stackSize = keepStackSize(); |
5202 | 6780 | ||
5203 | try { | 6781 | try { |
5204 | // InternalProblem.g:1613:1: ( rule__ClassDeclaration__Group_4_0_1__1__Impl ) | 6782 | // InternalProblem.g:2087:1: ( rule__ClassDeclaration__Group_4_0_1__1__Impl ) |
5205 | // InternalProblem.g:1614:2: rule__ClassDeclaration__Group_4_0_1__1__Impl | 6783 | // InternalProblem.g:2088:2: rule__ClassDeclaration__Group_4_0_1__1__Impl |
5206 | { | 6784 | { |
5207 | pushFollow(FOLLOW_2); | 6785 | pushFollow(FOLLOW_2); |
5208 | rule__ClassDeclaration__Group_4_0_1__1__Impl(); | 6786 | rule__ClassDeclaration__Group_4_0_1__1__Impl(); |
@@ -5228,29 +6806,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5228 | 6806 | ||
5229 | 6807 | ||
5230 | // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__1__Impl" | 6808 | // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__1__Impl" |
5231 | // InternalProblem.g:1620:1: rule__ClassDeclaration__Group_4_0_1__1__Impl : ( ( ';' )? ) ; | 6809 | // InternalProblem.g:2094:1: rule__ClassDeclaration__Group_4_0_1__1__Impl : ( ( ';' )? ) ; |
5232 | public final void rule__ClassDeclaration__Group_4_0_1__1__Impl() throws RecognitionException { | 6810 | public final void rule__ClassDeclaration__Group_4_0_1__1__Impl() throws RecognitionException { |
5233 | 6811 | ||
5234 | int stackSize = keepStackSize(); | 6812 | int stackSize = keepStackSize(); |
5235 | 6813 | ||
5236 | try { | 6814 | try { |
5237 | // InternalProblem.g:1624:1: ( ( ( ';' )? ) ) | 6815 | // InternalProblem.g:2098:1: ( ( ( ';' )? ) ) |
5238 | // InternalProblem.g:1625:1: ( ( ';' )? ) | 6816 | // InternalProblem.g:2099:1: ( ( ';' )? ) |
5239 | { | 6817 | { |
5240 | // InternalProblem.g:1625:1: ( ( ';' )? ) | 6818 | // InternalProblem.g:2099:1: ( ( ';' )? ) |
5241 | // InternalProblem.g:1626:2: ( ';' )? | 6819 | // InternalProblem.g:2100:2: ( ';' )? |
5242 | { | 6820 | { |
5243 | before(grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); | 6821 | before(grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); |
5244 | // InternalProblem.g:1627:2: ( ';' )? | 6822 | // InternalProblem.g:2101:2: ( ';' )? |
5245 | int alt24=2; | 6823 | int alt30=2; |
5246 | int LA24_0 = input.LA(1); | 6824 | int LA30_0 = input.LA(1); |
5247 | 6825 | ||
5248 | if ( (LA24_0==14) ) { | 6826 | if ( (LA30_0==14) ) { |
5249 | alt24=1; | 6827 | alt30=1; |
5250 | } | 6828 | } |
5251 | switch (alt24) { | 6829 | switch (alt30) { |
5252 | case 1 : | 6830 | case 1 : |
5253 | // InternalProblem.g:1627:3: ';' | 6831 | // InternalProblem.g:2101:3: ';' |
5254 | { | 6832 | { |
5255 | match(input,14,FOLLOW_2); | 6833 | match(input,14,FOLLOW_2); |
5256 | 6834 | ||
@@ -5282,14 +6860,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5282 | 6860 | ||
5283 | 6861 | ||
5284 | // $ANTLR start "rule__EnumDeclaration__Group__0" | 6862 | // $ANTLR start "rule__EnumDeclaration__Group__0" |
5285 | // InternalProblem.g:1636:1: rule__EnumDeclaration__Group__0 : rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 ; | 6863 | // InternalProblem.g:2110:1: rule__EnumDeclaration__Group__0 : rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 ; |
5286 | public final void rule__EnumDeclaration__Group__0() throws RecognitionException { | 6864 | public final void rule__EnumDeclaration__Group__0() throws RecognitionException { |
5287 | 6865 | ||
5288 | int stackSize = keepStackSize(); | 6866 | int stackSize = keepStackSize(); |
5289 | 6867 | ||
5290 | try { | 6868 | try { |
5291 | // InternalProblem.g:1640:1: ( rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 ) | 6869 | // InternalProblem.g:2114:1: ( rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 ) |
5292 | // InternalProblem.g:1641:2: rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 | 6870 | // InternalProblem.g:2115:2: rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 |
5293 | { | 6871 | { |
5294 | pushFollow(FOLLOW_5); | 6872 | pushFollow(FOLLOW_5); |
5295 | rule__EnumDeclaration__Group__0__Impl(); | 6873 | rule__EnumDeclaration__Group__0__Impl(); |
@@ -5320,20 +6898,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5320 | 6898 | ||
5321 | 6899 | ||
5322 | // $ANTLR start "rule__EnumDeclaration__Group__0__Impl" | 6900 | // $ANTLR start "rule__EnumDeclaration__Group__0__Impl" |
5323 | // InternalProblem.g:1648:1: rule__EnumDeclaration__Group__0__Impl : ( 'enum' ) ; | 6901 | // InternalProblem.g:2122:1: rule__EnumDeclaration__Group__0__Impl : ( 'enum' ) ; |
5324 | public final void rule__EnumDeclaration__Group__0__Impl() throws RecognitionException { | 6902 | public final void rule__EnumDeclaration__Group__0__Impl() throws RecognitionException { |
5325 | 6903 | ||
5326 | int stackSize = keepStackSize(); | 6904 | int stackSize = keepStackSize(); |
5327 | 6905 | ||
5328 | try { | 6906 | try { |
5329 | // InternalProblem.g:1652:1: ( ( 'enum' ) ) | 6907 | // InternalProblem.g:2126:1: ( ( 'enum' ) ) |
5330 | // InternalProblem.g:1653:1: ( 'enum' ) | 6908 | // InternalProblem.g:2127:1: ( 'enum' ) |
5331 | { | 6909 | { |
5332 | // InternalProblem.g:1653:1: ( 'enum' ) | 6910 | // InternalProblem.g:2127:1: ( 'enum' ) |
5333 | // InternalProblem.g:1654:2: 'enum' | 6911 | // InternalProblem.g:2128:2: 'enum' |
5334 | { | 6912 | { |
5335 | before(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); | 6913 | before(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); |
5336 | match(input,29,FOLLOW_2); | 6914 | match(input,33,FOLLOW_2); |
5337 | after(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); | 6915 | after(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); |
5338 | 6916 | ||
5339 | } | 6917 | } |
@@ -5357,14 +6935,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5357 | 6935 | ||
5358 | 6936 | ||
5359 | // $ANTLR start "rule__EnumDeclaration__Group__1" | 6937 | // $ANTLR start "rule__EnumDeclaration__Group__1" |
5360 | // InternalProblem.g:1663:1: rule__EnumDeclaration__Group__1 : rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 ; | 6938 | // InternalProblem.g:2137:1: rule__EnumDeclaration__Group__1 : rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 ; |
5361 | public final void rule__EnumDeclaration__Group__1() throws RecognitionException { | 6939 | public final void rule__EnumDeclaration__Group__1() throws RecognitionException { |
5362 | 6940 | ||
5363 | int stackSize = keepStackSize(); | 6941 | int stackSize = keepStackSize(); |
5364 | 6942 | ||
5365 | try { | 6943 | try { |
5366 | // InternalProblem.g:1667:1: ( rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 ) | 6944 | // InternalProblem.g:2141:1: ( rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 ) |
5367 | // InternalProblem.g:1668:2: rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 | 6945 | // InternalProblem.g:2142:2: rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 |
5368 | { | 6946 | { |
5369 | pushFollow(FOLLOW_14); | 6947 | pushFollow(FOLLOW_14); |
5370 | rule__EnumDeclaration__Group__1__Impl(); | 6948 | rule__EnumDeclaration__Group__1__Impl(); |
@@ -5395,21 +6973,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5395 | 6973 | ||
5396 | 6974 | ||
5397 | // $ANTLR start "rule__EnumDeclaration__Group__1__Impl" | 6975 | // $ANTLR start "rule__EnumDeclaration__Group__1__Impl" |
5398 | // InternalProblem.g:1675:1: rule__EnumDeclaration__Group__1__Impl : ( ( rule__EnumDeclaration__NameAssignment_1 ) ) ; | 6976 | // InternalProblem.g:2149:1: rule__EnumDeclaration__Group__1__Impl : ( ( rule__EnumDeclaration__NameAssignment_1 ) ) ; |
5399 | public final void rule__EnumDeclaration__Group__1__Impl() throws RecognitionException { | 6977 | public final void rule__EnumDeclaration__Group__1__Impl() throws RecognitionException { |
5400 | 6978 | ||
5401 | int stackSize = keepStackSize(); | 6979 | int stackSize = keepStackSize(); |
5402 | 6980 | ||
5403 | try { | 6981 | try { |
5404 | // InternalProblem.g:1679:1: ( ( ( rule__EnumDeclaration__NameAssignment_1 ) ) ) | 6982 | // InternalProblem.g:2153:1: ( ( ( rule__EnumDeclaration__NameAssignment_1 ) ) ) |
5405 | // InternalProblem.g:1680:1: ( ( rule__EnumDeclaration__NameAssignment_1 ) ) | 6983 | // InternalProblem.g:2154:1: ( ( rule__EnumDeclaration__NameAssignment_1 ) ) |
5406 | { | 6984 | { |
5407 | // InternalProblem.g:1680:1: ( ( rule__EnumDeclaration__NameAssignment_1 ) ) | 6985 | // InternalProblem.g:2154:1: ( ( rule__EnumDeclaration__NameAssignment_1 ) ) |
5408 | // InternalProblem.g:1681:2: ( rule__EnumDeclaration__NameAssignment_1 ) | 6986 | // InternalProblem.g:2155:2: ( rule__EnumDeclaration__NameAssignment_1 ) |
5409 | { | 6987 | { |
5410 | before(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); | 6988 | before(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); |
5411 | // InternalProblem.g:1682:2: ( rule__EnumDeclaration__NameAssignment_1 ) | 6989 | // InternalProblem.g:2156:2: ( rule__EnumDeclaration__NameAssignment_1 ) |
5412 | // InternalProblem.g:1682:3: rule__EnumDeclaration__NameAssignment_1 | 6990 | // InternalProblem.g:2156:3: rule__EnumDeclaration__NameAssignment_1 |
5413 | { | 6991 | { |
5414 | pushFollow(FOLLOW_2); | 6992 | pushFollow(FOLLOW_2); |
5415 | rule__EnumDeclaration__NameAssignment_1(); | 6993 | rule__EnumDeclaration__NameAssignment_1(); |
@@ -5442,14 +7020,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5442 | 7020 | ||
5443 | 7021 | ||
5444 | // $ANTLR start "rule__EnumDeclaration__Group__2" | 7022 | // $ANTLR start "rule__EnumDeclaration__Group__2" |
5445 | // InternalProblem.g:1690:1: rule__EnumDeclaration__Group__2 : rule__EnumDeclaration__Group__2__Impl ; | 7023 | // InternalProblem.g:2164:1: rule__EnumDeclaration__Group__2 : rule__EnumDeclaration__Group__2__Impl ; |
5446 | public final void rule__EnumDeclaration__Group__2() throws RecognitionException { | 7024 | public final void rule__EnumDeclaration__Group__2() throws RecognitionException { |
5447 | 7025 | ||
5448 | int stackSize = keepStackSize(); | 7026 | int stackSize = keepStackSize(); |
5449 | 7027 | ||
5450 | try { | 7028 | try { |
5451 | // InternalProblem.g:1694:1: ( rule__EnumDeclaration__Group__2__Impl ) | 7029 | // InternalProblem.g:2168:1: ( rule__EnumDeclaration__Group__2__Impl ) |
5452 | // InternalProblem.g:1695:2: rule__EnumDeclaration__Group__2__Impl | 7030 | // InternalProblem.g:2169:2: rule__EnumDeclaration__Group__2__Impl |
5453 | { | 7031 | { |
5454 | pushFollow(FOLLOW_2); | 7032 | pushFollow(FOLLOW_2); |
5455 | rule__EnumDeclaration__Group__2__Impl(); | 7033 | rule__EnumDeclaration__Group__2__Impl(); |
@@ -5475,21 +7053,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5475 | 7053 | ||
5476 | 7054 | ||
5477 | // $ANTLR start "rule__EnumDeclaration__Group__2__Impl" | 7055 | // $ANTLR start "rule__EnumDeclaration__Group__2__Impl" |
5478 | // InternalProblem.g:1701:1: rule__EnumDeclaration__Group__2__Impl : ( ( rule__EnumDeclaration__Alternatives_2 ) ) ; | 7056 | // InternalProblem.g:2175:1: rule__EnumDeclaration__Group__2__Impl : ( ( rule__EnumDeclaration__Alternatives_2 ) ) ; |
5479 | public final void rule__EnumDeclaration__Group__2__Impl() throws RecognitionException { | 7057 | public final void rule__EnumDeclaration__Group__2__Impl() throws RecognitionException { |
5480 | 7058 | ||
5481 | int stackSize = keepStackSize(); | 7059 | int stackSize = keepStackSize(); |
5482 | 7060 | ||
5483 | try { | 7061 | try { |
5484 | // InternalProblem.g:1705:1: ( ( ( rule__EnumDeclaration__Alternatives_2 ) ) ) | 7062 | // InternalProblem.g:2179:1: ( ( ( rule__EnumDeclaration__Alternatives_2 ) ) ) |
5485 | // InternalProblem.g:1706:1: ( ( rule__EnumDeclaration__Alternatives_2 ) ) | 7063 | // InternalProblem.g:2180:1: ( ( rule__EnumDeclaration__Alternatives_2 ) ) |
5486 | { | 7064 | { |
5487 | // InternalProblem.g:1706:1: ( ( rule__EnumDeclaration__Alternatives_2 ) ) | 7065 | // InternalProblem.g:2180:1: ( ( rule__EnumDeclaration__Alternatives_2 ) ) |
5488 | // InternalProblem.g:1707:2: ( rule__EnumDeclaration__Alternatives_2 ) | 7066 | // InternalProblem.g:2181:2: ( rule__EnumDeclaration__Alternatives_2 ) |
5489 | { | 7067 | { |
5490 | before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); | 7068 | before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); |
5491 | // InternalProblem.g:1708:2: ( rule__EnumDeclaration__Alternatives_2 ) | 7069 | // InternalProblem.g:2182:2: ( rule__EnumDeclaration__Alternatives_2 ) |
5492 | // InternalProblem.g:1708:3: rule__EnumDeclaration__Alternatives_2 | 7070 | // InternalProblem.g:2182:3: rule__EnumDeclaration__Alternatives_2 |
5493 | { | 7071 | { |
5494 | pushFollow(FOLLOW_2); | 7072 | pushFollow(FOLLOW_2); |
5495 | rule__EnumDeclaration__Alternatives_2(); | 7073 | rule__EnumDeclaration__Alternatives_2(); |
@@ -5522,14 +7100,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5522 | 7100 | ||
5523 | 7101 | ||
5524 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__0" | 7102 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__0" |
5525 | // InternalProblem.g:1717:1: rule__EnumDeclaration__Group_2_0__0 : rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 ; | 7103 | // InternalProblem.g:2191:1: rule__EnumDeclaration__Group_2_0__0 : rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 ; |
5526 | public final void rule__EnumDeclaration__Group_2_0__0() throws RecognitionException { | 7104 | public final void rule__EnumDeclaration__Group_2_0__0() throws RecognitionException { |
5527 | 7105 | ||
5528 | int stackSize = keepStackSize(); | 7106 | int stackSize = keepStackSize(); |
5529 | 7107 | ||
5530 | try { | 7108 | try { |
5531 | // InternalProblem.g:1721:1: ( rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 ) | 7109 | // InternalProblem.g:2195:1: ( rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 ) |
5532 | // InternalProblem.g:1722:2: rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 | 7110 | // InternalProblem.g:2196:2: rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 |
5533 | { | 7111 | { |
5534 | pushFollow(FOLLOW_15); | 7112 | pushFollow(FOLLOW_15); |
5535 | rule__EnumDeclaration__Group_2_0__0__Impl(); | 7113 | rule__EnumDeclaration__Group_2_0__0__Impl(); |
@@ -5560,20 +7138,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5560 | 7138 | ||
5561 | 7139 | ||
5562 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__0__Impl" | 7140 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__0__Impl" |
5563 | // InternalProblem.g:1729:1: rule__EnumDeclaration__Group_2_0__0__Impl : ( '{' ) ; | 7141 | // InternalProblem.g:2203:1: rule__EnumDeclaration__Group_2_0__0__Impl : ( '{' ) ; |
5564 | public final void rule__EnumDeclaration__Group_2_0__0__Impl() throws RecognitionException { | 7142 | public final void rule__EnumDeclaration__Group_2_0__0__Impl() throws RecognitionException { |
5565 | 7143 | ||
5566 | int stackSize = keepStackSize(); | 7144 | int stackSize = keepStackSize(); |
5567 | 7145 | ||
5568 | try { | 7146 | try { |
5569 | // InternalProblem.g:1733:1: ( ( '{' ) ) | 7147 | // InternalProblem.g:2207:1: ( ( '{' ) ) |
5570 | // InternalProblem.g:1734:1: ( '{' ) | 7148 | // InternalProblem.g:2208:1: ( '{' ) |
5571 | { | 7149 | { |
5572 | // InternalProblem.g:1734:1: ( '{' ) | 7150 | // InternalProblem.g:2208:1: ( '{' ) |
5573 | // InternalProblem.g:1735:2: '{' | 7151 | // InternalProblem.g:2209:2: '{' |
5574 | { | 7152 | { |
5575 | before(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); | 7153 | before(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); |
5576 | match(input,27,FOLLOW_2); | 7154 | match(input,31,FOLLOW_2); |
5577 | after(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); | 7155 | after(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); |
5578 | 7156 | ||
5579 | } | 7157 | } |
@@ -5597,14 +7175,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5597 | 7175 | ||
5598 | 7176 | ||
5599 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__1" | 7177 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__1" |
5600 | // InternalProblem.g:1744:1: rule__EnumDeclaration__Group_2_0__1 : rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 ; | 7178 | // InternalProblem.g:2218:1: rule__EnumDeclaration__Group_2_0__1 : rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 ; |
5601 | public final void rule__EnumDeclaration__Group_2_0__1() throws RecognitionException { | 7179 | public final void rule__EnumDeclaration__Group_2_0__1() throws RecognitionException { |
5602 | 7180 | ||
5603 | int stackSize = keepStackSize(); | 7181 | int stackSize = keepStackSize(); |
5604 | 7182 | ||
5605 | try { | 7183 | try { |
5606 | // InternalProblem.g:1748:1: ( rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 ) | 7184 | // InternalProblem.g:2222:1: ( rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 ) |
5607 | // InternalProblem.g:1749:2: rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 | 7185 | // InternalProblem.g:2223:2: rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 |
5608 | { | 7186 | { |
5609 | pushFollow(FOLLOW_15); | 7187 | pushFollow(FOLLOW_15); |
5610 | rule__EnumDeclaration__Group_2_0__1__Impl(); | 7188 | rule__EnumDeclaration__Group_2_0__1__Impl(); |
@@ -5635,29 +7213,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5635 | 7213 | ||
5636 | 7214 | ||
5637 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__1__Impl" | 7215 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__1__Impl" |
5638 | // InternalProblem.g:1756:1: rule__EnumDeclaration__Group_2_0__1__Impl : ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) ; | 7216 | // InternalProblem.g:2230:1: rule__EnumDeclaration__Group_2_0__1__Impl : ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) ; |
5639 | public final void rule__EnumDeclaration__Group_2_0__1__Impl() throws RecognitionException { | 7217 | public final void rule__EnumDeclaration__Group_2_0__1__Impl() throws RecognitionException { |
5640 | 7218 | ||
5641 | int stackSize = keepStackSize(); | 7219 | int stackSize = keepStackSize(); |
5642 | 7220 | ||
5643 | try { | 7221 | try { |
5644 | // InternalProblem.g:1760:1: ( ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) ) | 7222 | // InternalProblem.g:2234:1: ( ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) ) |
5645 | // InternalProblem.g:1761:1: ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) | 7223 | // InternalProblem.g:2235:1: ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) |
5646 | { | 7224 | { |
5647 | // InternalProblem.g:1761:1: ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) | 7225 | // InternalProblem.g:2235:1: ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) |
5648 | // InternalProblem.g:1762:2: ( rule__EnumDeclaration__Group_2_0_1__0 )? | 7226 | // InternalProblem.g:2236:2: ( rule__EnumDeclaration__Group_2_0_1__0 )? |
5649 | { | 7227 | { |
5650 | before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); | 7228 | before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); |
5651 | // InternalProblem.g:1763:2: ( rule__EnumDeclaration__Group_2_0_1__0 )? | 7229 | // InternalProblem.g:2237:2: ( rule__EnumDeclaration__Group_2_0_1__0 )? |
5652 | int alt25=2; | 7230 | int alt31=2; |
5653 | int LA25_0 = input.LA(1); | 7231 | int LA31_0 = input.LA(1); |
5654 | 7232 | ||
5655 | if ( ((LA25_0>=RULE_QUOTED_ID && LA25_0<=RULE_ID)||(LA25_0>=19 && LA25_0<=20)) ) { | 7233 | if ( ((LA31_0>=RULE_QUOTED_ID && LA31_0<=RULE_ID)||(LA31_0>=19 && LA31_0<=22)) ) { |
5656 | alt25=1; | 7234 | alt31=1; |
5657 | } | 7235 | } |
5658 | switch (alt25) { | 7236 | switch (alt31) { |
5659 | case 1 : | 7237 | case 1 : |
5660 | // InternalProblem.g:1763:3: rule__EnumDeclaration__Group_2_0_1__0 | 7238 | // InternalProblem.g:2237:3: rule__EnumDeclaration__Group_2_0_1__0 |
5661 | { | 7239 | { |
5662 | pushFollow(FOLLOW_2); | 7240 | pushFollow(FOLLOW_2); |
5663 | rule__EnumDeclaration__Group_2_0_1__0(); | 7241 | rule__EnumDeclaration__Group_2_0_1__0(); |
@@ -5693,14 +7271,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5693 | 7271 | ||
5694 | 7272 | ||
5695 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__2" | 7273 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__2" |
5696 | // InternalProblem.g:1771:1: rule__EnumDeclaration__Group_2_0__2 : rule__EnumDeclaration__Group_2_0__2__Impl ; | 7274 | // InternalProblem.g:2245:1: rule__EnumDeclaration__Group_2_0__2 : rule__EnumDeclaration__Group_2_0__2__Impl ; |
5697 | public final void rule__EnumDeclaration__Group_2_0__2() throws RecognitionException { | 7275 | public final void rule__EnumDeclaration__Group_2_0__2() throws RecognitionException { |
5698 | 7276 | ||
5699 | int stackSize = keepStackSize(); | 7277 | int stackSize = keepStackSize(); |
5700 | 7278 | ||
5701 | try { | 7279 | try { |
5702 | // InternalProblem.g:1775:1: ( rule__EnumDeclaration__Group_2_0__2__Impl ) | 7280 | // InternalProblem.g:2249:1: ( rule__EnumDeclaration__Group_2_0__2__Impl ) |
5703 | // InternalProblem.g:1776:2: rule__EnumDeclaration__Group_2_0__2__Impl | 7281 | // InternalProblem.g:2250:2: rule__EnumDeclaration__Group_2_0__2__Impl |
5704 | { | 7282 | { |
5705 | pushFollow(FOLLOW_2); | 7283 | pushFollow(FOLLOW_2); |
5706 | rule__EnumDeclaration__Group_2_0__2__Impl(); | 7284 | rule__EnumDeclaration__Group_2_0__2__Impl(); |
@@ -5726,20 +7304,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5726 | 7304 | ||
5727 | 7305 | ||
5728 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__2__Impl" | 7306 | // $ANTLR start "rule__EnumDeclaration__Group_2_0__2__Impl" |
5729 | // InternalProblem.g:1782:1: rule__EnumDeclaration__Group_2_0__2__Impl : ( '}' ) ; | 7307 | // InternalProblem.g:2256:1: rule__EnumDeclaration__Group_2_0__2__Impl : ( '}' ) ; |
5730 | public final void rule__EnumDeclaration__Group_2_0__2__Impl() throws RecognitionException { | 7308 | public final void rule__EnumDeclaration__Group_2_0__2__Impl() throws RecognitionException { |
5731 | 7309 | ||
5732 | int stackSize = keepStackSize(); | 7310 | int stackSize = keepStackSize(); |
5733 | 7311 | ||
5734 | try { | 7312 | try { |
5735 | // InternalProblem.g:1786:1: ( ( '}' ) ) | 7313 | // InternalProblem.g:2260:1: ( ( '}' ) ) |
5736 | // InternalProblem.g:1787:1: ( '}' ) | 7314 | // InternalProblem.g:2261:1: ( '}' ) |
5737 | { | 7315 | { |
5738 | // InternalProblem.g:1787:1: ( '}' ) | 7316 | // InternalProblem.g:2261:1: ( '}' ) |
5739 | // InternalProblem.g:1788:2: '}' | 7317 | // InternalProblem.g:2262:2: '}' |
5740 | { | 7318 | { |
5741 | before(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); | 7319 | before(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); |
5742 | match(input,28,FOLLOW_2); | 7320 | match(input,32,FOLLOW_2); |
5743 | after(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); | 7321 | after(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); |
5744 | 7322 | ||
5745 | } | 7323 | } |
@@ -5763,14 +7341,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5763 | 7341 | ||
5764 | 7342 | ||
5765 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__0" | 7343 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__0" |
5766 | // InternalProblem.g:1798:1: rule__EnumDeclaration__Group_2_0_1__0 : rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 ; | 7344 | // InternalProblem.g:2272:1: rule__EnumDeclaration__Group_2_0_1__0 : rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 ; |
5767 | public final void rule__EnumDeclaration__Group_2_0_1__0() throws RecognitionException { | 7345 | public final void rule__EnumDeclaration__Group_2_0_1__0() throws RecognitionException { |
5768 | 7346 | ||
5769 | int stackSize = keepStackSize(); | 7347 | int stackSize = keepStackSize(); |
5770 | 7348 | ||
5771 | try { | 7349 | try { |
5772 | // InternalProblem.g:1802:1: ( rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 ) | 7350 | // InternalProblem.g:2276:1: ( rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 ) |
5773 | // InternalProblem.g:1803:2: rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 | 7351 | // InternalProblem.g:2277:2: rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 |
5774 | { | 7352 | { |
5775 | pushFollow(FOLLOW_16); | 7353 | pushFollow(FOLLOW_16); |
5776 | rule__EnumDeclaration__Group_2_0_1__0__Impl(); | 7354 | rule__EnumDeclaration__Group_2_0_1__0__Impl(); |
@@ -5801,21 +7379,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5801 | 7379 | ||
5802 | 7380 | ||
5803 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__0__Impl" | 7381 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__0__Impl" |
5804 | // InternalProblem.g:1810:1: rule__EnumDeclaration__Group_2_0_1__0__Impl : ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) ; | 7382 | // InternalProblem.g:2284:1: rule__EnumDeclaration__Group_2_0_1__0__Impl : ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) ; |
5805 | public final void rule__EnumDeclaration__Group_2_0_1__0__Impl() throws RecognitionException { | 7383 | public final void rule__EnumDeclaration__Group_2_0_1__0__Impl() throws RecognitionException { |
5806 | 7384 | ||
5807 | int stackSize = keepStackSize(); | 7385 | int stackSize = keepStackSize(); |
5808 | 7386 | ||
5809 | try { | 7387 | try { |
5810 | // InternalProblem.g:1814:1: ( ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) ) | 7388 | // InternalProblem.g:2288:1: ( ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) ) |
5811 | // InternalProblem.g:1815:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) | 7389 | // InternalProblem.g:2289:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) |
5812 | { | 7390 | { |
5813 | // InternalProblem.g:1815:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) | 7391 | // InternalProblem.g:2289:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) |
5814 | // InternalProblem.g:1816:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) | 7392 | // InternalProblem.g:2290:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) |
5815 | { | 7393 | { |
5816 | before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); | 7394 | before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); |
5817 | // InternalProblem.g:1817:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) | 7395 | // InternalProblem.g:2291:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) |
5818 | // InternalProblem.g:1817:3: rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 | 7396 | // InternalProblem.g:2291:3: rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 |
5819 | { | 7397 | { |
5820 | pushFollow(FOLLOW_2); | 7398 | pushFollow(FOLLOW_2); |
5821 | rule__EnumDeclaration__LiteralsAssignment_2_0_1_0(); | 7399 | rule__EnumDeclaration__LiteralsAssignment_2_0_1_0(); |
@@ -5848,14 +7426,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5848 | 7426 | ||
5849 | 7427 | ||
5850 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__1" | 7428 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__1" |
5851 | // InternalProblem.g:1825:1: rule__EnumDeclaration__Group_2_0_1__1 : rule__EnumDeclaration__Group_2_0_1__1__Impl rule__EnumDeclaration__Group_2_0_1__2 ; | 7429 | // InternalProblem.g:2299:1: rule__EnumDeclaration__Group_2_0_1__1 : rule__EnumDeclaration__Group_2_0_1__1__Impl rule__EnumDeclaration__Group_2_0_1__2 ; |
5852 | public final void rule__EnumDeclaration__Group_2_0_1__1() throws RecognitionException { | 7430 | public final void rule__EnumDeclaration__Group_2_0_1__1() throws RecognitionException { |
5853 | 7431 | ||
5854 | int stackSize = keepStackSize(); | 7432 | int stackSize = keepStackSize(); |
5855 | 7433 | ||
5856 | try { | 7434 | try { |
5857 | // InternalProblem.g:1829:1: ( rule__EnumDeclaration__Group_2_0_1__1__Impl rule__EnumDeclaration__Group_2_0_1__2 ) | 7435 | // InternalProblem.g:2303:1: ( rule__EnumDeclaration__Group_2_0_1__1__Impl rule__EnumDeclaration__Group_2_0_1__2 ) |
5858 | // InternalProblem.g:1830:2: rule__EnumDeclaration__Group_2_0_1__1__Impl rule__EnumDeclaration__Group_2_0_1__2 | 7436 | // InternalProblem.g:2304:2: rule__EnumDeclaration__Group_2_0_1__1__Impl rule__EnumDeclaration__Group_2_0_1__2 |
5859 | { | 7437 | { |
5860 | pushFollow(FOLLOW_16); | 7438 | pushFollow(FOLLOW_16); |
5861 | rule__EnumDeclaration__Group_2_0_1__1__Impl(); | 7439 | rule__EnumDeclaration__Group_2_0_1__1__Impl(); |
@@ -5886,39 +7464,39 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5886 | 7464 | ||
5887 | 7465 | ||
5888 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__1__Impl" | 7466 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__1__Impl" |
5889 | // InternalProblem.g:1837:1: rule__EnumDeclaration__Group_2_0_1__1__Impl : ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) ; | 7467 | // InternalProblem.g:2311:1: rule__EnumDeclaration__Group_2_0_1__1__Impl : ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) ; |
5890 | public final void rule__EnumDeclaration__Group_2_0_1__1__Impl() throws RecognitionException { | 7468 | public final void rule__EnumDeclaration__Group_2_0_1__1__Impl() throws RecognitionException { |
5891 | 7469 | ||
5892 | int stackSize = keepStackSize(); | 7470 | int stackSize = keepStackSize(); |
5893 | 7471 | ||
5894 | try { | 7472 | try { |
5895 | // InternalProblem.g:1841:1: ( ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) ) | 7473 | // InternalProblem.g:2315:1: ( ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) ) |
5896 | // InternalProblem.g:1842:1: ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) | 7474 | // InternalProblem.g:2316:1: ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) |
5897 | { | 7475 | { |
5898 | // InternalProblem.g:1842:1: ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) | 7476 | // InternalProblem.g:2316:1: ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) |
5899 | // InternalProblem.g:1843:2: ( rule__EnumDeclaration__Group_2_0_1_1__0 )* | 7477 | // InternalProblem.g:2317:2: ( rule__EnumDeclaration__Group_2_0_1_1__0 )* |
5900 | { | 7478 | { |
5901 | before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); | 7479 | before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); |
5902 | // InternalProblem.g:1844:2: ( rule__EnumDeclaration__Group_2_0_1_1__0 )* | 7480 | // InternalProblem.g:2318:2: ( rule__EnumDeclaration__Group_2_0_1_1__0 )* |
5903 | loop26: | 7481 | loop32: |
5904 | do { | 7482 | do { |
5905 | int alt26=2; | 7483 | int alt32=2; |
5906 | int LA26_0 = input.LA(1); | 7484 | int LA32_0 = input.LA(1); |
5907 | 7485 | ||
5908 | if ( (LA26_0==13) ) { | 7486 | if ( (LA32_0==13) ) { |
5909 | int LA26_1 = input.LA(2); | 7487 | int LA32_1 = input.LA(2); |
5910 | 7488 | ||
5911 | if ( ((LA26_1>=RULE_QUOTED_ID && LA26_1<=RULE_ID)||(LA26_1>=19 && LA26_1<=20)) ) { | 7489 | if ( ((LA32_1>=RULE_QUOTED_ID && LA32_1<=RULE_ID)||(LA32_1>=19 && LA32_1<=22)) ) { |
5912 | alt26=1; | 7490 | alt32=1; |
5913 | } | 7491 | } |
5914 | 7492 | ||
5915 | 7493 | ||
5916 | } | 7494 | } |
5917 | 7495 | ||
5918 | 7496 | ||
5919 | switch (alt26) { | 7497 | switch (alt32) { |
5920 | case 1 : | 7498 | case 1 : |
5921 | // InternalProblem.g:1844:3: rule__EnumDeclaration__Group_2_0_1_1__0 | 7499 | // InternalProblem.g:2318:3: rule__EnumDeclaration__Group_2_0_1_1__0 |
5922 | { | 7500 | { |
5923 | pushFollow(FOLLOW_10); | 7501 | pushFollow(FOLLOW_10); |
5924 | rule__EnumDeclaration__Group_2_0_1_1__0(); | 7502 | rule__EnumDeclaration__Group_2_0_1_1__0(); |
@@ -5930,7 +7508,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5930 | break; | 7508 | break; |
5931 | 7509 | ||
5932 | default : | 7510 | default : |
5933 | break loop26; | 7511 | break loop32; |
5934 | } | 7512 | } |
5935 | } while (true); | 7513 | } while (true); |
5936 | 7514 | ||
@@ -5957,14 +7535,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5957 | 7535 | ||
5958 | 7536 | ||
5959 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__2" | 7537 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__2" |
5960 | // InternalProblem.g:1852:1: rule__EnumDeclaration__Group_2_0_1__2 : rule__EnumDeclaration__Group_2_0_1__2__Impl ; | 7538 | // InternalProblem.g:2326:1: rule__EnumDeclaration__Group_2_0_1__2 : rule__EnumDeclaration__Group_2_0_1__2__Impl ; |
5961 | public final void rule__EnumDeclaration__Group_2_0_1__2() throws RecognitionException { | 7539 | public final void rule__EnumDeclaration__Group_2_0_1__2() throws RecognitionException { |
5962 | 7540 | ||
5963 | int stackSize = keepStackSize(); | 7541 | int stackSize = keepStackSize(); |
5964 | 7542 | ||
5965 | try { | 7543 | try { |
5966 | // InternalProblem.g:1856:1: ( rule__EnumDeclaration__Group_2_0_1__2__Impl ) | 7544 | // InternalProblem.g:2330:1: ( rule__EnumDeclaration__Group_2_0_1__2__Impl ) |
5967 | // InternalProblem.g:1857:2: rule__EnumDeclaration__Group_2_0_1__2__Impl | 7545 | // InternalProblem.g:2331:2: rule__EnumDeclaration__Group_2_0_1__2__Impl |
5968 | { | 7546 | { |
5969 | pushFollow(FOLLOW_2); | 7547 | pushFollow(FOLLOW_2); |
5970 | rule__EnumDeclaration__Group_2_0_1__2__Impl(); | 7548 | rule__EnumDeclaration__Group_2_0_1__2__Impl(); |
@@ -5990,29 +7568,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
5990 | 7568 | ||
5991 | 7569 | ||
5992 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__2__Impl" | 7570 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__2__Impl" |
5993 | // InternalProblem.g:1863:1: rule__EnumDeclaration__Group_2_0_1__2__Impl : ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) ; | 7571 | // InternalProblem.g:2337:1: rule__EnumDeclaration__Group_2_0_1__2__Impl : ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) ; |
5994 | public final void rule__EnumDeclaration__Group_2_0_1__2__Impl() throws RecognitionException { | 7572 | public final void rule__EnumDeclaration__Group_2_0_1__2__Impl() throws RecognitionException { |
5995 | 7573 | ||
5996 | int stackSize = keepStackSize(); | 7574 | int stackSize = keepStackSize(); |
5997 | 7575 | ||
5998 | try { | 7576 | try { |
5999 | // InternalProblem.g:1867:1: ( ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) ) | 7577 | // InternalProblem.g:2341:1: ( ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) ) |
6000 | // InternalProblem.g:1868:1: ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) | 7578 | // InternalProblem.g:2342:1: ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) |
6001 | { | 7579 | { |
6002 | // InternalProblem.g:1868:1: ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) | 7580 | // InternalProblem.g:2342:1: ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) |
6003 | // InternalProblem.g:1869:2: ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? | 7581 | // InternalProblem.g:2343:2: ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? |
6004 | { | 7582 | { |
6005 | before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2_0_1_2()); | 7583 | before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2_0_1_2()); |
6006 | // InternalProblem.g:1870:2: ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? | 7584 | // InternalProblem.g:2344:2: ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? |
6007 | int alt27=2; | 7585 | int alt33=2; |
6008 | int LA27_0 = input.LA(1); | 7586 | int LA33_0 = input.LA(1); |
6009 | 7587 | ||
6010 | if ( ((LA27_0>=13 && LA27_0<=14)) ) { | 7588 | if ( ((LA33_0>=13 && LA33_0<=14)) ) { |
6011 | alt27=1; | 7589 | alt33=1; |
6012 | } | 7590 | } |
6013 | switch (alt27) { | 7591 | switch (alt33) { |
6014 | case 1 : | 7592 | case 1 : |
6015 | // InternalProblem.g:1870:3: rule__EnumDeclaration__Alternatives_2_0_1_2 | 7593 | // InternalProblem.g:2344:3: rule__EnumDeclaration__Alternatives_2_0_1_2 |
6016 | { | 7594 | { |
6017 | pushFollow(FOLLOW_2); | 7595 | pushFollow(FOLLOW_2); |
6018 | rule__EnumDeclaration__Alternatives_2_0_1_2(); | 7596 | rule__EnumDeclaration__Alternatives_2_0_1_2(); |
@@ -6048,14 +7626,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6048 | 7626 | ||
6049 | 7627 | ||
6050 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__0" | 7628 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__0" |
6051 | // InternalProblem.g:1879:1: rule__EnumDeclaration__Group_2_0_1_1__0 : rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 ; | 7629 | // InternalProblem.g:2353:1: rule__EnumDeclaration__Group_2_0_1_1__0 : rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 ; |
6052 | public final void rule__EnumDeclaration__Group_2_0_1_1__0() throws RecognitionException { | 7630 | public final void rule__EnumDeclaration__Group_2_0_1_1__0() throws RecognitionException { |
6053 | 7631 | ||
6054 | int stackSize = keepStackSize(); | 7632 | int stackSize = keepStackSize(); |
6055 | 7633 | ||
6056 | try { | 7634 | try { |
6057 | // InternalProblem.g:1883:1: ( rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 ) | 7635 | // InternalProblem.g:2357:1: ( rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 ) |
6058 | // InternalProblem.g:1884:2: rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 | 7636 | // InternalProblem.g:2358:2: rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 |
6059 | { | 7637 | { |
6060 | pushFollow(FOLLOW_5); | 7638 | pushFollow(FOLLOW_5); |
6061 | rule__EnumDeclaration__Group_2_0_1_1__0__Impl(); | 7639 | rule__EnumDeclaration__Group_2_0_1_1__0__Impl(); |
@@ -6086,17 +7664,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6086 | 7664 | ||
6087 | 7665 | ||
6088 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__0__Impl" | 7666 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__0__Impl" |
6089 | // InternalProblem.g:1891:1: rule__EnumDeclaration__Group_2_0_1_1__0__Impl : ( ',' ) ; | 7667 | // InternalProblem.g:2365:1: rule__EnumDeclaration__Group_2_0_1_1__0__Impl : ( ',' ) ; |
6090 | public final void rule__EnumDeclaration__Group_2_0_1_1__0__Impl() throws RecognitionException { | 7668 | public final void rule__EnumDeclaration__Group_2_0_1_1__0__Impl() throws RecognitionException { |
6091 | 7669 | ||
6092 | int stackSize = keepStackSize(); | 7670 | int stackSize = keepStackSize(); |
6093 | 7671 | ||
6094 | try { | 7672 | try { |
6095 | // InternalProblem.g:1895:1: ( ( ',' ) ) | 7673 | // InternalProblem.g:2369:1: ( ( ',' ) ) |
6096 | // InternalProblem.g:1896:1: ( ',' ) | 7674 | // InternalProblem.g:2370:1: ( ',' ) |
6097 | { | 7675 | { |
6098 | // InternalProblem.g:1896:1: ( ',' ) | 7676 | // InternalProblem.g:2370:1: ( ',' ) |
6099 | // InternalProblem.g:1897:2: ',' | 7677 | // InternalProblem.g:2371:2: ',' |
6100 | { | 7678 | { |
6101 | before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); | 7679 | before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); |
6102 | match(input,13,FOLLOW_2); | 7680 | match(input,13,FOLLOW_2); |
@@ -6123,14 +7701,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6123 | 7701 | ||
6124 | 7702 | ||
6125 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__1" | 7703 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__1" |
6126 | // InternalProblem.g:1906:1: rule__EnumDeclaration__Group_2_0_1_1__1 : rule__EnumDeclaration__Group_2_0_1_1__1__Impl ; | 7704 | // InternalProblem.g:2380:1: rule__EnumDeclaration__Group_2_0_1_1__1 : rule__EnumDeclaration__Group_2_0_1_1__1__Impl ; |
6127 | public final void rule__EnumDeclaration__Group_2_0_1_1__1() throws RecognitionException { | 7705 | public final void rule__EnumDeclaration__Group_2_0_1_1__1() throws RecognitionException { |
6128 | 7706 | ||
6129 | int stackSize = keepStackSize(); | 7707 | int stackSize = keepStackSize(); |
6130 | 7708 | ||
6131 | try { | 7709 | try { |
6132 | // InternalProblem.g:1910:1: ( rule__EnumDeclaration__Group_2_0_1_1__1__Impl ) | 7710 | // InternalProblem.g:2384:1: ( rule__EnumDeclaration__Group_2_0_1_1__1__Impl ) |
6133 | // InternalProblem.g:1911:2: rule__EnumDeclaration__Group_2_0_1_1__1__Impl | 7711 | // InternalProblem.g:2385:2: rule__EnumDeclaration__Group_2_0_1_1__1__Impl |
6134 | { | 7712 | { |
6135 | pushFollow(FOLLOW_2); | 7713 | pushFollow(FOLLOW_2); |
6136 | rule__EnumDeclaration__Group_2_0_1_1__1__Impl(); | 7714 | rule__EnumDeclaration__Group_2_0_1_1__1__Impl(); |
@@ -6156,21 +7734,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6156 | 7734 | ||
6157 | 7735 | ||
6158 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__1__Impl" | 7736 | // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__1__Impl" |
6159 | // InternalProblem.g:1917:1: rule__EnumDeclaration__Group_2_0_1_1__1__Impl : ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) ; | 7737 | // InternalProblem.g:2391:1: rule__EnumDeclaration__Group_2_0_1_1__1__Impl : ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) ; |
6160 | public final void rule__EnumDeclaration__Group_2_0_1_1__1__Impl() throws RecognitionException { | 7738 | public final void rule__EnumDeclaration__Group_2_0_1_1__1__Impl() throws RecognitionException { |
6161 | 7739 | ||
6162 | int stackSize = keepStackSize(); | 7740 | int stackSize = keepStackSize(); |
6163 | 7741 | ||
6164 | try { | 7742 | try { |
6165 | // InternalProblem.g:1921:1: ( ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) ) | 7743 | // InternalProblem.g:2395:1: ( ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) ) |
6166 | // InternalProblem.g:1922:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) | 7744 | // InternalProblem.g:2396:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) |
6167 | { | 7745 | { |
6168 | // InternalProblem.g:1922:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) | 7746 | // InternalProblem.g:2396:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) |
6169 | // InternalProblem.g:1923:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) | 7747 | // InternalProblem.g:2397:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) |
6170 | { | 7748 | { |
6171 | before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); | 7749 | before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); |
6172 | // InternalProblem.g:1924:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) | 7750 | // InternalProblem.g:2398:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) |
6173 | // InternalProblem.g:1924:3: rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 | 7751 | // InternalProblem.g:2398:3: rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 |
6174 | { | 7752 | { |
6175 | pushFollow(FOLLOW_2); | 7753 | pushFollow(FOLLOW_2); |
6176 | rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1(); | 7754 | rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1(); |
@@ -6203,14 +7781,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6203 | 7781 | ||
6204 | 7782 | ||
6205 | // $ANTLR start "rule__ReferenceDeclaration__Group__0" | 7783 | // $ANTLR start "rule__ReferenceDeclaration__Group__0" |
6206 | // InternalProblem.g:1933:1: rule__ReferenceDeclaration__Group__0 : rule__ReferenceDeclaration__Group__0__Impl rule__ReferenceDeclaration__Group__1 ; | 7784 | // InternalProblem.g:2407:1: rule__ReferenceDeclaration__Group__0 : rule__ReferenceDeclaration__Group__0__Impl rule__ReferenceDeclaration__Group__1 ; |
6207 | public final void rule__ReferenceDeclaration__Group__0() throws RecognitionException { | 7785 | public final void rule__ReferenceDeclaration__Group__0() throws RecognitionException { |
6208 | 7786 | ||
6209 | int stackSize = keepStackSize(); | 7787 | int stackSize = keepStackSize(); |
6210 | 7788 | ||
6211 | try { | 7789 | try { |
6212 | // InternalProblem.g:1937:1: ( rule__ReferenceDeclaration__Group__0__Impl rule__ReferenceDeclaration__Group__1 ) | 7790 | // InternalProblem.g:2411:1: ( rule__ReferenceDeclaration__Group__0__Impl rule__ReferenceDeclaration__Group__1 ) |
6213 | // InternalProblem.g:1938:2: rule__ReferenceDeclaration__Group__0__Impl rule__ReferenceDeclaration__Group__1 | 7791 | // InternalProblem.g:2412:2: rule__ReferenceDeclaration__Group__0__Impl rule__ReferenceDeclaration__Group__1 |
6214 | { | 7792 | { |
6215 | pushFollow(FOLLOW_17); | 7793 | pushFollow(FOLLOW_17); |
6216 | rule__ReferenceDeclaration__Group__0__Impl(); | 7794 | rule__ReferenceDeclaration__Group__0__Impl(); |
@@ -6241,29 +7819,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6241 | 7819 | ||
6242 | 7820 | ||
6243 | // $ANTLR start "rule__ReferenceDeclaration__Group__0__Impl" | 7821 | // $ANTLR start "rule__ReferenceDeclaration__Group__0__Impl" |
6244 | // InternalProblem.g:1945:1: rule__ReferenceDeclaration__Group__0__Impl : ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) ; | 7822 | // InternalProblem.g:2419:1: rule__ReferenceDeclaration__Group__0__Impl : ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) ; |
6245 | public final void rule__ReferenceDeclaration__Group__0__Impl() throws RecognitionException { | 7823 | public final void rule__ReferenceDeclaration__Group__0__Impl() throws RecognitionException { |
6246 | 7824 | ||
6247 | int stackSize = keepStackSize(); | 7825 | int stackSize = keepStackSize(); |
6248 | 7826 | ||
6249 | try { | 7827 | try { |
6250 | // InternalProblem.g:1949:1: ( ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) ) | 7828 | // InternalProblem.g:2423:1: ( ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) ) |
6251 | // InternalProblem.g:1950:1: ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) | 7829 | // InternalProblem.g:2424:1: ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) |
6252 | { | 7830 | { |
6253 | // InternalProblem.g:1950:1: ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) | 7831 | // InternalProblem.g:2424:1: ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) |
6254 | // InternalProblem.g:1951:2: ( rule__ReferenceDeclaration__Alternatives_0 )? | 7832 | // InternalProblem.g:2425:2: ( rule__ReferenceDeclaration__Alternatives_0 )? |
6255 | { | 7833 | { |
6256 | before(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0()); | 7834 | before(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0()); |
6257 | // InternalProblem.g:1952:2: ( rule__ReferenceDeclaration__Alternatives_0 )? | 7835 | // InternalProblem.g:2426:2: ( rule__ReferenceDeclaration__Alternatives_0 )? |
6258 | int alt28=2; | 7836 | int alt34=2; |
6259 | int LA28_0 = input.LA(1); | 7837 | int LA34_0 = input.LA(1); |
6260 | 7838 | ||
6261 | if ( (LA28_0==15||LA28_0==41) ) { | 7839 | if ( (LA34_0==15||LA34_0==45) ) { |
6262 | alt28=1; | 7840 | alt34=1; |
6263 | } | 7841 | } |
6264 | switch (alt28) { | 7842 | switch (alt34) { |
6265 | case 1 : | 7843 | case 1 : |
6266 | // InternalProblem.g:1952:3: rule__ReferenceDeclaration__Alternatives_0 | 7844 | // InternalProblem.g:2426:3: rule__ReferenceDeclaration__Alternatives_0 |
6267 | { | 7845 | { |
6268 | pushFollow(FOLLOW_2); | 7846 | pushFollow(FOLLOW_2); |
6269 | rule__ReferenceDeclaration__Alternatives_0(); | 7847 | rule__ReferenceDeclaration__Alternatives_0(); |
@@ -6299,14 +7877,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6299 | 7877 | ||
6300 | 7878 | ||
6301 | // $ANTLR start "rule__ReferenceDeclaration__Group__1" | 7879 | // $ANTLR start "rule__ReferenceDeclaration__Group__1" |
6302 | // InternalProblem.g:1960:1: rule__ReferenceDeclaration__Group__1 : rule__ReferenceDeclaration__Group__1__Impl rule__ReferenceDeclaration__Group__2 ; | 7880 | // InternalProblem.g:2434:1: rule__ReferenceDeclaration__Group__1 : rule__ReferenceDeclaration__Group__1__Impl rule__ReferenceDeclaration__Group__2 ; |
6303 | public final void rule__ReferenceDeclaration__Group__1() throws RecognitionException { | 7881 | public final void rule__ReferenceDeclaration__Group__1() throws RecognitionException { |
6304 | 7882 | ||
6305 | int stackSize = keepStackSize(); | 7883 | int stackSize = keepStackSize(); |
6306 | 7884 | ||
6307 | try { | 7885 | try { |
6308 | // InternalProblem.g:1964:1: ( rule__ReferenceDeclaration__Group__1__Impl rule__ReferenceDeclaration__Group__2 ) | 7886 | // InternalProblem.g:2438:1: ( rule__ReferenceDeclaration__Group__1__Impl rule__ReferenceDeclaration__Group__2 ) |
6309 | // InternalProblem.g:1965:2: rule__ReferenceDeclaration__Group__1__Impl rule__ReferenceDeclaration__Group__2 | 7887 | // InternalProblem.g:2439:2: rule__ReferenceDeclaration__Group__1__Impl rule__ReferenceDeclaration__Group__2 |
6310 | { | 7888 | { |
6311 | pushFollow(FOLLOW_18); | 7889 | pushFollow(FOLLOW_18); |
6312 | rule__ReferenceDeclaration__Group__1__Impl(); | 7890 | rule__ReferenceDeclaration__Group__1__Impl(); |
@@ -6337,21 +7915,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6337 | 7915 | ||
6338 | 7916 | ||
6339 | // $ANTLR start "rule__ReferenceDeclaration__Group__1__Impl" | 7917 | // $ANTLR start "rule__ReferenceDeclaration__Group__1__Impl" |
6340 | // InternalProblem.g:1972:1: rule__ReferenceDeclaration__Group__1__Impl : ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) ; | 7918 | // InternalProblem.g:2446:1: rule__ReferenceDeclaration__Group__1__Impl : ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) ; |
6341 | public final void rule__ReferenceDeclaration__Group__1__Impl() throws RecognitionException { | 7919 | public final void rule__ReferenceDeclaration__Group__1__Impl() throws RecognitionException { |
6342 | 7920 | ||
6343 | int stackSize = keepStackSize(); | 7921 | int stackSize = keepStackSize(); |
6344 | 7922 | ||
6345 | try { | 7923 | try { |
6346 | // InternalProblem.g:1976:1: ( ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) ) | 7924 | // InternalProblem.g:2450:1: ( ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) ) |
6347 | // InternalProblem.g:1977:1: ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) | 7925 | // InternalProblem.g:2451:1: ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) |
6348 | { | 7926 | { |
6349 | // InternalProblem.g:1977:1: ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) | 7927 | // InternalProblem.g:2451:1: ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) |
6350 | // InternalProblem.g:1978:2: ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) | 7928 | // InternalProblem.g:2452:2: ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) |
6351 | { | 7929 | { |
6352 | before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeAssignment_1()); | 7930 | before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeAssignment_1()); |
6353 | // InternalProblem.g:1979:2: ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) | 7931 | // InternalProblem.g:2453:2: ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) |
6354 | // InternalProblem.g:1979:3: rule__ReferenceDeclaration__ReferenceTypeAssignment_1 | 7932 | // InternalProblem.g:2453:3: rule__ReferenceDeclaration__ReferenceTypeAssignment_1 |
6355 | { | 7933 | { |
6356 | pushFollow(FOLLOW_2); | 7934 | pushFollow(FOLLOW_2); |
6357 | rule__ReferenceDeclaration__ReferenceTypeAssignment_1(); | 7935 | rule__ReferenceDeclaration__ReferenceTypeAssignment_1(); |
@@ -6384,14 +7962,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6384 | 7962 | ||
6385 | 7963 | ||
6386 | // $ANTLR start "rule__ReferenceDeclaration__Group__2" | 7964 | // $ANTLR start "rule__ReferenceDeclaration__Group__2" |
6387 | // InternalProblem.g:1987:1: rule__ReferenceDeclaration__Group__2 : rule__ReferenceDeclaration__Group__2__Impl rule__ReferenceDeclaration__Group__3 ; | 7965 | // InternalProblem.g:2461:1: rule__ReferenceDeclaration__Group__2 : rule__ReferenceDeclaration__Group__2__Impl rule__ReferenceDeclaration__Group__3 ; |
6388 | public final void rule__ReferenceDeclaration__Group__2() throws RecognitionException { | 7966 | public final void rule__ReferenceDeclaration__Group__2() throws RecognitionException { |
6389 | 7967 | ||
6390 | int stackSize = keepStackSize(); | 7968 | int stackSize = keepStackSize(); |
6391 | 7969 | ||
6392 | try { | 7970 | try { |
6393 | // InternalProblem.g:1991:1: ( rule__ReferenceDeclaration__Group__2__Impl rule__ReferenceDeclaration__Group__3 ) | 7971 | // InternalProblem.g:2465:1: ( rule__ReferenceDeclaration__Group__2__Impl rule__ReferenceDeclaration__Group__3 ) |
6394 | // InternalProblem.g:1992:2: rule__ReferenceDeclaration__Group__2__Impl rule__ReferenceDeclaration__Group__3 | 7972 | // InternalProblem.g:2466:2: rule__ReferenceDeclaration__Group__2__Impl rule__ReferenceDeclaration__Group__3 |
6395 | { | 7973 | { |
6396 | pushFollow(FOLLOW_18); | 7974 | pushFollow(FOLLOW_18); |
6397 | rule__ReferenceDeclaration__Group__2__Impl(); | 7975 | rule__ReferenceDeclaration__Group__2__Impl(); |
@@ -6422,29 +8000,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6422 | 8000 | ||
6423 | 8001 | ||
6424 | // $ANTLR start "rule__ReferenceDeclaration__Group__2__Impl" | 8002 | // $ANTLR start "rule__ReferenceDeclaration__Group__2__Impl" |
6425 | // InternalProblem.g:1999:1: rule__ReferenceDeclaration__Group__2__Impl : ( ( rule__ReferenceDeclaration__Group_2__0 )? ) ; | 8003 | // InternalProblem.g:2473:1: rule__ReferenceDeclaration__Group__2__Impl : ( ( rule__ReferenceDeclaration__Group_2__0 )? ) ; |
6426 | public final void rule__ReferenceDeclaration__Group__2__Impl() throws RecognitionException { | 8004 | public final void rule__ReferenceDeclaration__Group__2__Impl() throws RecognitionException { |
6427 | 8005 | ||
6428 | int stackSize = keepStackSize(); | 8006 | int stackSize = keepStackSize(); |
6429 | 8007 | ||
6430 | try { | 8008 | try { |
6431 | // InternalProblem.g:2003:1: ( ( ( rule__ReferenceDeclaration__Group_2__0 )? ) ) | 8009 | // InternalProblem.g:2477:1: ( ( ( rule__ReferenceDeclaration__Group_2__0 )? ) ) |
6432 | // InternalProblem.g:2004:1: ( ( rule__ReferenceDeclaration__Group_2__0 )? ) | 8010 | // InternalProblem.g:2478:1: ( ( rule__ReferenceDeclaration__Group_2__0 )? ) |
6433 | { | 8011 | { |
6434 | // InternalProblem.g:2004:1: ( ( rule__ReferenceDeclaration__Group_2__0 )? ) | 8012 | // InternalProblem.g:2478:1: ( ( rule__ReferenceDeclaration__Group_2__0 )? ) |
6435 | // InternalProblem.g:2005:2: ( rule__ReferenceDeclaration__Group_2__0 )? | 8013 | // InternalProblem.g:2479:2: ( rule__ReferenceDeclaration__Group_2__0 )? |
6436 | { | 8014 | { |
6437 | before(grammarAccess.getReferenceDeclarationAccess().getGroup_2()); | 8015 | before(grammarAccess.getReferenceDeclarationAccess().getGroup_2()); |
6438 | // InternalProblem.g:2006:2: ( rule__ReferenceDeclaration__Group_2__0 )? | 8016 | // InternalProblem.g:2480:2: ( rule__ReferenceDeclaration__Group_2__0 )? |
6439 | int alt29=2; | 8017 | int alt35=2; |
6440 | int LA29_0 = input.LA(1); | 8018 | int LA35_0 = input.LA(1); |
6441 | 8019 | ||
6442 | if ( (LA29_0==30) ) { | 8020 | if ( (LA35_0==34) ) { |
6443 | alt29=1; | 8021 | alt35=1; |
6444 | } | 8022 | } |
6445 | switch (alt29) { | 8023 | switch (alt35) { |
6446 | case 1 : | 8024 | case 1 : |
6447 | // InternalProblem.g:2006:3: rule__ReferenceDeclaration__Group_2__0 | 8025 | // InternalProblem.g:2480:3: rule__ReferenceDeclaration__Group_2__0 |
6448 | { | 8026 | { |
6449 | pushFollow(FOLLOW_2); | 8027 | pushFollow(FOLLOW_2); |
6450 | rule__ReferenceDeclaration__Group_2__0(); | 8028 | rule__ReferenceDeclaration__Group_2__0(); |
@@ -6480,14 +8058,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6480 | 8058 | ||
6481 | 8059 | ||
6482 | // $ANTLR start "rule__ReferenceDeclaration__Group__3" | 8060 | // $ANTLR start "rule__ReferenceDeclaration__Group__3" |
6483 | // InternalProblem.g:2014:1: rule__ReferenceDeclaration__Group__3 : rule__ReferenceDeclaration__Group__3__Impl rule__ReferenceDeclaration__Group__4 ; | 8061 | // InternalProblem.g:2488:1: rule__ReferenceDeclaration__Group__3 : rule__ReferenceDeclaration__Group__3__Impl rule__ReferenceDeclaration__Group__4 ; |
6484 | public final void rule__ReferenceDeclaration__Group__3() throws RecognitionException { | 8062 | public final void rule__ReferenceDeclaration__Group__3() throws RecognitionException { |
6485 | 8063 | ||
6486 | int stackSize = keepStackSize(); | 8064 | int stackSize = keepStackSize(); |
6487 | 8065 | ||
6488 | try { | 8066 | try { |
6489 | // InternalProblem.g:2018:1: ( rule__ReferenceDeclaration__Group__3__Impl rule__ReferenceDeclaration__Group__4 ) | 8067 | // InternalProblem.g:2492:1: ( rule__ReferenceDeclaration__Group__3__Impl rule__ReferenceDeclaration__Group__4 ) |
6490 | // InternalProblem.g:2019:2: rule__ReferenceDeclaration__Group__3__Impl rule__ReferenceDeclaration__Group__4 | 8068 | // InternalProblem.g:2493:2: rule__ReferenceDeclaration__Group__3__Impl rule__ReferenceDeclaration__Group__4 |
6491 | { | 8069 | { |
6492 | pushFollow(FOLLOW_19); | 8070 | pushFollow(FOLLOW_19); |
6493 | rule__ReferenceDeclaration__Group__3__Impl(); | 8071 | rule__ReferenceDeclaration__Group__3__Impl(); |
@@ -6518,21 +8096,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6518 | 8096 | ||
6519 | 8097 | ||
6520 | // $ANTLR start "rule__ReferenceDeclaration__Group__3__Impl" | 8098 | // $ANTLR start "rule__ReferenceDeclaration__Group__3__Impl" |
6521 | // InternalProblem.g:2026:1: rule__ReferenceDeclaration__Group__3__Impl : ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) ; | 8099 | // InternalProblem.g:2500:1: rule__ReferenceDeclaration__Group__3__Impl : ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) ; |
6522 | public final void rule__ReferenceDeclaration__Group__3__Impl() throws RecognitionException { | 8100 | public final void rule__ReferenceDeclaration__Group__3__Impl() throws RecognitionException { |
6523 | 8101 | ||
6524 | int stackSize = keepStackSize(); | 8102 | int stackSize = keepStackSize(); |
6525 | 8103 | ||
6526 | try { | 8104 | try { |
6527 | // InternalProblem.g:2030:1: ( ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) ) | 8105 | // InternalProblem.g:2504:1: ( ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) ) |
6528 | // InternalProblem.g:2031:1: ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) | 8106 | // InternalProblem.g:2505:1: ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) |
6529 | { | 8107 | { |
6530 | // InternalProblem.g:2031:1: ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) | 8108 | // InternalProblem.g:2505:1: ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) |
6531 | // InternalProblem.g:2032:2: ( rule__ReferenceDeclaration__NameAssignment_3 ) | 8109 | // InternalProblem.g:2506:2: ( rule__ReferenceDeclaration__NameAssignment_3 ) |
6532 | { | 8110 | { |
6533 | before(grammarAccess.getReferenceDeclarationAccess().getNameAssignment_3()); | 8111 | before(grammarAccess.getReferenceDeclarationAccess().getNameAssignment_3()); |
6534 | // InternalProblem.g:2033:2: ( rule__ReferenceDeclaration__NameAssignment_3 ) | 8112 | // InternalProblem.g:2507:2: ( rule__ReferenceDeclaration__NameAssignment_3 ) |
6535 | // InternalProblem.g:2033:3: rule__ReferenceDeclaration__NameAssignment_3 | 8113 | // InternalProblem.g:2507:3: rule__ReferenceDeclaration__NameAssignment_3 |
6536 | { | 8114 | { |
6537 | pushFollow(FOLLOW_2); | 8115 | pushFollow(FOLLOW_2); |
6538 | rule__ReferenceDeclaration__NameAssignment_3(); | 8116 | rule__ReferenceDeclaration__NameAssignment_3(); |
@@ -6565,14 +8143,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6565 | 8143 | ||
6566 | 8144 | ||
6567 | // $ANTLR start "rule__ReferenceDeclaration__Group__4" | 8145 | // $ANTLR start "rule__ReferenceDeclaration__Group__4" |
6568 | // InternalProblem.g:2041:1: rule__ReferenceDeclaration__Group__4 : rule__ReferenceDeclaration__Group__4__Impl ; | 8146 | // InternalProblem.g:2515:1: rule__ReferenceDeclaration__Group__4 : rule__ReferenceDeclaration__Group__4__Impl ; |
6569 | public final void rule__ReferenceDeclaration__Group__4() throws RecognitionException { | 8147 | public final void rule__ReferenceDeclaration__Group__4() throws RecognitionException { |
6570 | 8148 | ||
6571 | int stackSize = keepStackSize(); | 8149 | int stackSize = keepStackSize(); |
6572 | 8150 | ||
6573 | try { | 8151 | try { |
6574 | // InternalProblem.g:2045:1: ( rule__ReferenceDeclaration__Group__4__Impl ) | 8152 | // InternalProblem.g:2519:1: ( rule__ReferenceDeclaration__Group__4__Impl ) |
6575 | // InternalProblem.g:2046:2: rule__ReferenceDeclaration__Group__4__Impl | 8153 | // InternalProblem.g:2520:2: rule__ReferenceDeclaration__Group__4__Impl |
6576 | { | 8154 | { |
6577 | pushFollow(FOLLOW_2); | 8155 | pushFollow(FOLLOW_2); |
6578 | rule__ReferenceDeclaration__Group__4__Impl(); | 8156 | rule__ReferenceDeclaration__Group__4__Impl(); |
@@ -6598,29 +8176,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6598 | 8176 | ||
6599 | 8177 | ||
6600 | // $ANTLR start "rule__ReferenceDeclaration__Group__4__Impl" | 8178 | // $ANTLR start "rule__ReferenceDeclaration__Group__4__Impl" |
6601 | // InternalProblem.g:2052:1: rule__ReferenceDeclaration__Group__4__Impl : ( ( rule__ReferenceDeclaration__Group_4__0 )? ) ; | 8179 | // InternalProblem.g:2526:1: rule__ReferenceDeclaration__Group__4__Impl : ( ( rule__ReferenceDeclaration__Group_4__0 )? ) ; |
6602 | public final void rule__ReferenceDeclaration__Group__4__Impl() throws RecognitionException { | 8180 | public final void rule__ReferenceDeclaration__Group__4__Impl() throws RecognitionException { |
6603 | 8181 | ||
6604 | int stackSize = keepStackSize(); | 8182 | int stackSize = keepStackSize(); |
6605 | 8183 | ||
6606 | try { | 8184 | try { |
6607 | // InternalProblem.g:2056:1: ( ( ( rule__ReferenceDeclaration__Group_4__0 )? ) ) | 8185 | // InternalProblem.g:2530:1: ( ( ( rule__ReferenceDeclaration__Group_4__0 )? ) ) |
6608 | // InternalProblem.g:2057:1: ( ( rule__ReferenceDeclaration__Group_4__0 )? ) | 8186 | // InternalProblem.g:2531:1: ( ( rule__ReferenceDeclaration__Group_4__0 )? ) |
6609 | { | 8187 | { |
6610 | // InternalProblem.g:2057:1: ( ( rule__ReferenceDeclaration__Group_4__0 )? ) | 8188 | // InternalProblem.g:2531:1: ( ( rule__ReferenceDeclaration__Group_4__0 )? ) |
6611 | // InternalProblem.g:2058:2: ( rule__ReferenceDeclaration__Group_4__0 )? | 8189 | // InternalProblem.g:2532:2: ( rule__ReferenceDeclaration__Group_4__0 )? |
6612 | { | 8190 | { |
6613 | before(grammarAccess.getReferenceDeclarationAccess().getGroup_4()); | 8191 | before(grammarAccess.getReferenceDeclarationAccess().getGroup_4()); |
6614 | // InternalProblem.g:2059:2: ( rule__ReferenceDeclaration__Group_4__0 )? | 8192 | // InternalProblem.g:2533:2: ( rule__ReferenceDeclaration__Group_4__0 )? |
6615 | int alt30=2; | 8193 | int alt36=2; |
6616 | int LA30_0 = input.LA(1); | 8194 | int LA36_0 = input.LA(1); |
6617 | 8195 | ||
6618 | if ( (LA30_0==32) ) { | 8196 | if ( (LA36_0==36) ) { |
6619 | alt30=1; | 8197 | alt36=1; |
6620 | } | 8198 | } |
6621 | switch (alt30) { | 8199 | switch (alt36) { |
6622 | case 1 : | 8200 | case 1 : |
6623 | // InternalProblem.g:2059:3: rule__ReferenceDeclaration__Group_4__0 | 8201 | // InternalProblem.g:2533:3: rule__ReferenceDeclaration__Group_4__0 |
6624 | { | 8202 | { |
6625 | pushFollow(FOLLOW_2); | 8203 | pushFollow(FOLLOW_2); |
6626 | rule__ReferenceDeclaration__Group_4__0(); | 8204 | rule__ReferenceDeclaration__Group_4__0(); |
@@ -6656,14 +8234,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6656 | 8234 | ||
6657 | 8235 | ||
6658 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__0" | 8236 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__0" |
6659 | // InternalProblem.g:2068:1: rule__ReferenceDeclaration__Group_2__0 : rule__ReferenceDeclaration__Group_2__0__Impl rule__ReferenceDeclaration__Group_2__1 ; | 8237 | // InternalProblem.g:2542:1: rule__ReferenceDeclaration__Group_2__0 : rule__ReferenceDeclaration__Group_2__0__Impl rule__ReferenceDeclaration__Group_2__1 ; |
6660 | public final void rule__ReferenceDeclaration__Group_2__0() throws RecognitionException { | 8238 | public final void rule__ReferenceDeclaration__Group_2__0() throws RecognitionException { |
6661 | 8239 | ||
6662 | int stackSize = keepStackSize(); | 8240 | int stackSize = keepStackSize(); |
6663 | 8241 | ||
6664 | try { | 8242 | try { |
6665 | // InternalProblem.g:2072:1: ( rule__ReferenceDeclaration__Group_2__0__Impl rule__ReferenceDeclaration__Group_2__1 ) | 8243 | // InternalProblem.g:2546:1: ( rule__ReferenceDeclaration__Group_2__0__Impl rule__ReferenceDeclaration__Group_2__1 ) |
6666 | // InternalProblem.g:2073:2: rule__ReferenceDeclaration__Group_2__0__Impl rule__ReferenceDeclaration__Group_2__1 | 8244 | // InternalProblem.g:2547:2: rule__ReferenceDeclaration__Group_2__0__Impl rule__ReferenceDeclaration__Group_2__1 |
6667 | { | 8245 | { |
6668 | pushFollow(FOLLOW_20); | 8246 | pushFollow(FOLLOW_20); |
6669 | rule__ReferenceDeclaration__Group_2__0__Impl(); | 8247 | rule__ReferenceDeclaration__Group_2__0__Impl(); |
@@ -6694,20 +8272,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6694 | 8272 | ||
6695 | 8273 | ||
6696 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__0__Impl" | 8274 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__0__Impl" |
6697 | // InternalProblem.g:2080:1: rule__ReferenceDeclaration__Group_2__0__Impl : ( '[' ) ; | 8275 | // InternalProblem.g:2554:1: rule__ReferenceDeclaration__Group_2__0__Impl : ( '[' ) ; |
6698 | public final void rule__ReferenceDeclaration__Group_2__0__Impl() throws RecognitionException { | 8276 | public final void rule__ReferenceDeclaration__Group_2__0__Impl() throws RecognitionException { |
6699 | 8277 | ||
6700 | int stackSize = keepStackSize(); | 8278 | int stackSize = keepStackSize(); |
6701 | 8279 | ||
6702 | try { | 8280 | try { |
6703 | // InternalProblem.g:2084:1: ( ( '[' ) ) | 8281 | // InternalProblem.g:2558:1: ( ( '[' ) ) |
6704 | // InternalProblem.g:2085:1: ( '[' ) | 8282 | // InternalProblem.g:2559:1: ( '[' ) |
6705 | { | 8283 | { |
6706 | // InternalProblem.g:2085:1: ( '[' ) | 8284 | // InternalProblem.g:2559:1: ( '[' ) |
6707 | // InternalProblem.g:2086:2: '[' | 8285 | // InternalProblem.g:2560:2: '[' |
6708 | { | 8286 | { |
6709 | before(grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); | 8287 | before(grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); |
6710 | match(input,30,FOLLOW_2); | 8288 | match(input,34,FOLLOW_2); |
6711 | after(grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); | 8289 | after(grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); |
6712 | 8290 | ||
6713 | } | 8291 | } |
@@ -6731,14 +8309,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6731 | 8309 | ||
6732 | 8310 | ||
6733 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__1" | 8311 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__1" |
6734 | // InternalProblem.g:2095:1: rule__ReferenceDeclaration__Group_2__1 : rule__ReferenceDeclaration__Group_2__1__Impl rule__ReferenceDeclaration__Group_2__2 ; | 8312 | // InternalProblem.g:2569:1: rule__ReferenceDeclaration__Group_2__1 : rule__ReferenceDeclaration__Group_2__1__Impl rule__ReferenceDeclaration__Group_2__2 ; |
6735 | public final void rule__ReferenceDeclaration__Group_2__1() throws RecognitionException { | 8313 | public final void rule__ReferenceDeclaration__Group_2__1() throws RecognitionException { |
6736 | 8314 | ||
6737 | int stackSize = keepStackSize(); | 8315 | int stackSize = keepStackSize(); |
6738 | 8316 | ||
6739 | try { | 8317 | try { |
6740 | // InternalProblem.g:2099:1: ( rule__ReferenceDeclaration__Group_2__1__Impl rule__ReferenceDeclaration__Group_2__2 ) | 8318 | // InternalProblem.g:2573:1: ( rule__ReferenceDeclaration__Group_2__1__Impl rule__ReferenceDeclaration__Group_2__2 ) |
6741 | // InternalProblem.g:2100:2: rule__ReferenceDeclaration__Group_2__1__Impl rule__ReferenceDeclaration__Group_2__2 | 8319 | // InternalProblem.g:2574:2: rule__ReferenceDeclaration__Group_2__1__Impl rule__ReferenceDeclaration__Group_2__2 |
6742 | { | 8320 | { |
6743 | pushFollow(FOLLOW_21); | 8321 | pushFollow(FOLLOW_21); |
6744 | rule__ReferenceDeclaration__Group_2__1__Impl(); | 8322 | rule__ReferenceDeclaration__Group_2__1__Impl(); |
@@ -6769,21 +8347,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6769 | 8347 | ||
6770 | 8348 | ||
6771 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__1__Impl" | 8349 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__1__Impl" |
6772 | // InternalProblem.g:2107:1: rule__ReferenceDeclaration__Group_2__1__Impl : ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) ; | 8350 | // InternalProblem.g:2581:1: rule__ReferenceDeclaration__Group_2__1__Impl : ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) ; |
6773 | public final void rule__ReferenceDeclaration__Group_2__1__Impl() throws RecognitionException { | 8351 | public final void rule__ReferenceDeclaration__Group_2__1__Impl() throws RecognitionException { |
6774 | 8352 | ||
6775 | int stackSize = keepStackSize(); | 8353 | int stackSize = keepStackSize(); |
6776 | 8354 | ||
6777 | try { | 8355 | try { |
6778 | // InternalProblem.g:2111:1: ( ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) ) | 8356 | // InternalProblem.g:2585:1: ( ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) ) |
6779 | // InternalProblem.g:2112:1: ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) | 8357 | // InternalProblem.g:2586:1: ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) |
6780 | { | 8358 | { |
6781 | // InternalProblem.g:2112:1: ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) | 8359 | // InternalProblem.g:2586:1: ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) |
6782 | // InternalProblem.g:2113:2: ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) | 8360 | // InternalProblem.g:2587:2: ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) |
6783 | { | 8361 | { |
6784 | before(grammarAccess.getReferenceDeclarationAccess().getMultiplicityAssignment_2_1()); | 8362 | before(grammarAccess.getReferenceDeclarationAccess().getMultiplicityAssignment_2_1()); |
6785 | // InternalProblem.g:2114:2: ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) | 8363 | // InternalProblem.g:2588:2: ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) |
6786 | // InternalProblem.g:2114:3: rule__ReferenceDeclaration__MultiplicityAssignment_2_1 | 8364 | // InternalProblem.g:2588:3: rule__ReferenceDeclaration__MultiplicityAssignment_2_1 |
6787 | { | 8365 | { |
6788 | pushFollow(FOLLOW_2); | 8366 | pushFollow(FOLLOW_2); |
6789 | rule__ReferenceDeclaration__MultiplicityAssignment_2_1(); | 8367 | rule__ReferenceDeclaration__MultiplicityAssignment_2_1(); |
@@ -6816,14 +8394,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6816 | 8394 | ||
6817 | 8395 | ||
6818 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__2" | 8396 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__2" |
6819 | // InternalProblem.g:2122:1: rule__ReferenceDeclaration__Group_2__2 : rule__ReferenceDeclaration__Group_2__2__Impl ; | 8397 | // InternalProblem.g:2596:1: rule__ReferenceDeclaration__Group_2__2 : rule__ReferenceDeclaration__Group_2__2__Impl ; |
6820 | public final void rule__ReferenceDeclaration__Group_2__2() throws RecognitionException { | 8398 | public final void rule__ReferenceDeclaration__Group_2__2() throws RecognitionException { |
6821 | 8399 | ||
6822 | int stackSize = keepStackSize(); | 8400 | int stackSize = keepStackSize(); |
6823 | 8401 | ||
6824 | try { | 8402 | try { |
6825 | // InternalProblem.g:2126:1: ( rule__ReferenceDeclaration__Group_2__2__Impl ) | 8403 | // InternalProblem.g:2600:1: ( rule__ReferenceDeclaration__Group_2__2__Impl ) |
6826 | // InternalProblem.g:2127:2: rule__ReferenceDeclaration__Group_2__2__Impl | 8404 | // InternalProblem.g:2601:2: rule__ReferenceDeclaration__Group_2__2__Impl |
6827 | { | 8405 | { |
6828 | pushFollow(FOLLOW_2); | 8406 | pushFollow(FOLLOW_2); |
6829 | rule__ReferenceDeclaration__Group_2__2__Impl(); | 8407 | rule__ReferenceDeclaration__Group_2__2__Impl(); |
@@ -6849,20 +8427,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6849 | 8427 | ||
6850 | 8428 | ||
6851 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__2__Impl" | 8429 | // $ANTLR start "rule__ReferenceDeclaration__Group_2__2__Impl" |
6852 | // InternalProblem.g:2133:1: rule__ReferenceDeclaration__Group_2__2__Impl : ( ']' ) ; | 8430 | // InternalProblem.g:2607:1: rule__ReferenceDeclaration__Group_2__2__Impl : ( ']' ) ; |
6853 | public final void rule__ReferenceDeclaration__Group_2__2__Impl() throws RecognitionException { | 8431 | public final void rule__ReferenceDeclaration__Group_2__2__Impl() throws RecognitionException { |
6854 | 8432 | ||
6855 | int stackSize = keepStackSize(); | 8433 | int stackSize = keepStackSize(); |
6856 | 8434 | ||
6857 | try { | 8435 | try { |
6858 | // InternalProblem.g:2137:1: ( ( ']' ) ) | 8436 | // InternalProblem.g:2611:1: ( ( ']' ) ) |
6859 | // InternalProblem.g:2138:1: ( ']' ) | 8437 | // InternalProblem.g:2612:1: ( ']' ) |
6860 | { | 8438 | { |
6861 | // InternalProblem.g:2138:1: ( ']' ) | 8439 | // InternalProblem.g:2612:1: ( ']' ) |
6862 | // InternalProblem.g:2139:2: ']' | 8440 | // InternalProblem.g:2613:2: ']' |
6863 | { | 8441 | { |
6864 | before(grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); | 8442 | before(grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); |
6865 | match(input,31,FOLLOW_2); | 8443 | match(input,35,FOLLOW_2); |
6866 | after(grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); | 8444 | after(grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); |
6867 | 8445 | ||
6868 | } | 8446 | } |
@@ -6886,14 +8464,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6886 | 8464 | ||
6887 | 8465 | ||
6888 | // $ANTLR start "rule__ReferenceDeclaration__Group_4__0" | 8466 | // $ANTLR start "rule__ReferenceDeclaration__Group_4__0" |
6889 | // InternalProblem.g:2149:1: rule__ReferenceDeclaration__Group_4__0 : rule__ReferenceDeclaration__Group_4__0__Impl rule__ReferenceDeclaration__Group_4__1 ; | 8467 | // InternalProblem.g:2623:1: rule__ReferenceDeclaration__Group_4__0 : rule__ReferenceDeclaration__Group_4__0__Impl rule__ReferenceDeclaration__Group_4__1 ; |
6890 | public final void rule__ReferenceDeclaration__Group_4__0() throws RecognitionException { | 8468 | public final void rule__ReferenceDeclaration__Group_4__0() throws RecognitionException { |
6891 | 8469 | ||
6892 | int stackSize = keepStackSize(); | 8470 | int stackSize = keepStackSize(); |
6893 | 8471 | ||
6894 | try { | 8472 | try { |
6895 | // InternalProblem.g:2153:1: ( rule__ReferenceDeclaration__Group_4__0__Impl rule__ReferenceDeclaration__Group_4__1 ) | 8473 | // InternalProblem.g:2627:1: ( rule__ReferenceDeclaration__Group_4__0__Impl rule__ReferenceDeclaration__Group_4__1 ) |
6896 | // InternalProblem.g:2154:2: rule__ReferenceDeclaration__Group_4__0__Impl rule__ReferenceDeclaration__Group_4__1 | 8474 | // InternalProblem.g:2628:2: rule__ReferenceDeclaration__Group_4__0__Impl rule__ReferenceDeclaration__Group_4__1 |
6897 | { | 8475 | { |
6898 | pushFollow(FOLLOW_5); | 8476 | pushFollow(FOLLOW_5); |
6899 | rule__ReferenceDeclaration__Group_4__0__Impl(); | 8477 | rule__ReferenceDeclaration__Group_4__0__Impl(); |
@@ -6924,20 +8502,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6924 | 8502 | ||
6925 | 8503 | ||
6926 | // $ANTLR start "rule__ReferenceDeclaration__Group_4__0__Impl" | 8504 | // $ANTLR start "rule__ReferenceDeclaration__Group_4__0__Impl" |
6927 | // InternalProblem.g:2161:1: rule__ReferenceDeclaration__Group_4__0__Impl : ( 'opposite' ) ; | 8505 | // InternalProblem.g:2635:1: rule__ReferenceDeclaration__Group_4__0__Impl : ( 'opposite' ) ; |
6928 | public final void rule__ReferenceDeclaration__Group_4__0__Impl() throws RecognitionException { | 8506 | public final void rule__ReferenceDeclaration__Group_4__0__Impl() throws RecognitionException { |
6929 | 8507 | ||
6930 | int stackSize = keepStackSize(); | 8508 | int stackSize = keepStackSize(); |
6931 | 8509 | ||
6932 | try { | 8510 | try { |
6933 | // InternalProblem.g:2165:1: ( ( 'opposite' ) ) | 8511 | // InternalProblem.g:2639:1: ( ( 'opposite' ) ) |
6934 | // InternalProblem.g:2166:1: ( 'opposite' ) | 8512 | // InternalProblem.g:2640:1: ( 'opposite' ) |
6935 | { | 8513 | { |
6936 | // InternalProblem.g:2166:1: ( 'opposite' ) | 8514 | // InternalProblem.g:2640:1: ( 'opposite' ) |
6937 | // InternalProblem.g:2167:2: 'opposite' | 8515 | // InternalProblem.g:2641:2: 'opposite' |
6938 | { | 8516 | { |
6939 | before(grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); | 8517 | before(grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); |
6940 | match(input,32,FOLLOW_2); | 8518 | match(input,36,FOLLOW_2); |
6941 | after(grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); | 8519 | after(grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); |
6942 | 8520 | ||
6943 | } | 8521 | } |
@@ -6961,14 +8539,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6961 | 8539 | ||
6962 | 8540 | ||
6963 | // $ANTLR start "rule__ReferenceDeclaration__Group_4__1" | 8541 | // $ANTLR start "rule__ReferenceDeclaration__Group_4__1" |
6964 | // InternalProblem.g:2176:1: rule__ReferenceDeclaration__Group_4__1 : rule__ReferenceDeclaration__Group_4__1__Impl ; | 8542 | // InternalProblem.g:2650:1: rule__ReferenceDeclaration__Group_4__1 : rule__ReferenceDeclaration__Group_4__1__Impl ; |
6965 | public final void rule__ReferenceDeclaration__Group_4__1() throws RecognitionException { | 8543 | public final void rule__ReferenceDeclaration__Group_4__1() throws RecognitionException { |
6966 | 8544 | ||
6967 | int stackSize = keepStackSize(); | 8545 | int stackSize = keepStackSize(); |
6968 | 8546 | ||
6969 | try { | 8547 | try { |
6970 | // InternalProblem.g:2180:1: ( rule__ReferenceDeclaration__Group_4__1__Impl ) | 8548 | // InternalProblem.g:2654:1: ( rule__ReferenceDeclaration__Group_4__1__Impl ) |
6971 | // InternalProblem.g:2181:2: rule__ReferenceDeclaration__Group_4__1__Impl | 8549 | // InternalProblem.g:2655:2: rule__ReferenceDeclaration__Group_4__1__Impl |
6972 | { | 8550 | { |
6973 | pushFollow(FOLLOW_2); | 8551 | pushFollow(FOLLOW_2); |
6974 | rule__ReferenceDeclaration__Group_4__1__Impl(); | 8552 | rule__ReferenceDeclaration__Group_4__1__Impl(); |
@@ -6994,21 +8572,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
6994 | 8572 | ||
6995 | 8573 | ||
6996 | // $ANTLR start "rule__ReferenceDeclaration__Group_4__1__Impl" | 8574 | // $ANTLR start "rule__ReferenceDeclaration__Group_4__1__Impl" |
6997 | // InternalProblem.g:2187:1: rule__ReferenceDeclaration__Group_4__1__Impl : ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) ; | 8575 | // InternalProblem.g:2661:1: rule__ReferenceDeclaration__Group_4__1__Impl : ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) ; |
6998 | public final void rule__ReferenceDeclaration__Group_4__1__Impl() throws RecognitionException { | 8576 | public final void rule__ReferenceDeclaration__Group_4__1__Impl() throws RecognitionException { |
6999 | 8577 | ||
7000 | int stackSize = keepStackSize(); | 8578 | int stackSize = keepStackSize(); |
7001 | 8579 | ||
7002 | try { | 8580 | try { |
7003 | // InternalProblem.g:2191:1: ( ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) ) | 8581 | // InternalProblem.g:2665:1: ( ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) ) |
7004 | // InternalProblem.g:2192:1: ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) | 8582 | // InternalProblem.g:2666:1: ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) |
7005 | { | 8583 | { |
7006 | // InternalProblem.g:2192:1: ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) | 8584 | // InternalProblem.g:2666:1: ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) |
7007 | // InternalProblem.g:2193:2: ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) | 8585 | // InternalProblem.g:2667:2: ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) |
7008 | { | 8586 | { |
7009 | before(grammarAccess.getReferenceDeclarationAccess().getOppositeAssignment_4_1()); | 8587 | before(grammarAccess.getReferenceDeclarationAccess().getOppositeAssignment_4_1()); |
7010 | // InternalProblem.g:2194:2: ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) | 8588 | // InternalProblem.g:2668:2: ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) |
7011 | // InternalProblem.g:2194:3: rule__ReferenceDeclaration__OppositeAssignment_4_1 | 8589 | // InternalProblem.g:2668:3: rule__ReferenceDeclaration__OppositeAssignment_4_1 |
7012 | { | 8590 | { |
7013 | pushFollow(FOLLOW_2); | 8591 | pushFollow(FOLLOW_2); |
7014 | rule__ReferenceDeclaration__OppositeAssignment_4_1(); | 8592 | rule__ReferenceDeclaration__OppositeAssignment_4_1(); |
@@ -7041,14 +8619,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7041 | 8619 | ||
7042 | 8620 | ||
7043 | // $ANTLR start "rule__PredicateDefinition__Group__0" | 8621 | // $ANTLR start "rule__PredicateDefinition__Group__0" |
7044 | // InternalProblem.g:2203:1: rule__PredicateDefinition__Group__0 : rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ; | 8622 | // InternalProblem.g:2677:1: rule__PredicateDefinition__Group__0 : rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ; |
7045 | public final void rule__PredicateDefinition__Group__0() throws RecognitionException { | 8623 | public final void rule__PredicateDefinition__Group__0() throws RecognitionException { |
7046 | 8624 | ||
7047 | int stackSize = keepStackSize(); | 8625 | int stackSize = keepStackSize(); |
7048 | 8626 | ||
7049 | try { | 8627 | try { |
7050 | // InternalProblem.g:2207:1: ( rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ) | 8628 | // InternalProblem.g:2681:1: ( rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ) |
7051 | // InternalProblem.g:2208:2: rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 | 8629 | // InternalProblem.g:2682:2: rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 |
7052 | { | 8630 | { |
7053 | pushFollow(FOLLOW_5); | 8631 | pushFollow(FOLLOW_5); |
7054 | rule__PredicateDefinition__Group__0__Impl(); | 8632 | rule__PredicateDefinition__Group__0__Impl(); |
@@ -7079,21 +8657,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7079 | 8657 | ||
7080 | 8658 | ||
7081 | // $ANTLR start "rule__PredicateDefinition__Group__0__Impl" | 8659 | // $ANTLR start "rule__PredicateDefinition__Group__0__Impl" |
7082 | // InternalProblem.g:2215:1: rule__PredicateDefinition__Group__0__Impl : ( ( rule__PredicateDefinition__Alternatives_0 ) ) ; | 8660 | // InternalProblem.g:2689:1: rule__PredicateDefinition__Group__0__Impl : ( ( rule__PredicateDefinition__Alternatives_0 ) ) ; |
7083 | public final void rule__PredicateDefinition__Group__0__Impl() throws RecognitionException { | 8661 | public final void rule__PredicateDefinition__Group__0__Impl() throws RecognitionException { |
7084 | 8662 | ||
7085 | int stackSize = keepStackSize(); | 8663 | int stackSize = keepStackSize(); |
7086 | 8664 | ||
7087 | try { | 8665 | try { |
7088 | // InternalProblem.g:2219:1: ( ( ( rule__PredicateDefinition__Alternatives_0 ) ) ) | 8666 | // InternalProblem.g:2693:1: ( ( ( rule__PredicateDefinition__Alternatives_0 ) ) ) |
7089 | // InternalProblem.g:2220:1: ( ( rule__PredicateDefinition__Alternatives_0 ) ) | 8667 | // InternalProblem.g:2694:1: ( ( rule__PredicateDefinition__Alternatives_0 ) ) |
7090 | { | 8668 | { |
7091 | // InternalProblem.g:2220:1: ( ( rule__PredicateDefinition__Alternatives_0 ) ) | 8669 | // InternalProblem.g:2694:1: ( ( rule__PredicateDefinition__Alternatives_0 ) ) |
7092 | // InternalProblem.g:2221:2: ( rule__PredicateDefinition__Alternatives_0 ) | 8670 | // InternalProblem.g:2695:2: ( rule__PredicateDefinition__Alternatives_0 ) |
7093 | { | 8671 | { |
7094 | before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); | 8672 | before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); |
7095 | // InternalProblem.g:2222:2: ( rule__PredicateDefinition__Alternatives_0 ) | 8673 | // InternalProblem.g:2696:2: ( rule__PredicateDefinition__Alternatives_0 ) |
7096 | // InternalProblem.g:2222:3: rule__PredicateDefinition__Alternatives_0 | 8674 | // InternalProblem.g:2696:3: rule__PredicateDefinition__Alternatives_0 |
7097 | { | 8675 | { |
7098 | pushFollow(FOLLOW_2); | 8676 | pushFollow(FOLLOW_2); |
7099 | rule__PredicateDefinition__Alternatives_0(); | 8677 | rule__PredicateDefinition__Alternatives_0(); |
@@ -7126,14 +8704,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7126 | 8704 | ||
7127 | 8705 | ||
7128 | // $ANTLR start "rule__PredicateDefinition__Group__1" | 8706 | // $ANTLR start "rule__PredicateDefinition__Group__1" |
7129 | // InternalProblem.g:2230:1: rule__PredicateDefinition__Group__1 : rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ; | 8707 | // InternalProblem.g:2704:1: rule__PredicateDefinition__Group__1 : rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ; |
7130 | public final void rule__PredicateDefinition__Group__1() throws RecognitionException { | 8708 | public final void rule__PredicateDefinition__Group__1() throws RecognitionException { |
7131 | 8709 | ||
7132 | int stackSize = keepStackSize(); | 8710 | int stackSize = keepStackSize(); |
7133 | 8711 | ||
7134 | try { | 8712 | try { |
7135 | // InternalProblem.g:2234:1: ( rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ) | 8713 | // InternalProblem.g:2708:1: ( rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ) |
7136 | // InternalProblem.g:2235:2: rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 | 8714 | // InternalProblem.g:2709:2: rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 |
7137 | { | 8715 | { |
7138 | pushFollow(FOLLOW_22); | 8716 | pushFollow(FOLLOW_22); |
7139 | rule__PredicateDefinition__Group__1__Impl(); | 8717 | rule__PredicateDefinition__Group__1__Impl(); |
@@ -7164,21 +8742,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7164 | 8742 | ||
7165 | 8743 | ||
7166 | // $ANTLR start "rule__PredicateDefinition__Group__1__Impl" | 8744 | // $ANTLR start "rule__PredicateDefinition__Group__1__Impl" |
7167 | // InternalProblem.g:2242:1: rule__PredicateDefinition__Group__1__Impl : ( ( rule__PredicateDefinition__NameAssignment_1 ) ) ; | 8745 | // InternalProblem.g:2716:1: rule__PredicateDefinition__Group__1__Impl : ( ( rule__PredicateDefinition__NameAssignment_1 ) ) ; |
7168 | public final void rule__PredicateDefinition__Group__1__Impl() throws RecognitionException { | 8746 | public final void rule__PredicateDefinition__Group__1__Impl() throws RecognitionException { |
7169 | 8747 | ||
7170 | int stackSize = keepStackSize(); | 8748 | int stackSize = keepStackSize(); |
7171 | 8749 | ||
7172 | try { | 8750 | try { |
7173 | // InternalProblem.g:2246:1: ( ( ( rule__PredicateDefinition__NameAssignment_1 ) ) ) | 8751 | // InternalProblem.g:2720:1: ( ( ( rule__PredicateDefinition__NameAssignment_1 ) ) ) |
7174 | // InternalProblem.g:2247:1: ( ( rule__PredicateDefinition__NameAssignment_1 ) ) | 8752 | // InternalProblem.g:2721:1: ( ( rule__PredicateDefinition__NameAssignment_1 ) ) |
7175 | { | 8753 | { |
7176 | // InternalProblem.g:2247:1: ( ( rule__PredicateDefinition__NameAssignment_1 ) ) | 8754 | // InternalProblem.g:2721:1: ( ( rule__PredicateDefinition__NameAssignment_1 ) ) |
7177 | // InternalProblem.g:2248:2: ( rule__PredicateDefinition__NameAssignment_1 ) | 8755 | // InternalProblem.g:2722:2: ( rule__PredicateDefinition__NameAssignment_1 ) |
7178 | { | 8756 | { |
7179 | before(grammarAccess.getPredicateDefinitionAccess().getNameAssignment_1()); | 8757 | before(grammarAccess.getPredicateDefinitionAccess().getNameAssignment_1()); |
7180 | // InternalProblem.g:2249:2: ( rule__PredicateDefinition__NameAssignment_1 ) | 8758 | // InternalProblem.g:2723:2: ( rule__PredicateDefinition__NameAssignment_1 ) |
7181 | // InternalProblem.g:2249:3: rule__PredicateDefinition__NameAssignment_1 | 8759 | // InternalProblem.g:2723:3: rule__PredicateDefinition__NameAssignment_1 |
7182 | { | 8760 | { |
7183 | pushFollow(FOLLOW_2); | 8761 | pushFollow(FOLLOW_2); |
7184 | rule__PredicateDefinition__NameAssignment_1(); | 8762 | rule__PredicateDefinition__NameAssignment_1(); |
@@ -7211,14 +8789,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7211 | 8789 | ||
7212 | 8790 | ||
7213 | // $ANTLR start "rule__PredicateDefinition__Group__2" | 8791 | // $ANTLR start "rule__PredicateDefinition__Group__2" |
7214 | // InternalProblem.g:2257:1: rule__PredicateDefinition__Group__2 : rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ; | 8792 | // InternalProblem.g:2731:1: rule__PredicateDefinition__Group__2 : rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ; |
7215 | public final void rule__PredicateDefinition__Group__2() throws RecognitionException { | 8793 | public final void rule__PredicateDefinition__Group__2() throws RecognitionException { |
7216 | 8794 | ||
7217 | int stackSize = keepStackSize(); | 8795 | int stackSize = keepStackSize(); |
7218 | 8796 | ||
7219 | try { | 8797 | try { |
7220 | // InternalProblem.g:2261:1: ( rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ) | 8798 | // InternalProblem.g:2735:1: ( rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ) |
7221 | // InternalProblem.g:2262:2: rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 | 8799 | // InternalProblem.g:2736:2: rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 |
7222 | { | 8800 | { |
7223 | pushFollow(FOLLOW_23); | 8801 | pushFollow(FOLLOW_23); |
7224 | rule__PredicateDefinition__Group__2__Impl(); | 8802 | rule__PredicateDefinition__Group__2__Impl(); |
@@ -7249,20 +8827,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7249 | 8827 | ||
7250 | 8828 | ||
7251 | // $ANTLR start "rule__PredicateDefinition__Group__2__Impl" | 8829 | // $ANTLR start "rule__PredicateDefinition__Group__2__Impl" |
7252 | // InternalProblem.g:2269:1: rule__PredicateDefinition__Group__2__Impl : ( '(' ) ; | 8830 | // InternalProblem.g:2743:1: rule__PredicateDefinition__Group__2__Impl : ( '(' ) ; |
7253 | public final void rule__PredicateDefinition__Group__2__Impl() throws RecognitionException { | 8831 | public final void rule__PredicateDefinition__Group__2__Impl() throws RecognitionException { |
7254 | 8832 | ||
7255 | int stackSize = keepStackSize(); | 8833 | int stackSize = keepStackSize(); |
7256 | 8834 | ||
7257 | try { | 8835 | try { |
7258 | // InternalProblem.g:2273:1: ( ( '(' ) ) | 8836 | // InternalProblem.g:2747:1: ( ( '(' ) ) |
7259 | // InternalProblem.g:2274:1: ( '(' ) | 8837 | // InternalProblem.g:2748:1: ( '(' ) |
7260 | { | 8838 | { |
7261 | // InternalProblem.g:2274:1: ( '(' ) | 8839 | // InternalProblem.g:2748:1: ( '(' ) |
7262 | // InternalProblem.g:2275:2: '(' | 8840 | // InternalProblem.g:2749:2: '(' |
7263 | { | 8841 | { |
7264 | before(grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); | 8842 | before(grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); |
7265 | match(input,33,FOLLOW_2); | 8843 | match(input,37,FOLLOW_2); |
7266 | after(grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); | 8844 | after(grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); |
7267 | 8845 | ||
7268 | } | 8846 | } |
@@ -7286,14 +8864,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7286 | 8864 | ||
7287 | 8865 | ||
7288 | // $ANTLR start "rule__PredicateDefinition__Group__3" | 8866 | // $ANTLR start "rule__PredicateDefinition__Group__3" |
7289 | // InternalProblem.g:2284:1: rule__PredicateDefinition__Group__3 : rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 ; | 8867 | // InternalProblem.g:2758:1: rule__PredicateDefinition__Group__3 : rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 ; |
7290 | public final void rule__PredicateDefinition__Group__3() throws RecognitionException { | 8868 | public final void rule__PredicateDefinition__Group__3() throws RecognitionException { |
7291 | 8869 | ||
7292 | int stackSize = keepStackSize(); | 8870 | int stackSize = keepStackSize(); |
7293 | 8871 | ||
7294 | try { | 8872 | try { |
7295 | // InternalProblem.g:2288:1: ( rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 ) | 8873 | // InternalProblem.g:2762:1: ( rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 ) |
7296 | // InternalProblem.g:2289:2: rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 | 8874 | // InternalProblem.g:2763:2: rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 |
7297 | { | 8875 | { |
7298 | pushFollow(FOLLOW_23); | 8876 | pushFollow(FOLLOW_23); |
7299 | rule__PredicateDefinition__Group__3__Impl(); | 8877 | rule__PredicateDefinition__Group__3__Impl(); |
@@ -7324,29 +8902,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7324 | 8902 | ||
7325 | 8903 | ||
7326 | // $ANTLR start "rule__PredicateDefinition__Group__3__Impl" | 8904 | // $ANTLR start "rule__PredicateDefinition__Group__3__Impl" |
7327 | // InternalProblem.g:2296:1: rule__PredicateDefinition__Group__3__Impl : ( ( rule__PredicateDefinition__Group_3__0 )? ) ; | 8905 | // InternalProblem.g:2770:1: rule__PredicateDefinition__Group__3__Impl : ( ( rule__PredicateDefinition__Group_3__0 )? ) ; |
7328 | public final void rule__PredicateDefinition__Group__3__Impl() throws RecognitionException { | 8906 | public final void rule__PredicateDefinition__Group__3__Impl() throws RecognitionException { |
7329 | 8907 | ||
7330 | int stackSize = keepStackSize(); | 8908 | int stackSize = keepStackSize(); |
7331 | 8909 | ||
7332 | try { | 8910 | try { |
7333 | // InternalProblem.g:2300:1: ( ( ( rule__PredicateDefinition__Group_3__0 )? ) ) | 8911 | // InternalProblem.g:2774:1: ( ( ( rule__PredicateDefinition__Group_3__0 )? ) ) |
7334 | // InternalProblem.g:2301:1: ( ( rule__PredicateDefinition__Group_3__0 )? ) | 8912 | // InternalProblem.g:2775:1: ( ( rule__PredicateDefinition__Group_3__0 )? ) |
7335 | { | 8913 | { |
7336 | // InternalProblem.g:2301:1: ( ( rule__PredicateDefinition__Group_3__0 )? ) | 8914 | // InternalProblem.g:2775:1: ( ( rule__PredicateDefinition__Group_3__0 )? ) |
7337 | // InternalProblem.g:2302:2: ( rule__PredicateDefinition__Group_3__0 )? | 8915 | // InternalProblem.g:2776:2: ( rule__PredicateDefinition__Group_3__0 )? |
7338 | { | 8916 | { |
7339 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_3()); | 8917 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_3()); |
7340 | // InternalProblem.g:2303:2: ( rule__PredicateDefinition__Group_3__0 )? | 8918 | // InternalProblem.g:2777:2: ( rule__PredicateDefinition__Group_3__0 )? |
7341 | int alt31=2; | 8919 | int alt37=2; |
7342 | int LA31_0 = input.LA(1); | 8920 | int LA37_0 = input.LA(1); |
7343 | 8921 | ||
7344 | if ( ((LA31_0>=RULE_QUOTED_ID && LA31_0<=RULE_ID)||(LA31_0>=19 && LA31_0<=20)) ) { | 8922 | if ( ((LA37_0>=RULE_QUOTED_ID && LA37_0<=RULE_ID)||(LA37_0>=19 && LA37_0<=22)) ) { |
7345 | alt31=1; | 8923 | alt37=1; |
7346 | } | 8924 | } |
7347 | switch (alt31) { | 8925 | switch (alt37) { |
7348 | case 1 : | 8926 | case 1 : |
7349 | // InternalProblem.g:2303:3: rule__PredicateDefinition__Group_3__0 | 8927 | // InternalProblem.g:2777:3: rule__PredicateDefinition__Group_3__0 |
7350 | { | 8928 | { |
7351 | pushFollow(FOLLOW_2); | 8929 | pushFollow(FOLLOW_2); |
7352 | rule__PredicateDefinition__Group_3__0(); | 8930 | rule__PredicateDefinition__Group_3__0(); |
@@ -7382,14 +8960,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7382 | 8960 | ||
7383 | 8961 | ||
7384 | // $ANTLR start "rule__PredicateDefinition__Group__4" | 8962 | // $ANTLR start "rule__PredicateDefinition__Group__4" |
7385 | // InternalProblem.g:2311:1: rule__PredicateDefinition__Group__4 : rule__PredicateDefinition__Group__4__Impl rule__PredicateDefinition__Group__5 ; | 8963 | // InternalProblem.g:2785:1: rule__PredicateDefinition__Group__4 : rule__PredicateDefinition__Group__4__Impl rule__PredicateDefinition__Group__5 ; |
7386 | public final void rule__PredicateDefinition__Group__4() throws RecognitionException { | 8964 | public final void rule__PredicateDefinition__Group__4() throws RecognitionException { |
7387 | 8965 | ||
7388 | int stackSize = keepStackSize(); | 8966 | int stackSize = keepStackSize(); |
7389 | 8967 | ||
7390 | try { | 8968 | try { |
7391 | // InternalProblem.g:2315:1: ( rule__PredicateDefinition__Group__4__Impl rule__PredicateDefinition__Group__5 ) | 8969 | // InternalProblem.g:2789:1: ( rule__PredicateDefinition__Group__4__Impl rule__PredicateDefinition__Group__5 ) |
7392 | // InternalProblem.g:2316:2: rule__PredicateDefinition__Group__4__Impl rule__PredicateDefinition__Group__5 | 8970 | // InternalProblem.g:2790:2: rule__PredicateDefinition__Group__4__Impl rule__PredicateDefinition__Group__5 |
7393 | { | 8971 | { |
7394 | pushFollow(FOLLOW_24); | 8972 | pushFollow(FOLLOW_24); |
7395 | rule__PredicateDefinition__Group__4__Impl(); | 8973 | rule__PredicateDefinition__Group__4__Impl(); |
@@ -7420,20 +8998,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7420 | 8998 | ||
7421 | 8999 | ||
7422 | // $ANTLR start "rule__PredicateDefinition__Group__4__Impl" | 9000 | // $ANTLR start "rule__PredicateDefinition__Group__4__Impl" |
7423 | // InternalProblem.g:2323:1: rule__PredicateDefinition__Group__4__Impl : ( ')' ) ; | 9001 | // InternalProblem.g:2797:1: rule__PredicateDefinition__Group__4__Impl : ( ')' ) ; |
7424 | public final void rule__PredicateDefinition__Group__4__Impl() throws RecognitionException { | 9002 | public final void rule__PredicateDefinition__Group__4__Impl() throws RecognitionException { |
7425 | 9003 | ||
7426 | int stackSize = keepStackSize(); | 9004 | int stackSize = keepStackSize(); |
7427 | 9005 | ||
7428 | try { | 9006 | try { |
7429 | // InternalProblem.g:2327:1: ( ( ')' ) ) | 9007 | // InternalProblem.g:2801:1: ( ( ')' ) ) |
7430 | // InternalProblem.g:2328:1: ( ')' ) | 9008 | // InternalProblem.g:2802:1: ( ')' ) |
7431 | { | 9009 | { |
7432 | // InternalProblem.g:2328:1: ( ')' ) | 9010 | // InternalProblem.g:2802:1: ( ')' ) |
7433 | // InternalProblem.g:2329:2: ')' | 9011 | // InternalProblem.g:2803:2: ')' |
7434 | { | 9012 | { |
7435 | before(grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); | 9013 | before(grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); |
7436 | match(input,34,FOLLOW_2); | 9014 | match(input,38,FOLLOW_2); |
7437 | after(grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); | 9015 | after(grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); |
7438 | 9016 | ||
7439 | } | 9017 | } |
@@ -7457,14 +9035,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7457 | 9035 | ||
7458 | 9036 | ||
7459 | // $ANTLR start "rule__PredicateDefinition__Group__5" | 9037 | // $ANTLR start "rule__PredicateDefinition__Group__5" |
7460 | // InternalProblem.g:2338:1: rule__PredicateDefinition__Group__5 : rule__PredicateDefinition__Group__5__Impl rule__PredicateDefinition__Group__6 ; | 9038 | // InternalProblem.g:2812:1: rule__PredicateDefinition__Group__5 : rule__PredicateDefinition__Group__5__Impl rule__PredicateDefinition__Group__6 ; |
7461 | public final void rule__PredicateDefinition__Group__5() throws RecognitionException { | 9039 | public final void rule__PredicateDefinition__Group__5() throws RecognitionException { |
7462 | 9040 | ||
7463 | int stackSize = keepStackSize(); | 9041 | int stackSize = keepStackSize(); |
7464 | 9042 | ||
7465 | try { | 9043 | try { |
7466 | // InternalProblem.g:2342:1: ( rule__PredicateDefinition__Group__5__Impl rule__PredicateDefinition__Group__6 ) | 9044 | // InternalProblem.g:2816:1: ( rule__PredicateDefinition__Group__5__Impl rule__PredicateDefinition__Group__6 ) |
7467 | // InternalProblem.g:2343:2: rule__PredicateDefinition__Group__5__Impl rule__PredicateDefinition__Group__6 | 9045 | // InternalProblem.g:2817:2: rule__PredicateDefinition__Group__5__Impl rule__PredicateDefinition__Group__6 |
7468 | { | 9046 | { |
7469 | pushFollow(FOLLOW_24); | 9047 | pushFollow(FOLLOW_24); |
7470 | rule__PredicateDefinition__Group__5__Impl(); | 9048 | rule__PredicateDefinition__Group__5__Impl(); |
@@ -7495,29 +9073,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7495 | 9073 | ||
7496 | 9074 | ||
7497 | // $ANTLR start "rule__PredicateDefinition__Group__5__Impl" | 9075 | // $ANTLR start "rule__PredicateDefinition__Group__5__Impl" |
7498 | // InternalProblem.g:2350:1: rule__PredicateDefinition__Group__5__Impl : ( ( rule__PredicateDefinition__Group_5__0 )? ) ; | 9076 | // InternalProblem.g:2824:1: rule__PredicateDefinition__Group__5__Impl : ( ( rule__PredicateDefinition__Group_5__0 )? ) ; |
7499 | public final void rule__PredicateDefinition__Group__5__Impl() throws RecognitionException { | 9077 | public final void rule__PredicateDefinition__Group__5__Impl() throws RecognitionException { |
7500 | 9078 | ||
7501 | int stackSize = keepStackSize(); | 9079 | int stackSize = keepStackSize(); |
7502 | 9080 | ||
7503 | try { | 9081 | try { |
7504 | // InternalProblem.g:2354:1: ( ( ( rule__PredicateDefinition__Group_5__0 )? ) ) | 9082 | // InternalProblem.g:2828:1: ( ( ( rule__PredicateDefinition__Group_5__0 )? ) ) |
7505 | // InternalProblem.g:2355:1: ( ( rule__PredicateDefinition__Group_5__0 )? ) | 9083 | // InternalProblem.g:2829:1: ( ( rule__PredicateDefinition__Group_5__0 )? ) |
7506 | { | 9084 | { |
7507 | // InternalProblem.g:2355:1: ( ( rule__PredicateDefinition__Group_5__0 )? ) | 9085 | // InternalProblem.g:2829:1: ( ( rule__PredicateDefinition__Group_5__0 )? ) |
7508 | // InternalProblem.g:2356:2: ( rule__PredicateDefinition__Group_5__0 )? | 9086 | // InternalProblem.g:2830:2: ( rule__PredicateDefinition__Group_5__0 )? |
7509 | { | 9087 | { |
7510 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_5()); | 9088 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_5()); |
7511 | // InternalProblem.g:2357:2: ( rule__PredicateDefinition__Group_5__0 )? | 9089 | // InternalProblem.g:2831:2: ( rule__PredicateDefinition__Group_5__0 )? |
7512 | int alt32=2; | 9090 | int alt38=2; |
7513 | int LA32_0 = input.LA(1); | 9091 | int LA38_0 = input.LA(1); |
7514 | 9092 | ||
7515 | if ( (LA32_0==35) ) { | 9093 | if ( (LA38_0==39) ) { |
7516 | alt32=1; | 9094 | alt38=1; |
7517 | } | 9095 | } |
7518 | switch (alt32) { | 9096 | switch (alt38) { |
7519 | case 1 : | 9097 | case 1 : |
7520 | // InternalProblem.g:2357:3: rule__PredicateDefinition__Group_5__0 | 9098 | // InternalProblem.g:2831:3: rule__PredicateDefinition__Group_5__0 |
7521 | { | 9099 | { |
7522 | pushFollow(FOLLOW_2); | 9100 | pushFollow(FOLLOW_2); |
7523 | rule__PredicateDefinition__Group_5__0(); | 9101 | rule__PredicateDefinition__Group_5__0(); |
@@ -7553,14 +9131,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7553 | 9131 | ||
7554 | 9132 | ||
7555 | // $ANTLR start "rule__PredicateDefinition__Group__6" | 9133 | // $ANTLR start "rule__PredicateDefinition__Group__6" |
7556 | // InternalProblem.g:2365:1: rule__PredicateDefinition__Group__6 : rule__PredicateDefinition__Group__6__Impl ; | 9134 | // InternalProblem.g:2839:1: rule__PredicateDefinition__Group__6 : rule__PredicateDefinition__Group__6__Impl ; |
7557 | public final void rule__PredicateDefinition__Group__6() throws RecognitionException { | 9135 | public final void rule__PredicateDefinition__Group__6() throws RecognitionException { |
7558 | 9136 | ||
7559 | int stackSize = keepStackSize(); | 9137 | int stackSize = keepStackSize(); |
7560 | 9138 | ||
7561 | try { | 9139 | try { |
7562 | // InternalProblem.g:2369:1: ( rule__PredicateDefinition__Group__6__Impl ) | 9140 | // InternalProblem.g:2843:1: ( rule__PredicateDefinition__Group__6__Impl ) |
7563 | // InternalProblem.g:2370:2: rule__PredicateDefinition__Group__6__Impl | 9141 | // InternalProblem.g:2844:2: rule__PredicateDefinition__Group__6__Impl |
7564 | { | 9142 | { |
7565 | pushFollow(FOLLOW_2); | 9143 | pushFollow(FOLLOW_2); |
7566 | rule__PredicateDefinition__Group__6__Impl(); | 9144 | rule__PredicateDefinition__Group__6__Impl(); |
@@ -7586,17 +9164,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7586 | 9164 | ||
7587 | 9165 | ||
7588 | // $ANTLR start "rule__PredicateDefinition__Group__6__Impl" | 9166 | // $ANTLR start "rule__PredicateDefinition__Group__6__Impl" |
7589 | // InternalProblem.g:2376:1: rule__PredicateDefinition__Group__6__Impl : ( '.' ) ; | 9167 | // InternalProblem.g:2850:1: rule__PredicateDefinition__Group__6__Impl : ( '.' ) ; |
7590 | public final void rule__PredicateDefinition__Group__6__Impl() throws RecognitionException { | 9168 | public final void rule__PredicateDefinition__Group__6__Impl() throws RecognitionException { |
7591 | 9169 | ||
7592 | int stackSize = keepStackSize(); | 9170 | int stackSize = keepStackSize(); |
7593 | 9171 | ||
7594 | try { | 9172 | try { |
7595 | // InternalProblem.g:2380:1: ( ( '.' ) ) | 9173 | // InternalProblem.g:2854:1: ( ( '.' ) ) |
7596 | // InternalProblem.g:2381:1: ( '.' ) | 9174 | // InternalProblem.g:2855:1: ( '.' ) |
7597 | { | 9175 | { |
7598 | // InternalProblem.g:2381:1: ( '.' ) | 9176 | // InternalProblem.g:2855:1: ( '.' ) |
7599 | // InternalProblem.g:2382:2: '.' | 9177 | // InternalProblem.g:2856:2: '.' |
7600 | { | 9178 | { |
7601 | before(grammarAccess.getPredicateDefinitionAccess().getFullStopKeyword_6()); | 9179 | before(grammarAccess.getPredicateDefinitionAccess().getFullStopKeyword_6()); |
7602 | match(input,12,FOLLOW_2); | 9180 | match(input,12,FOLLOW_2); |
@@ -7623,14 +9201,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7623 | 9201 | ||
7624 | 9202 | ||
7625 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__0" | 9203 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__0" |
7626 | // InternalProblem.g:2392:1: rule__PredicateDefinition__Group_0_0__0 : rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ; | 9204 | // InternalProblem.g:2866:1: rule__PredicateDefinition__Group_0_0__0 : rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ; |
7627 | public final void rule__PredicateDefinition__Group_0_0__0() throws RecognitionException { | 9205 | public final void rule__PredicateDefinition__Group_0_0__0() throws RecognitionException { |
7628 | 9206 | ||
7629 | int stackSize = keepStackSize(); | 9207 | int stackSize = keepStackSize(); |
7630 | 9208 | ||
7631 | try { | 9209 | try { |
7632 | // InternalProblem.g:2396:1: ( rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ) | 9210 | // InternalProblem.g:2870:1: ( rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ) |
7633 | // InternalProblem.g:2397:2: rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 | 9211 | // InternalProblem.g:2871:2: rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 |
7634 | { | 9212 | { |
7635 | pushFollow(FOLLOW_25); | 9213 | pushFollow(FOLLOW_25); |
7636 | rule__PredicateDefinition__Group_0_0__0__Impl(); | 9214 | rule__PredicateDefinition__Group_0_0__0__Impl(); |
@@ -7661,21 +9239,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7661 | 9239 | ||
7662 | 9240 | ||
7663 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__0__Impl" | 9241 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__0__Impl" |
7664 | // InternalProblem.g:2404:1: rule__PredicateDefinition__Group_0_0__0__Impl : ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) ; | 9242 | // InternalProblem.g:2878:1: rule__PredicateDefinition__Group_0_0__0__Impl : ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) ; |
7665 | public final void rule__PredicateDefinition__Group_0_0__0__Impl() throws RecognitionException { | 9243 | public final void rule__PredicateDefinition__Group_0_0__0__Impl() throws RecognitionException { |
7666 | 9244 | ||
7667 | int stackSize = keepStackSize(); | 9245 | int stackSize = keepStackSize(); |
7668 | 9246 | ||
7669 | try { | 9247 | try { |
7670 | // InternalProblem.g:2408:1: ( ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) ) | 9248 | // InternalProblem.g:2882:1: ( ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) ) |
7671 | // InternalProblem.g:2409:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) | 9249 | // InternalProblem.g:2883:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) |
7672 | { | 9250 | { |
7673 | // InternalProblem.g:2409:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) | 9251 | // InternalProblem.g:2883:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) |
7674 | // InternalProblem.g:2410:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) | 9252 | // InternalProblem.g:2884:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) |
7675 | { | 9253 | { |
7676 | before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_0()); | 9254 | before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_0()); |
7677 | // InternalProblem.g:2411:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) | 9255 | // InternalProblem.g:2885:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) |
7678 | // InternalProblem.g:2411:3: rule__PredicateDefinition__ErrorAssignment_0_0_0 | 9256 | // InternalProblem.g:2885:3: rule__PredicateDefinition__ErrorAssignment_0_0_0 |
7679 | { | 9257 | { |
7680 | pushFollow(FOLLOW_2); | 9258 | pushFollow(FOLLOW_2); |
7681 | rule__PredicateDefinition__ErrorAssignment_0_0_0(); | 9259 | rule__PredicateDefinition__ErrorAssignment_0_0_0(); |
@@ -7708,14 +9286,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7708 | 9286 | ||
7709 | 9287 | ||
7710 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__1" | 9288 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__1" |
7711 | // InternalProblem.g:2419:1: rule__PredicateDefinition__Group_0_0__1 : rule__PredicateDefinition__Group_0_0__1__Impl ; | 9289 | // InternalProblem.g:2893:1: rule__PredicateDefinition__Group_0_0__1 : rule__PredicateDefinition__Group_0_0__1__Impl ; |
7712 | public final void rule__PredicateDefinition__Group_0_0__1() throws RecognitionException { | 9290 | public final void rule__PredicateDefinition__Group_0_0__1() throws RecognitionException { |
7713 | 9291 | ||
7714 | int stackSize = keepStackSize(); | 9292 | int stackSize = keepStackSize(); |
7715 | 9293 | ||
7716 | try { | 9294 | try { |
7717 | // InternalProblem.g:2423:1: ( rule__PredicateDefinition__Group_0_0__1__Impl ) | 9295 | // InternalProblem.g:2897:1: ( rule__PredicateDefinition__Group_0_0__1__Impl ) |
7718 | // InternalProblem.g:2424:2: rule__PredicateDefinition__Group_0_0__1__Impl | 9296 | // InternalProblem.g:2898:2: rule__PredicateDefinition__Group_0_0__1__Impl |
7719 | { | 9297 | { |
7720 | pushFollow(FOLLOW_2); | 9298 | pushFollow(FOLLOW_2); |
7721 | rule__PredicateDefinition__Group_0_0__1__Impl(); | 9299 | rule__PredicateDefinition__Group_0_0__1__Impl(); |
@@ -7741,29 +9319,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7741 | 9319 | ||
7742 | 9320 | ||
7743 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__1__Impl" | 9321 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__1__Impl" |
7744 | // InternalProblem.g:2430:1: rule__PredicateDefinition__Group_0_0__1__Impl : ( ( 'pred' )? ) ; | 9322 | // InternalProblem.g:2904:1: rule__PredicateDefinition__Group_0_0__1__Impl : ( ( 'pred' )? ) ; |
7745 | public final void rule__PredicateDefinition__Group_0_0__1__Impl() throws RecognitionException { | 9323 | public final void rule__PredicateDefinition__Group_0_0__1__Impl() throws RecognitionException { |
7746 | 9324 | ||
7747 | int stackSize = keepStackSize(); | 9325 | int stackSize = keepStackSize(); |
7748 | 9326 | ||
7749 | try { | 9327 | try { |
7750 | // InternalProblem.g:2434:1: ( ( ( 'pred' )? ) ) | 9328 | // InternalProblem.g:2908:1: ( ( ( 'pred' )? ) ) |
7751 | // InternalProblem.g:2435:1: ( ( 'pred' )? ) | 9329 | // InternalProblem.g:2909:1: ( ( 'pred' )? ) |
7752 | { | 9330 | { |
7753 | // InternalProblem.g:2435:1: ( ( 'pred' )? ) | 9331 | // InternalProblem.g:2909:1: ( ( 'pred' )? ) |
7754 | // InternalProblem.g:2436:2: ( 'pred' )? | 9332 | // InternalProblem.g:2910:2: ( 'pred' )? |
7755 | { | 9333 | { |
7756 | before(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); | 9334 | before(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); |
7757 | // InternalProblem.g:2437:2: ( 'pred' )? | 9335 | // InternalProblem.g:2911:2: ( 'pred' )? |
7758 | int alt33=2; | 9336 | int alt39=2; |
7759 | int LA33_0 = input.LA(1); | 9337 | int LA39_0 = input.LA(1); |
7760 | 9338 | ||
7761 | if ( (LA33_0==16) ) { | 9339 | if ( (LA39_0==16) ) { |
7762 | alt33=1; | 9340 | alt39=1; |
7763 | } | 9341 | } |
7764 | switch (alt33) { | 9342 | switch (alt39) { |
7765 | case 1 : | 9343 | case 1 : |
7766 | // InternalProblem.g:2437:3: 'pred' | 9344 | // InternalProblem.g:2911:3: 'pred' |
7767 | { | 9345 | { |
7768 | match(input,16,FOLLOW_2); | 9346 | match(input,16,FOLLOW_2); |
7769 | 9347 | ||
@@ -7795,14 +9373,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7795 | 9373 | ||
7796 | 9374 | ||
7797 | // $ANTLR start "rule__PredicateDefinition__Group_3__0" | 9375 | // $ANTLR start "rule__PredicateDefinition__Group_3__0" |
7798 | // InternalProblem.g:2446:1: rule__PredicateDefinition__Group_3__0 : rule__PredicateDefinition__Group_3__0__Impl rule__PredicateDefinition__Group_3__1 ; | 9376 | // InternalProblem.g:2920:1: rule__PredicateDefinition__Group_3__0 : rule__PredicateDefinition__Group_3__0__Impl rule__PredicateDefinition__Group_3__1 ; |
7799 | public final void rule__PredicateDefinition__Group_3__0() throws RecognitionException { | 9377 | public final void rule__PredicateDefinition__Group_3__0() throws RecognitionException { |
7800 | 9378 | ||
7801 | int stackSize = keepStackSize(); | 9379 | int stackSize = keepStackSize(); |
7802 | 9380 | ||
7803 | try { | 9381 | try { |
7804 | // InternalProblem.g:2450:1: ( rule__PredicateDefinition__Group_3__0__Impl rule__PredicateDefinition__Group_3__1 ) | 9382 | // InternalProblem.g:2924:1: ( rule__PredicateDefinition__Group_3__0__Impl rule__PredicateDefinition__Group_3__1 ) |
7805 | // InternalProblem.g:2451:2: rule__PredicateDefinition__Group_3__0__Impl rule__PredicateDefinition__Group_3__1 | 9383 | // InternalProblem.g:2925:2: rule__PredicateDefinition__Group_3__0__Impl rule__PredicateDefinition__Group_3__1 |
7806 | { | 9384 | { |
7807 | pushFollow(FOLLOW_9); | 9385 | pushFollow(FOLLOW_9); |
7808 | rule__PredicateDefinition__Group_3__0__Impl(); | 9386 | rule__PredicateDefinition__Group_3__0__Impl(); |
@@ -7833,21 +9411,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7833 | 9411 | ||
7834 | 9412 | ||
7835 | // $ANTLR start "rule__PredicateDefinition__Group_3__0__Impl" | 9413 | // $ANTLR start "rule__PredicateDefinition__Group_3__0__Impl" |
7836 | // InternalProblem.g:2458:1: rule__PredicateDefinition__Group_3__0__Impl : ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) ; | 9414 | // InternalProblem.g:2932:1: rule__PredicateDefinition__Group_3__0__Impl : ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) ; |
7837 | public final void rule__PredicateDefinition__Group_3__0__Impl() throws RecognitionException { | 9415 | public final void rule__PredicateDefinition__Group_3__0__Impl() throws RecognitionException { |
7838 | 9416 | ||
7839 | int stackSize = keepStackSize(); | 9417 | int stackSize = keepStackSize(); |
7840 | 9418 | ||
7841 | try { | 9419 | try { |
7842 | // InternalProblem.g:2462:1: ( ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) ) | 9420 | // InternalProblem.g:2936:1: ( ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) ) |
7843 | // InternalProblem.g:2463:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) | 9421 | // InternalProblem.g:2937:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) |
7844 | { | 9422 | { |
7845 | // InternalProblem.g:2463:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) | 9423 | // InternalProblem.g:2937:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) |
7846 | // InternalProblem.g:2464:2: ( rule__PredicateDefinition__ParametersAssignment_3_0 ) | 9424 | // InternalProblem.g:2938:2: ( rule__PredicateDefinition__ParametersAssignment_3_0 ) |
7847 | { | 9425 | { |
7848 | before(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_0()); | 9426 | before(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_0()); |
7849 | // InternalProblem.g:2465:2: ( rule__PredicateDefinition__ParametersAssignment_3_0 ) | 9427 | // InternalProblem.g:2939:2: ( rule__PredicateDefinition__ParametersAssignment_3_0 ) |
7850 | // InternalProblem.g:2465:3: rule__PredicateDefinition__ParametersAssignment_3_0 | 9428 | // InternalProblem.g:2939:3: rule__PredicateDefinition__ParametersAssignment_3_0 |
7851 | { | 9429 | { |
7852 | pushFollow(FOLLOW_2); | 9430 | pushFollow(FOLLOW_2); |
7853 | rule__PredicateDefinition__ParametersAssignment_3_0(); | 9431 | rule__PredicateDefinition__ParametersAssignment_3_0(); |
@@ -7880,14 +9458,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7880 | 9458 | ||
7881 | 9459 | ||
7882 | // $ANTLR start "rule__PredicateDefinition__Group_3__1" | 9460 | // $ANTLR start "rule__PredicateDefinition__Group_3__1" |
7883 | // InternalProblem.g:2473:1: rule__PredicateDefinition__Group_3__1 : rule__PredicateDefinition__Group_3__1__Impl ; | 9461 | // InternalProblem.g:2947:1: rule__PredicateDefinition__Group_3__1 : rule__PredicateDefinition__Group_3__1__Impl ; |
7884 | public final void rule__PredicateDefinition__Group_3__1() throws RecognitionException { | 9462 | public final void rule__PredicateDefinition__Group_3__1() throws RecognitionException { |
7885 | 9463 | ||
7886 | int stackSize = keepStackSize(); | 9464 | int stackSize = keepStackSize(); |
7887 | 9465 | ||
7888 | try { | 9466 | try { |
7889 | // InternalProblem.g:2477:1: ( rule__PredicateDefinition__Group_3__1__Impl ) | 9467 | // InternalProblem.g:2951:1: ( rule__PredicateDefinition__Group_3__1__Impl ) |
7890 | // InternalProblem.g:2478:2: rule__PredicateDefinition__Group_3__1__Impl | 9468 | // InternalProblem.g:2952:2: rule__PredicateDefinition__Group_3__1__Impl |
7891 | { | 9469 | { |
7892 | pushFollow(FOLLOW_2); | 9470 | pushFollow(FOLLOW_2); |
7893 | rule__PredicateDefinition__Group_3__1__Impl(); | 9471 | rule__PredicateDefinition__Group_3__1__Impl(); |
@@ -7913,33 +9491,33 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7913 | 9491 | ||
7914 | 9492 | ||
7915 | // $ANTLR start "rule__PredicateDefinition__Group_3__1__Impl" | 9493 | // $ANTLR start "rule__PredicateDefinition__Group_3__1__Impl" |
7916 | // InternalProblem.g:2484:1: rule__PredicateDefinition__Group_3__1__Impl : ( ( rule__PredicateDefinition__Group_3_1__0 )* ) ; | 9494 | // InternalProblem.g:2958:1: rule__PredicateDefinition__Group_3__1__Impl : ( ( rule__PredicateDefinition__Group_3_1__0 )* ) ; |
7917 | public final void rule__PredicateDefinition__Group_3__1__Impl() throws RecognitionException { | 9495 | public final void rule__PredicateDefinition__Group_3__1__Impl() throws RecognitionException { |
7918 | 9496 | ||
7919 | int stackSize = keepStackSize(); | 9497 | int stackSize = keepStackSize(); |
7920 | 9498 | ||
7921 | try { | 9499 | try { |
7922 | // InternalProblem.g:2488:1: ( ( ( rule__PredicateDefinition__Group_3_1__0 )* ) ) | 9500 | // InternalProblem.g:2962:1: ( ( ( rule__PredicateDefinition__Group_3_1__0 )* ) ) |
7923 | // InternalProblem.g:2489:1: ( ( rule__PredicateDefinition__Group_3_1__0 )* ) | 9501 | // InternalProblem.g:2963:1: ( ( rule__PredicateDefinition__Group_3_1__0 )* ) |
7924 | { | 9502 | { |
7925 | // InternalProblem.g:2489:1: ( ( rule__PredicateDefinition__Group_3_1__0 )* ) | 9503 | // InternalProblem.g:2963:1: ( ( rule__PredicateDefinition__Group_3_1__0 )* ) |
7926 | // InternalProblem.g:2490:2: ( rule__PredicateDefinition__Group_3_1__0 )* | 9504 | // InternalProblem.g:2964:2: ( rule__PredicateDefinition__Group_3_1__0 )* |
7927 | { | 9505 | { |
7928 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_3_1()); | 9506 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_3_1()); |
7929 | // InternalProblem.g:2491:2: ( rule__PredicateDefinition__Group_3_1__0 )* | 9507 | // InternalProblem.g:2965:2: ( rule__PredicateDefinition__Group_3_1__0 )* |
7930 | loop34: | 9508 | loop40: |
7931 | do { | 9509 | do { |
7932 | int alt34=2; | 9510 | int alt40=2; |
7933 | int LA34_0 = input.LA(1); | 9511 | int LA40_0 = input.LA(1); |
7934 | 9512 | ||
7935 | if ( (LA34_0==13) ) { | 9513 | if ( (LA40_0==13) ) { |
7936 | alt34=1; | 9514 | alt40=1; |
7937 | } | 9515 | } |
7938 | 9516 | ||
7939 | 9517 | ||
7940 | switch (alt34) { | 9518 | switch (alt40) { |
7941 | case 1 : | 9519 | case 1 : |
7942 | // InternalProblem.g:2491:3: rule__PredicateDefinition__Group_3_1__0 | 9520 | // InternalProblem.g:2965:3: rule__PredicateDefinition__Group_3_1__0 |
7943 | { | 9521 | { |
7944 | pushFollow(FOLLOW_10); | 9522 | pushFollow(FOLLOW_10); |
7945 | rule__PredicateDefinition__Group_3_1__0(); | 9523 | rule__PredicateDefinition__Group_3_1__0(); |
@@ -7951,7 +9529,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7951 | break; | 9529 | break; |
7952 | 9530 | ||
7953 | default : | 9531 | default : |
7954 | break loop34; | 9532 | break loop40; |
7955 | } | 9533 | } |
7956 | } while (true); | 9534 | } while (true); |
7957 | 9535 | ||
@@ -7978,14 +9556,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
7978 | 9556 | ||
7979 | 9557 | ||
7980 | // $ANTLR start "rule__PredicateDefinition__Group_3_1__0" | 9558 | // $ANTLR start "rule__PredicateDefinition__Group_3_1__0" |
7981 | // InternalProblem.g:2500:1: rule__PredicateDefinition__Group_3_1__0 : rule__PredicateDefinition__Group_3_1__0__Impl rule__PredicateDefinition__Group_3_1__1 ; | 9559 | // InternalProblem.g:2974:1: rule__PredicateDefinition__Group_3_1__0 : rule__PredicateDefinition__Group_3_1__0__Impl rule__PredicateDefinition__Group_3_1__1 ; |
7982 | public final void rule__PredicateDefinition__Group_3_1__0() throws RecognitionException { | 9560 | public final void rule__PredicateDefinition__Group_3_1__0() throws RecognitionException { |
7983 | 9561 | ||
7984 | int stackSize = keepStackSize(); | 9562 | int stackSize = keepStackSize(); |
7985 | 9563 | ||
7986 | try { | 9564 | try { |
7987 | // InternalProblem.g:2504:1: ( rule__PredicateDefinition__Group_3_1__0__Impl rule__PredicateDefinition__Group_3_1__1 ) | 9565 | // InternalProblem.g:2978:1: ( rule__PredicateDefinition__Group_3_1__0__Impl rule__PredicateDefinition__Group_3_1__1 ) |
7988 | // InternalProblem.g:2505:2: rule__PredicateDefinition__Group_3_1__0__Impl rule__PredicateDefinition__Group_3_1__1 | 9566 | // InternalProblem.g:2979:2: rule__PredicateDefinition__Group_3_1__0__Impl rule__PredicateDefinition__Group_3_1__1 |
7989 | { | 9567 | { |
7990 | pushFollow(FOLLOW_5); | 9568 | pushFollow(FOLLOW_5); |
7991 | rule__PredicateDefinition__Group_3_1__0__Impl(); | 9569 | rule__PredicateDefinition__Group_3_1__0__Impl(); |
@@ -8016,17 +9594,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8016 | 9594 | ||
8017 | 9595 | ||
8018 | // $ANTLR start "rule__PredicateDefinition__Group_3_1__0__Impl" | 9596 | // $ANTLR start "rule__PredicateDefinition__Group_3_1__0__Impl" |
8019 | // InternalProblem.g:2512:1: rule__PredicateDefinition__Group_3_1__0__Impl : ( ',' ) ; | 9597 | // InternalProblem.g:2986:1: rule__PredicateDefinition__Group_3_1__0__Impl : ( ',' ) ; |
8020 | public final void rule__PredicateDefinition__Group_3_1__0__Impl() throws RecognitionException { | 9598 | public final void rule__PredicateDefinition__Group_3_1__0__Impl() throws RecognitionException { |
8021 | 9599 | ||
8022 | int stackSize = keepStackSize(); | 9600 | int stackSize = keepStackSize(); |
8023 | 9601 | ||
8024 | try { | 9602 | try { |
8025 | // InternalProblem.g:2516:1: ( ( ',' ) ) | 9603 | // InternalProblem.g:2990:1: ( ( ',' ) ) |
8026 | // InternalProblem.g:2517:1: ( ',' ) | 9604 | // InternalProblem.g:2991:1: ( ',' ) |
8027 | { | 9605 | { |
8028 | // InternalProblem.g:2517:1: ( ',' ) | 9606 | // InternalProblem.g:2991:1: ( ',' ) |
8029 | // InternalProblem.g:2518:2: ',' | 9607 | // InternalProblem.g:2992:2: ',' |
8030 | { | 9608 | { |
8031 | before(grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); | 9609 | before(grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); |
8032 | match(input,13,FOLLOW_2); | 9610 | match(input,13,FOLLOW_2); |
@@ -8053,14 +9631,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8053 | 9631 | ||
8054 | 9632 | ||
8055 | // $ANTLR start "rule__PredicateDefinition__Group_3_1__1" | 9633 | // $ANTLR start "rule__PredicateDefinition__Group_3_1__1" |
8056 | // InternalProblem.g:2527:1: rule__PredicateDefinition__Group_3_1__1 : rule__PredicateDefinition__Group_3_1__1__Impl ; | 9634 | // InternalProblem.g:3001:1: rule__PredicateDefinition__Group_3_1__1 : rule__PredicateDefinition__Group_3_1__1__Impl ; |
8057 | public final void rule__PredicateDefinition__Group_3_1__1() throws RecognitionException { | 9635 | public final void rule__PredicateDefinition__Group_3_1__1() throws RecognitionException { |
8058 | 9636 | ||
8059 | int stackSize = keepStackSize(); | 9637 | int stackSize = keepStackSize(); |
8060 | 9638 | ||
8061 | try { | 9639 | try { |
8062 | // InternalProblem.g:2531:1: ( rule__PredicateDefinition__Group_3_1__1__Impl ) | 9640 | // InternalProblem.g:3005:1: ( rule__PredicateDefinition__Group_3_1__1__Impl ) |
8063 | // InternalProblem.g:2532:2: rule__PredicateDefinition__Group_3_1__1__Impl | 9641 | // InternalProblem.g:3006:2: rule__PredicateDefinition__Group_3_1__1__Impl |
8064 | { | 9642 | { |
8065 | pushFollow(FOLLOW_2); | 9643 | pushFollow(FOLLOW_2); |
8066 | rule__PredicateDefinition__Group_3_1__1__Impl(); | 9644 | rule__PredicateDefinition__Group_3_1__1__Impl(); |
@@ -8086,21 +9664,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8086 | 9664 | ||
8087 | 9665 | ||
8088 | // $ANTLR start "rule__PredicateDefinition__Group_3_1__1__Impl" | 9666 | // $ANTLR start "rule__PredicateDefinition__Group_3_1__1__Impl" |
8089 | // InternalProblem.g:2538:1: rule__PredicateDefinition__Group_3_1__1__Impl : ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) ; | 9667 | // InternalProblem.g:3012:1: rule__PredicateDefinition__Group_3_1__1__Impl : ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) ; |
8090 | public final void rule__PredicateDefinition__Group_3_1__1__Impl() throws RecognitionException { | 9668 | public final void rule__PredicateDefinition__Group_3_1__1__Impl() throws RecognitionException { |
8091 | 9669 | ||
8092 | int stackSize = keepStackSize(); | 9670 | int stackSize = keepStackSize(); |
8093 | 9671 | ||
8094 | try { | 9672 | try { |
8095 | // InternalProblem.g:2542:1: ( ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) ) | 9673 | // InternalProblem.g:3016:1: ( ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) ) |
8096 | // InternalProblem.g:2543:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) | 9674 | // InternalProblem.g:3017:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) |
8097 | { | 9675 | { |
8098 | // InternalProblem.g:2543:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) | 9676 | // InternalProblem.g:3017:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) |
8099 | // InternalProblem.g:2544:2: ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) | 9677 | // InternalProblem.g:3018:2: ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) |
8100 | { | 9678 | { |
8101 | before(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_1_1()); | 9679 | before(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_1_1()); |
8102 | // InternalProblem.g:2545:2: ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) | 9680 | // InternalProblem.g:3019:2: ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) |
8103 | // InternalProblem.g:2545:3: rule__PredicateDefinition__ParametersAssignment_3_1_1 | 9681 | // InternalProblem.g:3019:3: rule__PredicateDefinition__ParametersAssignment_3_1_1 |
8104 | { | 9682 | { |
8105 | pushFollow(FOLLOW_2); | 9683 | pushFollow(FOLLOW_2); |
8106 | rule__PredicateDefinition__ParametersAssignment_3_1_1(); | 9684 | rule__PredicateDefinition__ParametersAssignment_3_1_1(); |
@@ -8133,14 +9711,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8133 | 9711 | ||
8134 | 9712 | ||
8135 | // $ANTLR start "rule__PredicateDefinition__Group_5__0" | 9713 | // $ANTLR start "rule__PredicateDefinition__Group_5__0" |
8136 | // InternalProblem.g:2554:1: rule__PredicateDefinition__Group_5__0 : rule__PredicateDefinition__Group_5__0__Impl rule__PredicateDefinition__Group_5__1 ; | 9714 | // InternalProblem.g:3028:1: rule__PredicateDefinition__Group_5__0 : rule__PredicateDefinition__Group_5__0__Impl rule__PredicateDefinition__Group_5__1 ; |
8137 | public final void rule__PredicateDefinition__Group_5__0() throws RecognitionException { | 9715 | public final void rule__PredicateDefinition__Group_5__0() throws RecognitionException { |
8138 | 9716 | ||
8139 | int stackSize = keepStackSize(); | 9717 | int stackSize = keepStackSize(); |
8140 | 9718 | ||
8141 | try { | 9719 | try { |
8142 | // InternalProblem.g:2558:1: ( rule__PredicateDefinition__Group_5__0__Impl rule__PredicateDefinition__Group_5__1 ) | 9720 | // InternalProblem.g:3032:1: ( rule__PredicateDefinition__Group_5__0__Impl rule__PredicateDefinition__Group_5__1 ) |
8143 | // InternalProblem.g:2559:2: rule__PredicateDefinition__Group_5__0__Impl rule__PredicateDefinition__Group_5__1 | 9721 | // InternalProblem.g:3033:2: rule__PredicateDefinition__Group_5__0__Impl rule__PredicateDefinition__Group_5__1 |
8144 | { | 9722 | { |
8145 | pushFollow(FOLLOW_26); | 9723 | pushFollow(FOLLOW_26); |
8146 | rule__PredicateDefinition__Group_5__0__Impl(); | 9724 | rule__PredicateDefinition__Group_5__0__Impl(); |
@@ -8171,20 +9749,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8171 | 9749 | ||
8172 | 9750 | ||
8173 | // $ANTLR start "rule__PredicateDefinition__Group_5__0__Impl" | 9751 | // $ANTLR start "rule__PredicateDefinition__Group_5__0__Impl" |
8174 | // InternalProblem.g:2566:1: rule__PredicateDefinition__Group_5__0__Impl : ( ':-' ) ; | 9752 | // InternalProblem.g:3040:1: rule__PredicateDefinition__Group_5__0__Impl : ( ':-' ) ; |
8175 | public final void rule__PredicateDefinition__Group_5__0__Impl() throws RecognitionException { | 9753 | public final void rule__PredicateDefinition__Group_5__0__Impl() throws RecognitionException { |
8176 | 9754 | ||
8177 | int stackSize = keepStackSize(); | 9755 | int stackSize = keepStackSize(); |
8178 | 9756 | ||
8179 | try { | 9757 | try { |
8180 | // InternalProblem.g:2570:1: ( ( ':-' ) ) | 9758 | // InternalProblem.g:3044:1: ( ( ':-' ) ) |
8181 | // InternalProblem.g:2571:1: ( ':-' ) | 9759 | // InternalProblem.g:3045:1: ( ':-' ) |
8182 | { | 9760 | { |
8183 | // InternalProblem.g:2571:1: ( ':-' ) | 9761 | // InternalProblem.g:3045:1: ( ':-' ) |
8184 | // InternalProblem.g:2572:2: ':-' | 9762 | // InternalProblem.g:3046:2: ':-' |
8185 | { | 9763 | { |
8186 | before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); | 9764 | before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); |
8187 | match(input,35,FOLLOW_2); | 9765 | match(input,39,FOLLOW_2); |
8188 | after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); | 9766 | after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); |
8189 | 9767 | ||
8190 | } | 9768 | } |
@@ -8208,14 +9786,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8208 | 9786 | ||
8209 | 9787 | ||
8210 | // $ANTLR start "rule__PredicateDefinition__Group_5__1" | 9788 | // $ANTLR start "rule__PredicateDefinition__Group_5__1" |
8211 | // InternalProblem.g:2581:1: rule__PredicateDefinition__Group_5__1 : rule__PredicateDefinition__Group_5__1__Impl rule__PredicateDefinition__Group_5__2 ; | 9789 | // InternalProblem.g:3055:1: rule__PredicateDefinition__Group_5__1 : rule__PredicateDefinition__Group_5__1__Impl rule__PredicateDefinition__Group_5__2 ; |
8212 | public final void rule__PredicateDefinition__Group_5__1() throws RecognitionException { | 9790 | public final void rule__PredicateDefinition__Group_5__1() throws RecognitionException { |
8213 | 9791 | ||
8214 | int stackSize = keepStackSize(); | 9792 | int stackSize = keepStackSize(); |
8215 | 9793 | ||
8216 | try { | 9794 | try { |
8217 | // InternalProblem.g:2585:1: ( rule__PredicateDefinition__Group_5__1__Impl rule__PredicateDefinition__Group_5__2 ) | 9795 | // InternalProblem.g:3059:1: ( rule__PredicateDefinition__Group_5__1__Impl rule__PredicateDefinition__Group_5__2 ) |
8218 | // InternalProblem.g:2586:2: rule__PredicateDefinition__Group_5__1__Impl rule__PredicateDefinition__Group_5__2 | 9796 | // InternalProblem.g:3060:2: rule__PredicateDefinition__Group_5__1__Impl rule__PredicateDefinition__Group_5__2 |
8219 | { | 9797 | { |
8220 | pushFollow(FOLLOW_13); | 9798 | pushFollow(FOLLOW_13); |
8221 | rule__PredicateDefinition__Group_5__1__Impl(); | 9799 | rule__PredicateDefinition__Group_5__1__Impl(); |
@@ -8246,21 +9824,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8246 | 9824 | ||
8247 | 9825 | ||
8248 | // $ANTLR start "rule__PredicateDefinition__Group_5__1__Impl" | 9826 | // $ANTLR start "rule__PredicateDefinition__Group_5__1__Impl" |
8249 | // InternalProblem.g:2593:1: rule__PredicateDefinition__Group_5__1__Impl : ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) ; | 9827 | // InternalProblem.g:3067:1: rule__PredicateDefinition__Group_5__1__Impl : ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) ; |
8250 | public final void rule__PredicateDefinition__Group_5__1__Impl() throws RecognitionException { | 9828 | public final void rule__PredicateDefinition__Group_5__1__Impl() throws RecognitionException { |
8251 | 9829 | ||
8252 | int stackSize = keepStackSize(); | 9830 | int stackSize = keepStackSize(); |
8253 | 9831 | ||
8254 | try { | 9832 | try { |
8255 | // InternalProblem.g:2597:1: ( ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) ) | 9833 | // InternalProblem.g:3071:1: ( ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) ) |
8256 | // InternalProblem.g:2598:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) | 9834 | // InternalProblem.g:3072:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) |
8257 | { | 9835 | { |
8258 | // InternalProblem.g:2598:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) | 9836 | // InternalProblem.g:3072:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) |
8259 | // InternalProblem.g:2599:2: ( rule__PredicateDefinition__BodiesAssignment_5_1 ) | 9837 | // InternalProblem.g:3073:2: ( rule__PredicateDefinition__BodiesAssignment_5_1 ) |
8260 | { | 9838 | { |
8261 | before(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_1()); | 9839 | before(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_1()); |
8262 | // InternalProblem.g:2600:2: ( rule__PredicateDefinition__BodiesAssignment_5_1 ) | 9840 | // InternalProblem.g:3074:2: ( rule__PredicateDefinition__BodiesAssignment_5_1 ) |
8263 | // InternalProblem.g:2600:3: rule__PredicateDefinition__BodiesAssignment_5_1 | 9841 | // InternalProblem.g:3074:3: rule__PredicateDefinition__BodiesAssignment_5_1 |
8264 | { | 9842 | { |
8265 | pushFollow(FOLLOW_2); | 9843 | pushFollow(FOLLOW_2); |
8266 | rule__PredicateDefinition__BodiesAssignment_5_1(); | 9844 | rule__PredicateDefinition__BodiesAssignment_5_1(); |
@@ -8293,14 +9871,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8293 | 9871 | ||
8294 | 9872 | ||
8295 | // $ANTLR start "rule__PredicateDefinition__Group_5__2" | 9873 | // $ANTLR start "rule__PredicateDefinition__Group_5__2" |
8296 | // InternalProblem.g:2608:1: rule__PredicateDefinition__Group_5__2 : rule__PredicateDefinition__Group_5__2__Impl ; | 9874 | // InternalProblem.g:3082:1: rule__PredicateDefinition__Group_5__2 : rule__PredicateDefinition__Group_5__2__Impl ; |
8297 | public final void rule__PredicateDefinition__Group_5__2() throws RecognitionException { | 9875 | public final void rule__PredicateDefinition__Group_5__2() throws RecognitionException { |
8298 | 9876 | ||
8299 | int stackSize = keepStackSize(); | 9877 | int stackSize = keepStackSize(); |
8300 | 9878 | ||
8301 | try { | 9879 | try { |
8302 | // InternalProblem.g:2612:1: ( rule__PredicateDefinition__Group_5__2__Impl ) | 9880 | // InternalProblem.g:3086:1: ( rule__PredicateDefinition__Group_5__2__Impl ) |
8303 | // InternalProblem.g:2613:2: rule__PredicateDefinition__Group_5__2__Impl | 9881 | // InternalProblem.g:3087:2: rule__PredicateDefinition__Group_5__2__Impl |
8304 | { | 9882 | { |
8305 | pushFollow(FOLLOW_2); | 9883 | pushFollow(FOLLOW_2); |
8306 | rule__PredicateDefinition__Group_5__2__Impl(); | 9884 | rule__PredicateDefinition__Group_5__2__Impl(); |
@@ -8326,33 +9904,33 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8326 | 9904 | ||
8327 | 9905 | ||
8328 | // $ANTLR start "rule__PredicateDefinition__Group_5__2__Impl" | 9906 | // $ANTLR start "rule__PredicateDefinition__Group_5__2__Impl" |
8329 | // InternalProblem.g:2619:1: rule__PredicateDefinition__Group_5__2__Impl : ( ( rule__PredicateDefinition__Group_5_2__0 )* ) ; | 9907 | // InternalProblem.g:3093:1: rule__PredicateDefinition__Group_5__2__Impl : ( ( rule__PredicateDefinition__Group_5_2__0 )* ) ; |
8330 | public final void rule__PredicateDefinition__Group_5__2__Impl() throws RecognitionException { | 9908 | public final void rule__PredicateDefinition__Group_5__2__Impl() throws RecognitionException { |
8331 | 9909 | ||
8332 | int stackSize = keepStackSize(); | 9910 | int stackSize = keepStackSize(); |
8333 | 9911 | ||
8334 | try { | 9912 | try { |
8335 | // InternalProblem.g:2623:1: ( ( ( rule__PredicateDefinition__Group_5_2__0 )* ) ) | 9913 | // InternalProblem.g:3097:1: ( ( ( rule__PredicateDefinition__Group_5_2__0 )* ) ) |
8336 | // InternalProblem.g:2624:1: ( ( rule__PredicateDefinition__Group_5_2__0 )* ) | 9914 | // InternalProblem.g:3098:1: ( ( rule__PredicateDefinition__Group_5_2__0 )* ) |
8337 | { | 9915 | { |
8338 | // InternalProblem.g:2624:1: ( ( rule__PredicateDefinition__Group_5_2__0 )* ) | 9916 | // InternalProblem.g:3098:1: ( ( rule__PredicateDefinition__Group_5_2__0 )* ) |
8339 | // InternalProblem.g:2625:2: ( rule__PredicateDefinition__Group_5_2__0 )* | 9917 | // InternalProblem.g:3099:2: ( rule__PredicateDefinition__Group_5_2__0 )* |
8340 | { | 9918 | { |
8341 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_5_2()); | 9919 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_5_2()); |
8342 | // InternalProblem.g:2626:2: ( rule__PredicateDefinition__Group_5_2__0 )* | 9920 | // InternalProblem.g:3100:2: ( rule__PredicateDefinition__Group_5_2__0 )* |
8343 | loop35: | 9921 | loop41: |
8344 | do { | 9922 | do { |
8345 | int alt35=2; | 9923 | int alt41=2; |
8346 | int LA35_0 = input.LA(1); | 9924 | int LA41_0 = input.LA(1); |
8347 | 9925 | ||
8348 | if ( (LA35_0==14) ) { | 9926 | if ( (LA41_0==14) ) { |
8349 | alt35=1; | 9927 | alt41=1; |
8350 | } | 9928 | } |
8351 | 9929 | ||
8352 | 9930 | ||
8353 | switch (alt35) { | 9931 | switch (alt41) { |
8354 | case 1 : | 9932 | case 1 : |
8355 | // InternalProblem.g:2626:3: rule__PredicateDefinition__Group_5_2__0 | 9933 | // InternalProblem.g:3100:3: rule__PredicateDefinition__Group_5_2__0 |
8356 | { | 9934 | { |
8357 | pushFollow(FOLLOW_27); | 9935 | pushFollow(FOLLOW_27); |
8358 | rule__PredicateDefinition__Group_5_2__0(); | 9936 | rule__PredicateDefinition__Group_5_2__0(); |
@@ -8364,7 +9942,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8364 | break; | 9942 | break; |
8365 | 9943 | ||
8366 | default : | 9944 | default : |
8367 | break loop35; | 9945 | break loop41; |
8368 | } | 9946 | } |
8369 | } while (true); | 9947 | } while (true); |
8370 | 9948 | ||
@@ -8391,14 +9969,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8391 | 9969 | ||
8392 | 9970 | ||
8393 | // $ANTLR start "rule__PredicateDefinition__Group_5_2__0" | 9971 | // $ANTLR start "rule__PredicateDefinition__Group_5_2__0" |
8394 | // InternalProblem.g:2635:1: rule__PredicateDefinition__Group_5_2__0 : rule__PredicateDefinition__Group_5_2__0__Impl rule__PredicateDefinition__Group_5_2__1 ; | 9972 | // InternalProblem.g:3109:1: rule__PredicateDefinition__Group_5_2__0 : rule__PredicateDefinition__Group_5_2__0__Impl rule__PredicateDefinition__Group_5_2__1 ; |
8395 | public final void rule__PredicateDefinition__Group_5_2__0() throws RecognitionException { | 9973 | public final void rule__PredicateDefinition__Group_5_2__0() throws RecognitionException { |
8396 | 9974 | ||
8397 | int stackSize = keepStackSize(); | 9975 | int stackSize = keepStackSize(); |
8398 | 9976 | ||
8399 | try { | 9977 | try { |
8400 | // InternalProblem.g:2639:1: ( rule__PredicateDefinition__Group_5_2__0__Impl rule__PredicateDefinition__Group_5_2__1 ) | 9978 | // InternalProblem.g:3113:1: ( rule__PredicateDefinition__Group_5_2__0__Impl rule__PredicateDefinition__Group_5_2__1 ) |
8401 | // InternalProblem.g:2640:2: rule__PredicateDefinition__Group_5_2__0__Impl rule__PredicateDefinition__Group_5_2__1 | 9979 | // InternalProblem.g:3114:2: rule__PredicateDefinition__Group_5_2__0__Impl rule__PredicateDefinition__Group_5_2__1 |
8402 | { | 9980 | { |
8403 | pushFollow(FOLLOW_26); | 9981 | pushFollow(FOLLOW_26); |
8404 | rule__PredicateDefinition__Group_5_2__0__Impl(); | 9982 | rule__PredicateDefinition__Group_5_2__0__Impl(); |
@@ -8429,17 +10007,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8429 | 10007 | ||
8430 | 10008 | ||
8431 | // $ANTLR start "rule__PredicateDefinition__Group_5_2__0__Impl" | 10009 | // $ANTLR start "rule__PredicateDefinition__Group_5_2__0__Impl" |
8432 | // InternalProblem.g:2647:1: rule__PredicateDefinition__Group_5_2__0__Impl : ( ';' ) ; | 10010 | // InternalProblem.g:3121:1: rule__PredicateDefinition__Group_5_2__0__Impl : ( ';' ) ; |
8433 | public final void rule__PredicateDefinition__Group_5_2__0__Impl() throws RecognitionException { | 10011 | public final void rule__PredicateDefinition__Group_5_2__0__Impl() throws RecognitionException { |
8434 | 10012 | ||
8435 | int stackSize = keepStackSize(); | 10013 | int stackSize = keepStackSize(); |
8436 | 10014 | ||
8437 | try { | 10015 | try { |
8438 | // InternalProblem.g:2651:1: ( ( ';' ) ) | 10016 | // InternalProblem.g:3125:1: ( ( ';' ) ) |
8439 | // InternalProblem.g:2652:1: ( ';' ) | 10017 | // InternalProblem.g:3126:1: ( ';' ) |
8440 | { | 10018 | { |
8441 | // InternalProblem.g:2652:1: ( ';' ) | 10019 | // InternalProblem.g:3126:1: ( ';' ) |
8442 | // InternalProblem.g:2653:2: ';' | 10020 | // InternalProblem.g:3127:2: ';' |
8443 | { | 10021 | { |
8444 | before(grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); | 10022 | before(grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); |
8445 | match(input,14,FOLLOW_2); | 10023 | match(input,14,FOLLOW_2); |
@@ -8466,14 +10044,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8466 | 10044 | ||
8467 | 10045 | ||
8468 | // $ANTLR start "rule__PredicateDefinition__Group_5_2__1" | 10046 | // $ANTLR start "rule__PredicateDefinition__Group_5_2__1" |
8469 | // InternalProblem.g:2662:1: rule__PredicateDefinition__Group_5_2__1 : rule__PredicateDefinition__Group_5_2__1__Impl ; | 10047 | // InternalProblem.g:3136:1: rule__PredicateDefinition__Group_5_2__1 : rule__PredicateDefinition__Group_5_2__1__Impl ; |
8470 | public final void rule__PredicateDefinition__Group_5_2__1() throws RecognitionException { | 10048 | public final void rule__PredicateDefinition__Group_5_2__1() throws RecognitionException { |
8471 | 10049 | ||
8472 | int stackSize = keepStackSize(); | 10050 | int stackSize = keepStackSize(); |
8473 | 10051 | ||
8474 | try { | 10052 | try { |
8475 | // InternalProblem.g:2666:1: ( rule__PredicateDefinition__Group_5_2__1__Impl ) | 10053 | // InternalProblem.g:3140:1: ( rule__PredicateDefinition__Group_5_2__1__Impl ) |
8476 | // InternalProblem.g:2667:2: rule__PredicateDefinition__Group_5_2__1__Impl | 10054 | // InternalProblem.g:3141:2: rule__PredicateDefinition__Group_5_2__1__Impl |
8477 | { | 10055 | { |
8478 | pushFollow(FOLLOW_2); | 10056 | pushFollow(FOLLOW_2); |
8479 | rule__PredicateDefinition__Group_5_2__1__Impl(); | 10057 | rule__PredicateDefinition__Group_5_2__1__Impl(); |
@@ -8499,21 +10077,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8499 | 10077 | ||
8500 | 10078 | ||
8501 | // $ANTLR start "rule__PredicateDefinition__Group_5_2__1__Impl" | 10079 | // $ANTLR start "rule__PredicateDefinition__Group_5_2__1__Impl" |
8502 | // InternalProblem.g:2673:1: rule__PredicateDefinition__Group_5_2__1__Impl : ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) ; | 10080 | // InternalProblem.g:3147:1: rule__PredicateDefinition__Group_5_2__1__Impl : ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) ; |
8503 | public final void rule__PredicateDefinition__Group_5_2__1__Impl() throws RecognitionException { | 10081 | public final void rule__PredicateDefinition__Group_5_2__1__Impl() throws RecognitionException { |
8504 | 10082 | ||
8505 | int stackSize = keepStackSize(); | 10083 | int stackSize = keepStackSize(); |
8506 | 10084 | ||
8507 | try { | 10085 | try { |
8508 | // InternalProblem.g:2677:1: ( ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) ) | 10086 | // InternalProblem.g:3151:1: ( ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) ) |
8509 | // InternalProblem.g:2678:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) | 10087 | // InternalProblem.g:3152:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) |
8510 | { | 10088 | { |
8511 | // InternalProblem.g:2678:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) | 10089 | // InternalProblem.g:3152:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) |
8512 | // InternalProblem.g:2679:2: ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) | 10090 | // InternalProblem.g:3153:2: ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) |
8513 | { | 10091 | { |
8514 | before(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_2_1()); | 10092 | before(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_2_1()); |
8515 | // InternalProblem.g:2680:2: ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) | 10093 | // InternalProblem.g:3154:2: ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) |
8516 | // InternalProblem.g:2680:3: rule__PredicateDefinition__BodiesAssignment_5_2_1 | 10094 | // InternalProblem.g:3154:3: rule__PredicateDefinition__BodiesAssignment_5_2_1 |
8517 | { | 10095 | { |
8518 | pushFollow(FOLLOW_2); | 10096 | pushFollow(FOLLOW_2); |
8519 | rule__PredicateDefinition__BodiesAssignment_5_2_1(); | 10097 | rule__PredicateDefinition__BodiesAssignment_5_2_1(); |
@@ -8546,14 +10124,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8546 | 10124 | ||
8547 | 10125 | ||
8548 | // $ANTLR start "rule__Parameter__Group__0" | 10126 | // $ANTLR start "rule__Parameter__Group__0" |
8549 | // InternalProblem.g:2689:1: rule__Parameter__Group__0 : rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ; | 10127 | // InternalProblem.g:3163:1: rule__Parameter__Group__0 : rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ; |
8550 | public final void rule__Parameter__Group__0() throws RecognitionException { | 10128 | public final void rule__Parameter__Group__0() throws RecognitionException { |
8551 | 10129 | ||
8552 | int stackSize = keepStackSize(); | 10130 | int stackSize = keepStackSize(); |
8553 | 10131 | ||
8554 | try { | 10132 | try { |
8555 | // InternalProblem.g:2693:1: ( rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ) | 10133 | // InternalProblem.g:3167:1: ( rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ) |
8556 | // InternalProblem.g:2694:2: rule__Parameter__Group__0__Impl rule__Parameter__Group__1 | 10134 | // InternalProblem.g:3168:2: rule__Parameter__Group__0__Impl rule__Parameter__Group__1 |
8557 | { | 10135 | { |
8558 | pushFollow(FOLLOW_5); | 10136 | pushFollow(FOLLOW_5); |
8559 | rule__Parameter__Group__0__Impl(); | 10137 | rule__Parameter__Group__0__Impl(); |
@@ -8584,59 +10162,77 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8584 | 10162 | ||
8585 | 10163 | ||
8586 | // $ANTLR start "rule__Parameter__Group__0__Impl" | 10164 | // $ANTLR start "rule__Parameter__Group__0__Impl" |
8587 | // InternalProblem.g:2701:1: rule__Parameter__Group__0__Impl : ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) ; | 10165 | // InternalProblem.g:3175:1: rule__Parameter__Group__0__Impl : ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) ; |
8588 | public final void rule__Parameter__Group__0__Impl() throws RecognitionException { | 10166 | public final void rule__Parameter__Group__0__Impl() throws RecognitionException { |
8589 | 10167 | ||
8590 | int stackSize = keepStackSize(); | 10168 | int stackSize = keepStackSize(); |
8591 | 10169 | ||
8592 | try { | 10170 | try { |
8593 | // InternalProblem.g:2705:1: ( ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) ) | 10171 | // InternalProblem.g:3179:1: ( ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) ) |
8594 | // InternalProblem.g:2706:1: ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) | 10172 | // InternalProblem.g:3180:1: ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) |
8595 | { | 10173 | { |
8596 | // InternalProblem.g:2706:1: ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) | 10174 | // InternalProblem.g:3180:1: ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) |
8597 | // InternalProblem.g:2707:2: ( rule__Parameter__ParameterTypeAssignment_0 )? | 10175 | // InternalProblem.g:3181:2: ( rule__Parameter__ParameterTypeAssignment_0 )? |
8598 | { | 10176 | { |
8599 | before(grammarAccess.getParameterAccess().getParameterTypeAssignment_0()); | 10177 | before(grammarAccess.getParameterAccess().getParameterTypeAssignment_0()); |
8600 | // InternalProblem.g:2708:2: ( rule__Parameter__ParameterTypeAssignment_0 )? | 10178 | // InternalProblem.g:3182:2: ( rule__Parameter__ParameterTypeAssignment_0 )? |
8601 | int alt36=2; | 10179 | int alt42=2; |
8602 | switch ( input.LA(1) ) { | 10180 | switch ( input.LA(1) ) { |
8603 | case RULE_QUOTED_ID: | 10181 | case RULE_QUOTED_ID: |
8604 | { | 10182 | { |
8605 | alt36=1; | 10183 | alt42=1; |
8606 | } | 10184 | } |
8607 | break; | 10185 | break; |
8608 | case RULE_ID: | 10186 | case RULE_ID: |
8609 | { | 10187 | { |
8610 | int LA36_2 = input.LA(2); | 10188 | int LA42_2 = input.LA(2); |
8611 | 10189 | ||
8612 | if ( (LA36_2==RULE_ID||(LA36_2>=19 && LA36_2<=20)||LA36_2==39) ) { | 10190 | if ( (LA42_2==RULE_ID||(LA42_2>=19 && LA42_2<=22)||LA42_2==43) ) { |
8613 | alt36=1; | 10191 | alt42=1; |
8614 | } | 10192 | } |
8615 | } | 10193 | } |
8616 | break; | 10194 | break; |
8617 | case 19: | 10195 | case 19: |
8618 | { | 10196 | { |
8619 | int LA36_3 = input.LA(2); | 10197 | int LA42_3 = input.LA(2); |
8620 | 10198 | ||
8621 | if ( (LA36_3==RULE_ID||(LA36_3>=19 && LA36_3<=20)||LA36_3==39) ) { | 10199 | if ( (LA42_3==RULE_ID||(LA42_3>=19 && LA42_3<=22)||LA42_3==43) ) { |
8622 | alt36=1; | 10200 | alt42=1; |
8623 | } | 10201 | } |
8624 | } | 10202 | } |
8625 | break; | 10203 | break; |
8626 | case 20: | 10204 | case 20: |
8627 | { | 10205 | { |
8628 | int LA36_4 = input.LA(2); | 10206 | int LA42_4 = input.LA(2); |
10207 | |||
10208 | if ( (LA42_4==RULE_ID||(LA42_4>=19 && LA42_4<=22)||LA42_4==43) ) { | ||
10209 | alt42=1; | ||
10210 | } | ||
10211 | } | ||
10212 | break; | ||
10213 | case 21: | ||
10214 | { | ||
10215 | int LA42_5 = input.LA(2); | ||
10216 | |||
10217 | if ( (LA42_5==RULE_ID||(LA42_5>=19 && LA42_5<=22)||LA42_5==43) ) { | ||
10218 | alt42=1; | ||
10219 | } | ||
10220 | } | ||
10221 | break; | ||
10222 | case 22: | ||
10223 | { | ||
10224 | int LA42_6 = input.LA(2); | ||
8629 | 10225 | ||
8630 | if ( (LA36_4==RULE_ID||(LA36_4>=19 && LA36_4<=20)||LA36_4==39) ) { | 10226 | if ( (LA42_6==RULE_ID||(LA42_6>=19 && LA42_6<=22)||LA42_6==43) ) { |
8631 | alt36=1; | 10227 | alt42=1; |
8632 | } | 10228 | } |
8633 | } | 10229 | } |
8634 | break; | 10230 | break; |
8635 | } | 10231 | } |
8636 | 10232 | ||
8637 | switch (alt36) { | 10233 | switch (alt42) { |
8638 | case 1 : | 10234 | case 1 : |
8639 | // InternalProblem.g:2708:3: rule__Parameter__ParameterTypeAssignment_0 | 10235 | // InternalProblem.g:3182:3: rule__Parameter__ParameterTypeAssignment_0 |
8640 | { | 10236 | { |
8641 | pushFollow(FOLLOW_2); | 10237 | pushFollow(FOLLOW_2); |
8642 | rule__Parameter__ParameterTypeAssignment_0(); | 10238 | rule__Parameter__ParameterTypeAssignment_0(); |
@@ -8672,14 +10268,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8672 | 10268 | ||
8673 | 10269 | ||
8674 | // $ANTLR start "rule__Parameter__Group__1" | 10270 | // $ANTLR start "rule__Parameter__Group__1" |
8675 | // InternalProblem.g:2716:1: rule__Parameter__Group__1 : rule__Parameter__Group__1__Impl ; | 10271 | // InternalProblem.g:3190:1: rule__Parameter__Group__1 : rule__Parameter__Group__1__Impl ; |
8676 | public final void rule__Parameter__Group__1() throws RecognitionException { | 10272 | public final void rule__Parameter__Group__1() throws RecognitionException { |
8677 | 10273 | ||
8678 | int stackSize = keepStackSize(); | 10274 | int stackSize = keepStackSize(); |
8679 | 10275 | ||
8680 | try { | 10276 | try { |
8681 | // InternalProblem.g:2720:1: ( rule__Parameter__Group__1__Impl ) | 10277 | // InternalProblem.g:3194:1: ( rule__Parameter__Group__1__Impl ) |
8682 | // InternalProblem.g:2721:2: rule__Parameter__Group__1__Impl | 10278 | // InternalProblem.g:3195:2: rule__Parameter__Group__1__Impl |
8683 | { | 10279 | { |
8684 | pushFollow(FOLLOW_2); | 10280 | pushFollow(FOLLOW_2); |
8685 | rule__Parameter__Group__1__Impl(); | 10281 | rule__Parameter__Group__1__Impl(); |
@@ -8705,21 +10301,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8705 | 10301 | ||
8706 | 10302 | ||
8707 | // $ANTLR start "rule__Parameter__Group__1__Impl" | 10303 | // $ANTLR start "rule__Parameter__Group__1__Impl" |
8708 | // InternalProblem.g:2727:1: rule__Parameter__Group__1__Impl : ( ( rule__Parameter__NameAssignment_1 ) ) ; | 10304 | // InternalProblem.g:3201:1: rule__Parameter__Group__1__Impl : ( ( rule__Parameter__NameAssignment_1 ) ) ; |
8709 | public final void rule__Parameter__Group__1__Impl() throws RecognitionException { | 10305 | public final void rule__Parameter__Group__1__Impl() throws RecognitionException { |
8710 | 10306 | ||
8711 | int stackSize = keepStackSize(); | 10307 | int stackSize = keepStackSize(); |
8712 | 10308 | ||
8713 | try { | 10309 | try { |
8714 | // InternalProblem.g:2731:1: ( ( ( rule__Parameter__NameAssignment_1 ) ) ) | 10310 | // InternalProblem.g:3205:1: ( ( ( rule__Parameter__NameAssignment_1 ) ) ) |
8715 | // InternalProblem.g:2732:1: ( ( rule__Parameter__NameAssignment_1 ) ) | 10311 | // InternalProblem.g:3206:1: ( ( rule__Parameter__NameAssignment_1 ) ) |
8716 | { | 10312 | { |
8717 | // InternalProblem.g:2732:1: ( ( rule__Parameter__NameAssignment_1 ) ) | 10313 | // InternalProblem.g:3206:1: ( ( rule__Parameter__NameAssignment_1 ) ) |
8718 | // InternalProblem.g:2733:2: ( rule__Parameter__NameAssignment_1 ) | 10314 | // InternalProblem.g:3207:2: ( rule__Parameter__NameAssignment_1 ) |
8719 | { | 10315 | { |
8720 | before(grammarAccess.getParameterAccess().getNameAssignment_1()); | 10316 | before(grammarAccess.getParameterAccess().getNameAssignment_1()); |
8721 | // InternalProblem.g:2734:2: ( rule__Parameter__NameAssignment_1 ) | 10317 | // InternalProblem.g:3208:2: ( rule__Parameter__NameAssignment_1 ) |
8722 | // InternalProblem.g:2734:3: rule__Parameter__NameAssignment_1 | 10318 | // InternalProblem.g:3208:3: rule__Parameter__NameAssignment_1 |
8723 | { | 10319 | { |
8724 | pushFollow(FOLLOW_2); | 10320 | pushFollow(FOLLOW_2); |
8725 | rule__Parameter__NameAssignment_1(); | 10321 | rule__Parameter__NameAssignment_1(); |
@@ -8752,14 +10348,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8752 | 10348 | ||
8753 | 10349 | ||
8754 | // $ANTLR start "rule__Conjunction__Group__0" | 10350 | // $ANTLR start "rule__Conjunction__Group__0" |
8755 | // InternalProblem.g:2743:1: rule__Conjunction__Group__0 : rule__Conjunction__Group__0__Impl rule__Conjunction__Group__1 ; | 10351 | // InternalProblem.g:3217:1: rule__Conjunction__Group__0 : rule__Conjunction__Group__0__Impl rule__Conjunction__Group__1 ; |
8756 | public final void rule__Conjunction__Group__0() throws RecognitionException { | 10352 | public final void rule__Conjunction__Group__0() throws RecognitionException { |
8757 | 10353 | ||
8758 | int stackSize = keepStackSize(); | 10354 | int stackSize = keepStackSize(); |
8759 | 10355 | ||
8760 | try { | 10356 | try { |
8761 | // InternalProblem.g:2747:1: ( rule__Conjunction__Group__0__Impl rule__Conjunction__Group__1 ) | 10357 | // InternalProblem.g:3221:1: ( rule__Conjunction__Group__0__Impl rule__Conjunction__Group__1 ) |
8762 | // InternalProblem.g:2748:2: rule__Conjunction__Group__0__Impl rule__Conjunction__Group__1 | 10358 | // InternalProblem.g:3222:2: rule__Conjunction__Group__0__Impl rule__Conjunction__Group__1 |
8763 | { | 10359 | { |
8764 | pushFollow(FOLLOW_9); | 10360 | pushFollow(FOLLOW_9); |
8765 | rule__Conjunction__Group__0__Impl(); | 10361 | rule__Conjunction__Group__0__Impl(); |
@@ -8790,21 +10386,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8790 | 10386 | ||
8791 | 10387 | ||
8792 | // $ANTLR start "rule__Conjunction__Group__0__Impl" | 10388 | // $ANTLR start "rule__Conjunction__Group__0__Impl" |
8793 | // InternalProblem.g:2755:1: rule__Conjunction__Group__0__Impl : ( ( rule__Conjunction__LiteralsAssignment_0 ) ) ; | 10389 | // InternalProblem.g:3229:1: rule__Conjunction__Group__0__Impl : ( ( rule__Conjunction__LiteralsAssignment_0 ) ) ; |
8794 | public final void rule__Conjunction__Group__0__Impl() throws RecognitionException { | 10390 | public final void rule__Conjunction__Group__0__Impl() throws RecognitionException { |
8795 | 10391 | ||
8796 | int stackSize = keepStackSize(); | 10392 | int stackSize = keepStackSize(); |
8797 | 10393 | ||
8798 | try { | 10394 | try { |
8799 | // InternalProblem.g:2759:1: ( ( ( rule__Conjunction__LiteralsAssignment_0 ) ) ) | 10395 | // InternalProblem.g:3233:1: ( ( ( rule__Conjunction__LiteralsAssignment_0 ) ) ) |
8800 | // InternalProblem.g:2760:1: ( ( rule__Conjunction__LiteralsAssignment_0 ) ) | 10396 | // InternalProblem.g:3234:1: ( ( rule__Conjunction__LiteralsAssignment_0 ) ) |
8801 | { | 10397 | { |
8802 | // InternalProblem.g:2760:1: ( ( rule__Conjunction__LiteralsAssignment_0 ) ) | 10398 | // InternalProblem.g:3234:1: ( ( rule__Conjunction__LiteralsAssignment_0 ) ) |
8803 | // InternalProblem.g:2761:2: ( rule__Conjunction__LiteralsAssignment_0 ) | 10399 | // InternalProblem.g:3235:2: ( rule__Conjunction__LiteralsAssignment_0 ) |
8804 | { | 10400 | { |
8805 | before(grammarAccess.getConjunctionAccess().getLiteralsAssignment_0()); | 10401 | before(grammarAccess.getConjunctionAccess().getLiteralsAssignment_0()); |
8806 | // InternalProblem.g:2762:2: ( rule__Conjunction__LiteralsAssignment_0 ) | 10402 | // InternalProblem.g:3236:2: ( rule__Conjunction__LiteralsAssignment_0 ) |
8807 | // InternalProblem.g:2762:3: rule__Conjunction__LiteralsAssignment_0 | 10403 | // InternalProblem.g:3236:3: rule__Conjunction__LiteralsAssignment_0 |
8808 | { | 10404 | { |
8809 | pushFollow(FOLLOW_2); | 10405 | pushFollow(FOLLOW_2); |
8810 | rule__Conjunction__LiteralsAssignment_0(); | 10406 | rule__Conjunction__LiteralsAssignment_0(); |
@@ -8837,14 +10433,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8837 | 10433 | ||
8838 | 10434 | ||
8839 | // $ANTLR start "rule__Conjunction__Group__1" | 10435 | // $ANTLR start "rule__Conjunction__Group__1" |
8840 | // InternalProblem.g:2770:1: rule__Conjunction__Group__1 : rule__Conjunction__Group__1__Impl ; | 10436 | // InternalProblem.g:3244:1: rule__Conjunction__Group__1 : rule__Conjunction__Group__1__Impl ; |
8841 | public final void rule__Conjunction__Group__1() throws RecognitionException { | 10437 | public final void rule__Conjunction__Group__1() throws RecognitionException { |
8842 | 10438 | ||
8843 | int stackSize = keepStackSize(); | 10439 | int stackSize = keepStackSize(); |
8844 | 10440 | ||
8845 | try { | 10441 | try { |
8846 | // InternalProblem.g:2774:1: ( rule__Conjunction__Group__1__Impl ) | 10442 | // InternalProblem.g:3248:1: ( rule__Conjunction__Group__1__Impl ) |
8847 | // InternalProblem.g:2775:2: rule__Conjunction__Group__1__Impl | 10443 | // InternalProblem.g:3249:2: rule__Conjunction__Group__1__Impl |
8848 | { | 10444 | { |
8849 | pushFollow(FOLLOW_2); | 10445 | pushFollow(FOLLOW_2); |
8850 | rule__Conjunction__Group__1__Impl(); | 10446 | rule__Conjunction__Group__1__Impl(); |
@@ -8870,33 +10466,33 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8870 | 10466 | ||
8871 | 10467 | ||
8872 | // $ANTLR start "rule__Conjunction__Group__1__Impl" | 10468 | // $ANTLR start "rule__Conjunction__Group__1__Impl" |
8873 | // InternalProblem.g:2781:1: rule__Conjunction__Group__1__Impl : ( ( rule__Conjunction__Group_1__0 )* ) ; | 10469 | // InternalProblem.g:3255:1: rule__Conjunction__Group__1__Impl : ( ( rule__Conjunction__Group_1__0 )* ) ; |
8874 | public final void rule__Conjunction__Group__1__Impl() throws RecognitionException { | 10470 | public final void rule__Conjunction__Group__1__Impl() throws RecognitionException { |
8875 | 10471 | ||
8876 | int stackSize = keepStackSize(); | 10472 | int stackSize = keepStackSize(); |
8877 | 10473 | ||
8878 | try { | 10474 | try { |
8879 | // InternalProblem.g:2785:1: ( ( ( rule__Conjunction__Group_1__0 )* ) ) | 10475 | // InternalProblem.g:3259:1: ( ( ( rule__Conjunction__Group_1__0 )* ) ) |
8880 | // InternalProblem.g:2786:1: ( ( rule__Conjunction__Group_1__0 )* ) | 10476 | // InternalProblem.g:3260:1: ( ( rule__Conjunction__Group_1__0 )* ) |
8881 | { | 10477 | { |
8882 | // InternalProblem.g:2786:1: ( ( rule__Conjunction__Group_1__0 )* ) | 10478 | // InternalProblem.g:3260:1: ( ( rule__Conjunction__Group_1__0 )* ) |
8883 | // InternalProblem.g:2787:2: ( rule__Conjunction__Group_1__0 )* | 10479 | // InternalProblem.g:3261:2: ( rule__Conjunction__Group_1__0 )* |
8884 | { | 10480 | { |
8885 | before(grammarAccess.getConjunctionAccess().getGroup_1()); | 10481 | before(grammarAccess.getConjunctionAccess().getGroup_1()); |
8886 | // InternalProblem.g:2788:2: ( rule__Conjunction__Group_1__0 )* | 10482 | // InternalProblem.g:3262:2: ( rule__Conjunction__Group_1__0 )* |
8887 | loop37: | 10483 | loop43: |
8888 | do { | 10484 | do { |
8889 | int alt37=2; | 10485 | int alt43=2; |
8890 | int LA37_0 = input.LA(1); | 10486 | int LA43_0 = input.LA(1); |
8891 | 10487 | ||
8892 | if ( (LA37_0==13) ) { | 10488 | if ( (LA43_0==13) ) { |
8893 | alt37=1; | 10489 | alt43=1; |
8894 | } | 10490 | } |
8895 | 10491 | ||
8896 | 10492 | ||
8897 | switch (alt37) { | 10493 | switch (alt43) { |
8898 | case 1 : | 10494 | case 1 : |
8899 | // InternalProblem.g:2788:3: rule__Conjunction__Group_1__0 | 10495 | // InternalProblem.g:3262:3: rule__Conjunction__Group_1__0 |
8900 | { | 10496 | { |
8901 | pushFollow(FOLLOW_10); | 10497 | pushFollow(FOLLOW_10); |
8902 | rule__Conjunction__Group_1__0(); | 10498 | rule__Conjunction__Group_1__0(); |
@@ -8908,7 +10504,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8908 | break; | 10504 | break; |
8909 | 10505 | ||
8910 | default : | 10506 | default : |
8911 | break loop37; | 10507 | break loop43; |
8912 | } | 10508 | } |
8913 | } while (true); | 10509 | } while (true); |
8914 | 10510 | ||
@@ -8935,14 +10531,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8935 | 10531 | ||
8936 | 10532 | ||
8937 | // $ANTLR start "rule__Conjunction__Group_1__0" | 10533 | // $ANTLR start "rule__Conjunction__Group_1__0" |
8938 | // InternalProblem.g:2797:1: rule__Conjunction__Group_1__0 : rule__Conjunction__Group_1__0__Impl rule__Conjunction__Group_1__1 ; | 10534 | // InternalProblem.g:3271:1: rule__Conjunction__Group_1__0 : rule__Conjunction__Group_1__0__Impl rule__Conjunction__Group_1__1 ; |
8939 | public final void rule__Conjunction__Group_1__0() throws RecognitionException { | 10535 | public final void rule__Conjunction__Group_1__0() throws RecognitionException { |
8940 | 10536 | ||
8941 | int stackSize = keepStackSize(); | 10537 | int stackSize = keepStackSize(); |
8942 | 10538 | ||
8943 | try { | 10539 | try { |
8944 | // InternalProblem.g:2801:1: ( rule__Conjunction__Group_1__0__Impl rule__Conjunction__Group_1__1 ) | 10540 | // InternalProblem.g:3275:1: ( rule__Conjunction__Group_1__0__Impl rule__Conjunction__Group_1__1 ) |
8945 | // InternalProblem.g:2802:2: rule__Conjunction__Group_1__0__Impl rule__Conjunction__Group_1__1 | 10541 | // InternalProblem.g:3276:2: rule__Conjunction__Group_1__0__Impl rule__Conjunction__Group_1__1 |
8946 | { | 10542 | { |
8947 | pushFollow(FOLLOW_26); | 10543 | pushFollow(FOLLOW_26); |
8948 | rule__Conjunction__Group_1__0__Impl(); | 10544 | rule__Conjunction__Group_1__0__Impl(); |
@@ -8973,17 +10569,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
8973 | 10569 | ||
8974 | 10570 | ||
8975 | // $ANTLR start "rule__Conjunction__Group_1__0__Impl" | 10571 | // $ANTLR start "rule__Conjunction__Group_1__0__Impl" |
8976 | // InternalProblem.g:2809:1: rule__Conjunction__Group_1__0__Impl : ( ',' ) ; | 10572 | // InternalProblem.g:3283:1: rule__Conjunction__Group_1__0__Impl : ( ',' ) ; |
8977 | public final void rule__Conjunction__Group_1__0__Impl() throws RecognitionException { | 10573 | public final void rule__Conjunction__Group_1__0__Impl() throws RecognitionException { |
8978 | 10574 | ||
8979 | int stackSize = keepStackSize(); | 10575 | int stackSize = keepStackSize(); |
8980 | 10576 | ||
8981 | try { | 10577 | try { |
8982 | // InternalProblem.g:2813:1: ( ( ',' ) ) | 10578 | // InternalProblem.g:3287:1: ( ( ',' ) ) |
8983 | // InternalProblem.g:2814:1: ( ',' ) | 10579 | // InternalProblem.g:3288:1: ( ',' ) |
8984 | { | 10580 | { |
8985 | // InternalProblem.g:2814:1: ( ',' ) | 10581 | // InternalProblem.g:3288:1: ( ',' ) |
8986 | // InternalProblem.g:2815:2: ',' | 10582 | // InternalProblem.g:3289:2: ',' |
8987 | { | 10583 | { |
8988 | before(grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); | 10584 | before(grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); |
8989 | match(input,13,FOLLOW_2); | 10585 | match(input,13,FOLLOW_2); |
@@ -9010,14 +10606,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9010 | 10606 | ||
9011 | 10607 | ||
9012 | // $ANTLR start "rule__Conjunction__Group_1__1" | 10608 | // $ANTLR start "rule__Conjunction__Group_1__1" |
9013 | // InternalProblem.g:2824:1: rule__Conjunction__Group_1__1 : rule__Conjunction__Group_1__1__Impl ; | 10609 | // InternalProblem.g:3298:1: rule__Conjunction__Group_1__1 : rule__Conjunction__Group_1__1__Impl ; |
9014 | public final void rule__Conjunction__Group_1__1() throws RecognitionException { | 10610 | public final void rule__Conjunction__Group_1__1() throws RecognitionException { |
9015 | 10611 | ||
9016 | int stackSize = keepStackSize(); | 10612 | int stackSize = keepStackSize(); |
9017 | 10613 | ||
9018 | try { | 10614 | try { |
9019 | // InternalProblem.g:2828:1: ( rule__Conjunction__Group_1__1__Impl ) | 10615 | // InternalProblem.g:3302:1: ( rule__Conjunction__Group_1__1__Impl ) |
9020 | // InternalProblem.g:2829:2: rule__Conjunction__Group_1__1__Impl | 10616 | // InternalProblem.g:3303:2: rule__Conjunction__Group_1__1__Impl |
9021 | { | 10617 | { |
9022 | pushFollow(FOLLOW_2); | 10618 | pushFollow(FOLLOW_2); |
9023 | rule__Conjunction__Group_1__1__Impl(); | 10619 | rule__Conjunction__Group_1__1__Impl(); |
@@ -9043,21 +10639,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9043 | 10639 | ||
9044 | 10640 | ||
9045 | // $ANTLR start "rule__Conjunction__Group_1__1__Impl" | 10641 | // $ANTLR start "rule__Conjunction__Group_1__1__Impl" |
9046 | // InternalProblem.g:2835:1: rule__Conjunction__Group_1__1__Impl : ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) ; | 10642 | // InternalProblem.g:3309:1: rule__Conjunction__Group_1__1__Impl : ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) ; |
9047 | public final void rule__Conjunction__Group_1__1__Impl() throws RecognitionException { | 10643 | public final void rule__Conjunction__Group_1__1__Impl() throws RecognitionException { |
9048 | 10644 | ||
9049 | int stackSize = keepStackSize(); | 10645 | int stackSize = keepStackSize(); |
9050 | 10646 | ||
9051 | try { | 10647 | try { |
9052 | // InternalProblem.g:2839:1: ( ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) ) | 10648 | // InternalProblem.g:3313:1: ( ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) ) |
9053 | // InternalProblem.g:2840:1: ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) | 10649 | // InternalProblem.g:3314:1: ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) |
9054 | { | 10650 | { |
9055 | // InternalProblem.g:2840:1: ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) | 10651 | // InternalProblem.g:3314:1: ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) |
9056 | // InternalProblem.g:2841:2: ( rule__Conjunction__LiteralsAssignment_1_1 ) | 10652 | // InternalProblem.g:3315:2: ( rule__Conjunction__LiteralsAssignment_1_1 ) |
9057 | { | 10653 | { |
9058 | before(grammarAccess.getConjunctionAccess().getLiteralsAssignment_1_1()); | 10654 | before(grammarAccess.getConjunctionAccess().getLiteralsAssignment_1_1()); |
9059 | // InternalProblem.g:2842:2: ( rule__Conjunction__LiteralsAssignment_1_1 ) | 10655 | // InternalProblem.g:3316:2: ( rule__Conjunction__LiteralsAssignment_1_1 ) |
9060 | // InternalProblem.g:2842:3: rule__Conjunction__LiteralsAssignment_1_1 | 10656 | // InternalProblem.g:3316:3: rule__Conjunction__LiteralsAssignment_1_1 |
9061 | { | 10657 | { |
9062 | pushFollow(FOLLOW_2); | 10658 | pushFollow(FOLLOW_2); |
9063 | rule__Conjunction__LiteralsAssignment_1_1(); | 10659 | rule__Conjunction__LiteralsAssignment_1_1(); |
@@ -9090,14 +10686,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9090 | 10686 | ||
9091 | 10687 | ||
9092 | // $ANTLR start "rule__NegativeLiteral__Group__0" | 10688 | // $ANTLR start "rule__NegativeLiteral__Group__0" |
9093 | // InternalProblem.g:2851:1: rule__NegativeLiteral__Group__0 : rule__NegativeLiteral__Group__0__Impl rule__NegativeLiteral__Group__1 ; | 10689 | // InternalProblem.g:3325:1: rule__NegativeLiteral__Group__0 : rule__NegativeLiteral__Group__0__Impl rule__NegativeLiteral__Group__1 ; |
9094 | public final void rule__NegativeLiteral__Group__0() throws RecognitionException { | 10690 | public final void rule__NegativeLiteral__Group__0() throws RecognitionException { |
9095 | 10691 | ||
9096 | int stackSize = keepStackSize(); | 10692 | int stackSize = keepStackSize(); |
9097 | 10693 | ||
9098 | try { | 10694 | try { |
9099 | // InternalProblem.g:2855:1: ( rule__NegativeLiteral__Group__0__Impl rule__NegativeLiteral__Group__1 ) | 10695 | // InternalProblem.g:3329:1: ( rule__NegativeLiteral__Group__0__Impl rule__NegativeLiteral__Group__1 ) |
9100 | // InternalProblem.g:2856:2: rule__NegativeLiteral__Group__0__Impl rule__NegativeLiteral__Group__1 | 10696 | // InternalProblem.g:3330:2: rule__NegativeLiteral__Group__0__Impl rule__NegativeLiteral__Group__1 |
9101 | { | 10697 | { |
9102 | pushFollow(FOLLOW_5); | 10698 | pushFollow(FOLLOW_5); |
9103 | rule__NegativeLiteral__Group__0__Impl(); | 10699 | rule__NegativeLiteral__Group__0__Impl(); |
@@ -9128,20 +10724,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9128 | 10724 | ||
9129 | 10725 | ||
9130 | // $ANTLR start "rule__NegativeLiteral__Group__0__Impl" | 10726 | // $ANTLR start "rule__NegativeLiteral__Group__0__Impl" |
9131 | // InternalProblem.g:2863:1: rule__NegativeLiteral__Group__0__Impl : ( '!' ) ; | 10727 | // InternalProblem.g:3337:1: rule__NegativeLiteral__Group__0__Impl : ( '!' ) ; |
9132 | public final void rule__NegativeLiteral__Group__0__Impl() throws RecognitionException { | 10728 | public final void rule__NegativeLiteral__Group__0__Impl() throws RecognitionException { |
9133 | 10729 | ||
9134 | int stackSize = keepStackSize(); | 10730 | int stackSize = keepStackSize(); |
9135 | 10731 | ||
9136 | try { | 10732 | try { |
9137 | // InternalProblem.g:2867:1: ( ( '!' ) ) | 10733 | // InternalProblem.g:3341:1: ( ( '!' ) ) |
9138 | // InternalProblem.g:2868:1: ( '!' ) | 10734 | // InternalProblem.g:3342:1: ( '!' ) |
9139 | { | 10735 | { |
9140 | // InternalProblem.g:2868:1: ( '!' ) | 10736 | // InternalProblem.g:3342:1: ( '!' ) |
9141 | // InternalProblem.g:2869:2: '!' | 10737 | // InternalProblem.g:3343:2: '!' |
9142 | { | 10738 | { |
9143 | before(grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); | 10739 | before(grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); |
9144 | match(input,22,FOLLOW_2); | 10740 | match(input,26,FOLLOW_2); |
9145 | after(grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); | 10741 | after(grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); |
9146 | 10742 | ||
9147 | } | 10743 | } |
@@ -9165,14 +10761,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9165 | 10761 | ||
9166 | 10762 | ||
9167 | // $ANTLR start "rule__NegativeLiteral__Group__1" | 10763 | // $ANTLR start "rule__NegativeLiteral__Group__1" |
9168 | // InternalProblem.g:2878:1: rule__NegativeLiteral__Group__1 : rule__NegativeLiteral__Group__1__Impl ; | 10764 | // InternalProblem.g:3352:1: rule__NegativeLiteral__Group__1 : rule__NegativeLiteral__Group__1__Impl ; |
9169 | public final void rule__NegativeLiteral__Group__1() throws RecognitionException { | 10765 | public final void rule__NegativeLiteral__Group__1() throws RecognitionException { |
9170 | 10766 | ||
9171 | int stackSize = keepStackSize(); | 10767 | int stackSize = keepStackSize(); |
9172 | 10768 | ||
9173 | try { | 10769 | try { |
9174 | // InternalProblem.g:2882:1: ( rule__NegativeLiteral__Group__1__Impl ) | 10770 | // InternalProblem.g:3356:1: ( rule__NegativeLiteral__Group__1__Impl ) |
9175 | // InternalProblem.g:2883:2: rule__NegativeLiteral__Group__1__Impl | 10771 | // InternalProblem.g:3357:2: rule__NegativeLiteral__Group__1__Impl |
9176 | { | 10772 | { |
9177 | pushFollow(FOLLOW_2); | 10773 | pushFollow(FOLLOW_2); |
9178 | rule__NegativeLiteral__Group__1__Impl(); | 10774 | rule__NegativeLiteral__Group__1__Impl(); |
@@ -9198,21 +10794,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9198 | 10794 | ||
9199 | 10795 | ||
9200 | // $ANTLR start "rule__NegativeLiteral__Group__1__Impl" | 10796 | // $ANTLR start "rule__NegativeLiteral__Group__1__Impl" |
9201 | // InternalProblem.g:2889:1: rule__NegativeLiteral__Group__1__Impl : ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) ; | 10797 | // InternalProblem.g:3363:1: rule__NegativeLiteral__Group__1__Impl : ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) ; |
9202 | public final void rule__NegativeLiteral__Group__1__Impl() throws RecognitionException { | 10798 | public final void rule__NegativeLiteral__Group__1__Impl() throws RecognitionException { |
9203 | 10799 | ||
9204 | int stackSize = keepStackSize(); | 10800 | int stackSize = keepStackSize(); |
9205 | 10801 | ||
9206 | try { | 10802 | try { |
9207 | // InternalProblem.g:2893:1: ( ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) ) | 10803 | // InternalProblem.g:3367:1: ( ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) ) |
9208 | // InternalProblem.g:2894:1: ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) | 10804 | // InternalProblem.g:3368:1: ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) |
9209 | { | 10805 | { |
9210 | // InternalProblem.g:2894:1: ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) | 10806 | // InternalProblem.g:3368:1: ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) |
9211 | // InternalProblem.g:2895:2: ( rule__NegativeLiteral__AtomAssignment_1 ) | 10807 | // InternalProblem.g:3369:2: ( rule__NegativeLiteral__AtomAssignment_1 ) |
9212 | { | 10808 | { |
9213 | before(grammarAccess.getNegativeLiteralAccess().getAtomAssignment_1()); | 10809 | before(grammarAccess.getNegativeLiteralAccess().getAtomAssignment_1()); |
9214 | // InternalProblem.g:2896:2: ( rule__NegativeLiteral__AtomAssignment_1 ) | 10810 | // InternalProblem.g:3370:2: ( rule__NegativeLiteral__AtomAssignment_1 ) |
9215 | // InternalProblem.g:2896:3: rule__NegativeLiteral__AtomAssignment_1 | 10811 | // InternalProblem.g:3370:3: rule__NegativeLiteral__AtomAssignment_1 |
9216 | { | 10812 | { |
9217 | pushFollow(FOLLOW_2); | 10813 | pushFollow(FOLLOW_2); |
9218 | rule__NegativeLiteral__AtomAssignment_1(); | 10814 | rule__NegativeLiteral__AtomAssignment_1(); |
@@ -9245,14 +10841,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9245 | 10841 | ||
9246 | 10842 | ||
9247 | // $ANTLR start "rule__Atom__Group__0" | 10843 | // $ANTLR start "rule__Atom__Group__0" |
9248 | // InternalProblem.g:2905:1: rule__Atom__Group__0 : rule__Atom__Group__0__Impl rule__Atom__Group__1 ; | 10844 | // InternalProblem.g:3379:1: rule__Atom__Group__0 : rule__Atom__Group__0__Impl rule__Atom__Group__1 ; |
9249 | public final void rule__Atom__Group__0() throws RecognitionException { | 10845 | public final void rule__Atom__Group__0() throws RecognitionException { |
9250 | 10846 | ||
9251 | int stackSize = keepStackSize(); | 10847 | int stackSize = keepStackSize(); |
9252 | 10848 | ||
9253 | try { | 10849 | try { |
9254 | // InternalProblem.g:2909:1: ( rule__Atom__Group__0__Impl rule__Atom__Group__1 ) | 10850 | // InternalProblem.g:3383:1: ( rule__Atom__Group__0__Impl rule__Atom__Group__1 ) |
9255 | // InternalProblem.g:2910:2: rule__Atom__Group__0__Impl rule__Atom__Group__1 | 10851 | // InternalProblem.g:3384:2: rule__Atom__Group__0__Impl rule__Atom__Group__1 |
9256 | { | 10852 | { |
9257 | pushFollow(FOLLOW_28); | 10853 | pushFollow(FOLLOW_28); |
9258 | rule__Atom__Group__0__Impl(); | 10854 | rule__Atom__Group__0__Impl(); |
@@ -9283,21 +10879,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9283 | 10879 | ||
9284 | 10880 | ||
9285 | // $ANTLR start "rule__Atom__Group__0__Impl" | 10881 | // $ANTLR start "rule__Atom__Group__0__Impl" |
9286 | // InternalProblem.g:2917:1: rule__Atom__Group__0__Impl : ( ( rule__Atom__RelationAssignment_0 ) ) ; | 10882 | // InternalProblem.g:3391:1: rule__Atom__Group__0__Impl : ( ( rule__Atom__RelationAssignment_0 ) ) ; |
9287 | public final void rule__Atom__Group__0__Impl() throws RecognitionException { | 10883 | public final void rule__Atom__Group__0__Impl() throws RecognitionException { |
9288 | 10884 | ||
9289 | int stackSize = keepStackSize(); | 10885 | int stackSize = keepStackSize(); |
9290 | 10886 | ||
9291 | try { | 10887 | try { |
9292 | // InternalProblem.g:2921:1: ( ( ( rule__Atom__RelationAssignment_0 ) ) ) | 10888 | // InternalProblem.g:3395:1: ( ( ( rule__Atom__RelationAssignment_0 ) ) ) |
9293 | // InternalProblem.g:2922:1: ( ( rule__Atom__RelationAssignment_0 ) ) | 10889 | // InternalProblem.g:3396:1: ( ( rule__Atom__RelationAssignment_0 ) ) |
9294 | { | 10890 | { |
9295 | // InternalProblem.g:2922:1: ( ( rule__Atom__RelationAssignment_0 ) ) | 10891 | // InternalProblem.g:3396:1: ( ( rule__Atom__RelationAssignment_0 ) ) |
9296 | // InternalProblem.g:2923:2: ( rule__Atom__RelationAssignment_0 ) | 10892 | // InternalProblem.g:3397:2: ( rule__Atom__RelationAssignment_0 ) |
9297 | { | 10893 | { |
9298 | before(grammarAccess.getAtomAccess().getRelationAssignment_0()); | 10894 | before(grammarAccess.getAtomAccess().getRelationAssignment_0()); |
9299 | // InternalProblem.g:2924:2: ( rule__Atom__RelationAssignment_0 ) | 10895 | // InternalProblem.g:3398:2: ( rule__Atom__RelationAssignment_0 ) |
9300 | // InternalProblem.g:2924:3: rule__Atom__RelationAssignment_0 | 10896 | // InternalProblem.g:3398:3: rule__Atom__RelationAssignment_0 |
9301 | { | 10897 | { |
9302 | pushFollow(FOLLOW_2); | 10898 | pushFollow(FOLLOW_2); |
9303 | rule__Atom__RelationAssignment_0(); | 10899 | rule__Atom__RelationAssignment_0(); |
@@ -9330,14 +10926,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9330 | 10926 | ||
9331 | 10927 | ||
9332 | // $ANTLR start "rule__Atom__Group__1" | 10928 | // $ANTLR start "rule__Atom__Group__1" |
9333 | // InternalProblem.g:2932:1: rule__Atom__Group__1 : rule__Atom__Group__1__Impl rule__Atom__Group__2 ; | 10929 | // InternalProblem.g:3406:1: rule__Atom__Group__1 : rule__Atom__Group__1__Impl rule__Atom__Group__2 ; |
9334 | public final void rule__Atom__Group__1() throws RecognitionException { | 10930 | public final void rule__Atom__Group__1() throws RecognitionException { |
9335 | 10931 | ||
9336 | int stackSize = keepStackSize(); | 10932 | int stackSize = keepStackSize(); |
9337 | 10933 | ||
9338 | try { | 10934 | try { |
9339 | // InternalProblem.g:2936:1: ( rule__Atom__Group__1__Impl rule__Atom__Group__2 ) | 10935 | // InternalProblem.g:3410:1: ( rule__Atom__Group__1__Impl rule__Atom__Group__2 ) |
9340 | // InternalProblem.g:2937:2: rule__Atom__Group__1__Impl rule__Atom__Group__2 | 10936 | // InternalProblem.g:3411:2: rule__Atom__Group__1__Impl rule__Atom__Group__2 |
9341 | { | 10937 | { |
9342 | pushFollow(FOLLOW_28); | 10938 | pushFollow(FOLLOW_28); |
9343 | rule__Atom__Group__1__Impl(); | 10939 | rule__Atom__Group__1__Impl(); |
@@ -9368,29 +10964,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9368 | 10964 | ||
9369 | 10965 | ||
9370 | // $ANTLR start "rule__Atom__Group__1__Impl" | 10966 | // $ANTLR start "rule__Atom__Group__1__Impl" |
9371 | // InternalProblem.g:2944:1: rule__Atom__Group__1__Impl : ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) ; | 10967 | // InternalProblem.g:3418:1: rule__Atom__Group__1__Impl : ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) ; |
9372 | public final void rule__Atom__Group__1__Impl() throws RecognitionException { | 10968 | public final void rule__Atom__Group__1__Impl() throws RecognitionException { |
9373 | 10969 | ||
9374 | int stackSize = keepStackSize(); | 10970 | int stackSize = keepStackSize(); |
9375 | 10971 | ||
9376 | try { | 10972 | try { |
9377 | // InternalProblem.g:2948:1: ( ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) ) | 10973 | // InternalProblem.g:3422:1: ( ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) ) |
9378 | // InternalProblem.g:2949:1: ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) | 10974 | // InternalProblem.g:3423:1: ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) |
9379 | { | 10975 | { |
9380 | // InternalProblem.g:2949:1: ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) | 10976 | // InternalProblem.g:3423:1: ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) |
9381 | // InternalProblem.g:2950:2: ( rule__Atom__TransitiveClosureAssignment_1 )? | 10977 | // InternalProblem.g:3424:2: ( rule__Atom__TransitiveClosureAssignment_1 )? |
9382 | { | 10978 | { |
9383 | before(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1()); | 10979 | before(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1()); |
9384 | // InternalProblem.g:2951:2: ( rule__Atom__TransitiveClosureAssignment_1 )? | 10980 | // InternalProblem.g:3425:2: ( rule__Atom__TransitiveClosureAssignment_1 )? |
9385 | int alt38=2; | 10981 | int alt44=2; |
9386 | int LA38_0 = input.LA(1); | 10982 | int LA44_0 = input.LA(1); |
9387 | 10983 | ||
9388 | if ( (LA38_0==43) ) { | 10984 | if ( (LA44_0==24) ) { |
9389 | alt38=1; | 10985 | alt44=1; |
9390 | } | 10986 | } |
9391 | switch (alt38) { | 10987 | switch (alt44) { |
9392 | case 1 : | 10988 | case 1 : |
9393 | // InternalProblem.g:2951:3: rule__Atom__TransitiveClosureAssignment_1 | 10989 | // InternalProblem.g:3425:3: rule__Atom__TransitiveClosureAssignment_1 |
9394 | { | 10990 | { |
9395 | pushFollow(FOLLOW_2); | 10991 | pushFollow(FOLLOW_2); |
9396 | rule__Atom__TransitiveClosureAssignment_1(); | 10992 | rule__Atom__TransitiveClosureAssignment_1(); |
@@ -9426,16 +11022,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9426 | 11022 | ||
9427 | 11023 | ||
9428 | // $ANTLR start "rule__Atom__Group__2" | 11024 | // $ANTLR start "rule__Atom__Group__2" |
9429 | // InternalProblem.g:2959:1: rule__Atom__Group__2 : rule__Atom__Group__2__Impl rule__Atom__Group__3 ; | 11025 | // InternalProblem.g:3433:1: rule__Atom__Group__2 : rule__Atom__Group__2__Impl rule__Atom__Group__3 ; |
9430 | public final void rule__Atom__Group__2() throws RecognitionException { | 11026 | public final void rule__Atom__Group__2() throws RecognitionException { |
9431 | 11027 | ||
9432 | int stackSize = keepStackSize(); | 11028 | int stackSize = keepStackSize(); |
9433 | 11029 | ||
9434 | try { | 11030 | try { |
9435 | // InternalProblem.g:2963:1: ( rule__Atom__Group__2__Impl rule__Atom__Group__3 ) | 11031 | // InternalProblem.g:3437:1: ( rule__Atom__Group__2__Impl rule__Atom__Group__3 ) |
9436 | // InternalProblem.g:2964:2: rule__Atom__Group__2__Impl rule__Atom__Group__3 | 11032 | // InternalProblem.g:3438:2: rule__Atom__Group__2__Impl rule__Atom__Group__3 |
9437 | { | 11033 | { |
9438 | pushFollow(FOLLOW_23); | 11034 | pushFollow(FOLLOW_29); |
9439 | rule__Atom__Group__2__Impl(); | 11035 | rule__Atom__Group__2__Impl(); |
9440 | 11036 | ||
9441 | state._fsp--; | 11037 | state._fsp--; |
@@ -9464,20 +11060,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9464 | 11060 | ||
9465 | 11061 | ||
9466 | // $ANTLR start "rule__Atom__Group__2__Impl" | 11062 | // $ANTLR start "rule__Atom__Group__2__Impl" |
9467 | // InternalProblem.g:2971:1: rule__Atom__Group__2__Impl : ( '(' ) ; | 11063 | // InternalProblem.g:3445:1: rule__Atom__Group__2__Impl : ( '(' ) ; |
9468 | public final void rule__Atom__Group__2__Impl() throws RecognitionException { | 11064 | public final void rule__Atom__Group__2__Impl() throws RecognitionException { |
9469 | 11065 | ||
9470 | int stackSize = keepStackSize(); | 11066 | int stackSize = keepStackSize(); |
9471 | 11067 | ||
9472 | try { | 11068 | try { |
9473 | // InternalProblem.g:2975:1: ( ( '(' ) ) | 11069 | // InternalProblem.g:3449:1: ( ( '(' ) ) |
9474 | // InternalProblem.g:2976:1: ( '(' ) | 11070 | // InternalProblem.g:3450:1: ( '(' ) |
9475 | { | 11071 | { |
9476 | // InternalProblem.g:2976:1: ( '(' ) | 11072 | // InternalProblem.g:3450:1: ( '(' ) |
9477 | // InternalProblem.g:2977:2: '(' | 11073 | // InternalProblem.g:3451:2: '(' |
9478 | { | 11074 | { |
9479 | before(grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); | 11075 | before(grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); |
9480 | match(input,33,FOLLOW_2); | 11076 | match(input,37,FOLLOW_2); |
9481 | after(grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); | 11077 | after(grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); |
9482 | 11078 | ||
9483 | } | 11079 | } |
@@ -9501,16 +11097,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9501 | 11097 | ||
9502 | 11098 | ||
9503 | // $ANTLR start "rule__Atom__Group__3" | 11099 | // $ANTLR start "rule__Atom__Group__3" |
9504 | // InternalProblem.g:2986:1: rule__Atom__Group__3 : rule__Atom__Group__3__Impl rule__Atom__Group__4 ; | 11100 | // InternalProblem.g:3460:1: rule__Atom__Group__3 : rule__Atom__Group__3__Impl rule__Atom__Group__4 ; |
9505 | public final void rule__Atom__Group__3() throws RecognitionException { | 11101 | public final void rule__Atom__Group__3() throws RecognitionException { |
9506 | 11102 | ||
9507 | int stackSize = keepStackSize(); | 11103 | int stackSize = keepStackSize(); |
9508 | 11104 | ||
9509 | try { | 11105 | try { |
9510 | // InternalProblem.g:2990:1: ( rule__Atom__Group__3__Impl rule__Atom__Group__4 ) | 11106 | // InternalProblem.g:3464:1: ( rule__Atom__Group__3__Impl rule__Atom__Group__4 ) |
9511 | // InternalProblem.g:2991:2: rule__Atom__Group__3__Impl rule__Atom__Group__4 | 11107 | // InternalProblem.g:3465:2: rule__Atom__Group__3__Impl rule__Atom__Group__4 |
9512 | { | 11108 | { |
9513 | pushFollow(FOLLOW_23); | 11109 | pushFollow(FOLLOW_29); |
9514 | rule__Atom__Group__3__Impl(); | 11110 | rule__Atom__Group__3__Impl(); |
9515 | 11111 | ||
9516 | state._fsp--; | 11112 | state._fsp--; |
@@ -9539,29 +11135,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9539 | 11135 | ||
9540 | 11136 | ||
9541 | // $ANTLR start "rule__Atom__Group__3__Impl" | 11137 | // $ANTLR start "rule__Atom__Group__3__Impl" |
9542 | // InternalProblem.g:2998:1: rule__Atom__Group__3__Impl : ( ( rule__Atom__Group_3__0 )? ) ; | 11138 | // InternalProblem.g:3472:1: rule__Atom__Group__3__Impl : ( ( rule__Atom__Group_3__0 )? ) ; |
9543 | public final void rule__Atom__Group__3__Impl() throws RecognitionException { | 11139 | public final void rule__Atom__Group__3__Impl() throws RecognitionException { |
9544 | 11140 | ||
9545 | int stackSize = keepStackSize(); | 11141 | int stackSize = keepStackSize(); |
9546 | 11142 | ||
9547 | try { | 11143 | try { |
9548 | // InternalProblem.g:3002:1: ( ( ( rule__Atom__Group_3__0 )? ) ) | 11144 | // InternalProblem.g:3476:1: ( ( ( rule__Atom__Group_3__0 )? ) ) |
9549 | // InternalProblem.g:3003:1: ( ( rule__Atom__Group_3__0 )? ) | 11145 | // InternalProblem.g:3477:1: ( ( rule__Atom__Group_3__0 )? ) |
9550 | { | 11146 | { |
9551 | // InternalProblem.g:3003:1: ( ( rule__Atom__Group_3__0 )? ) | 11147 | // InternalProblem.g:3477:1: ( ( rule__Atom__Group_3__0 )? ) |
9552 | // InternalProblem.g:3004:2: ( rule__Atom__Group_3__0 )? | 11148 | // InternalProblem.g:3478:2: ( rule__Atom__Group_3__0 )? |
9553 | { | 11149 | { |
9554 | before(grammarAccess.getAtomAccess().getGroup_3()); | 11150 | before(grammarAccess.getAtomAccess().getGroup_3()); |
9555 | // InternalProblem.g:3005:2: ( rule__Atom__Group_3__0 )? | 11151 | // InternalProblem.g:3479:2: ( rule__Atom__Group_3__0 )? |
9556 | int alt39=2; | 11152 | int alt45=2; |
9557 | int LA39_0 = input.LA(1); | 11153 | int LA45_0 = input.LA(1); |
9558 | 11154 | ||
9559 | if ( ((LA39_0>=RULE_QUOTED_ID && LA39_0<=RULE_ID)||(LA39_0>=19 && LA39_0<=20)) ) { | 11155 | if ( ((LA45_0>=RULE_INT && LA45_0<=RULE_STRING)||(LA45_0>=19 && LA45_0<=23)) ) { |
9560 | alt39=1; | 11156 | alt45=1; |
9561 | } | 11157 | } |
9562 | switch (alt39) { | 11158 | switch (alt45) { |
9563 | case 1 : | 11159 | case 1 : |
9564 | // InternalProblem.g:3005:3: rule__Atom__Group_3__0 | 11160 | // InternalProblem.g:3479:3: rule__Atom__Group_3__0 |
9565 | { | 11161 | { |
9566 | pushFollow(FOLLOW_2); | 11162 | pushFollow(FOLLOW_2); |
9567 | rule__Atom__Group_3__0(); | 11163 | rule__Atom__Group_3__0(); |
@@ -9597,14 +11193,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9597 | 11193 | ||
9598 | 11194 | ||
9599 | // $ANTLR start "rule__Atom__Group__4" | 11195 | // $ANTLR start "rule__Atom__Group__4" |
9600 | // InternalProblem.g:3013:1: rule__Atom__Group__4 : rule__Atom__Group__4__Impl ; | 11196 | // InternalProblem.g:3487:1: rule__Atom__Group__4 : rule__Atom__Group__4__Impl ; |
9601 | public final void rule__Atom__Group__4() throws RecognitionException { | 11197 | public final void rule__Atom__Group__4() throws RecognitionException { |
9602 | 11198 | ||
9603 | int stackSize = keepStackSize(); | 11199 | int stackSize = keepStackSize(); |
9604 | 11200 | ||
9605 | try { | 11201 | try { |
9606 | // InternalProblem.g:3017:1: ( rule__Atom__Group__4__Impl ) | 11202 | // InternalProblem.g:3491:1: ( rule__Atom__Group__4__Impl ) |
9607 | // InternalProblem.g:3018:2: rule__Atom__Group__4__Impl | 11203 | // InternalProblem.g:3492:2: rule__Atom__Group__4__Impl |
9608 | { | 11204 | { |
9609 | pushFollow(FOLLOW_2); | 11205 | pushFollow(FOLLOW_2); |
9610 | rule__Atom__Group__4__Impl(); | 11206 | rule__Atom__Group__4__Impl(); |
@@ -9630,20 +11226,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9630 | 11226 | ||
9631 | 11227 | ||
9632 | // $ANTLR start "rule__Atom__Group__4__Impl" | 11228 | // $ANTLR start "rule__Atom__Group__4__Impl" |
9633 | // InternalProblem.g:3024:1: rule__Atom__Group__4__Impl : ( ')' ) ; | 11229 | // InternalProblem.g:3498:1: rule__Atom__Group__4__Impl : ( ')' ) ; |
9634 | public final void rule__Atom__Group__4__Impl() throws RecognitionException { | 11230 | public final void rule__Atom__Group__4__Impl() throws RecognitionException { |
9635 | 11231 | ||
9636 | int stackSize = keepStackSize(); | 11232 | int stackSize = keepStackSize(); |
9637 | 11233 | ||
9638 | try { | 11234 | try { |
9639 | // InternalProblem.g:3028:1: ( ( ')' ) ) | 11235 | // InternalProblem.g:3502:1: ( ( ')' ) ) |
9640 | // InternalProblem.g:3029:1: ( ')' ) | 11236 | // InternalProblem.g:3503:1: ( ')' ) |
9641 | { | 11237 | { |
9642 | // InternalProblem.g:3029:1: ( ')' ) | 11238 | // InternalProblem.g:3503:1: ( ')' ) |
9643 | // InternalProblem.g:3030:2: ')' | 11239 | // InternalProblem.g:3504:2: ')' |
9644 | { | 11240 | { |
9645 | before(grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); | 11241 | before(grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); |
9646 | match(input,34,FOLLOW_2); | 11242 | match(input,38,FOLLOW_2); |
9647 | after(grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); | 11243 | after(grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); |
9648 | 11244 | ||
9649 | } | 11245 | } |
@@ -9667,14 +11263,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9667 | 11263 | ||
9668 | 11264 | ||
9669 | // $ANTLR start "rule__Atom__Group_3__0" | 11265 | // $ANTLR start "rule__Atom__Group_3__0" |
9670 | // InternalProblem.g:3040:1: rule__Atom__Group_3__0 : rule__Atom__Group_3__0__Impl rule__Atom__Group_3__1 ; | 11266 | // InternalProblem.g:3514:1: rule__Atom__Group_3__0 : rule__Atom__Group_3__0__Impl rule__Atom__Group_3__1 ; |
9671 | public final void rule__Atom__Group_3__0() throws RecognitionException { | 11267 | public final void rule__Atom__Group_3__0() throws RecognitionException { |
9672 | 11268 | ||
9673 | int stackSize = keepStackSize(); | 11269 | int stackSize = keepStackSize(); |
9674 | 11270 | ||
9675 | try { | 11271 | try { |
9676 | // InternalProblem.g:3044:1: ( rule__Atom__Group_3__0__Impl rule__Atom__Group_3__1 ) | 11272 | // InternalProblem.g:3518:1: ( rule__Atom__Group_3__0__Impl rule__Atom__Group_3__1 ) |
9677 | // InternalProblem.g:3045:2: rule__Atom__Group_3__0__Impl rule__Atom__Group_3__1 | 11273 | // InternalProblem.g:3519:2: rule__Atom__Group_3__0__Impl rule__Atom__Group_3__1 |
9678 | { | 11274 | { |
9679 | pushFollow(FOLLOW_9); | 11275 | pushFollow(FOLLOW_9); |
9680 | rule__Atom__Group_3__0__Impl(); | 11276 | rule__Atom__Group_3__0__Impl(); |
@@ -9705,21 +11301,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9705 | 11301 | ||
9706 | 11302 | ||
9707 | // $ANTLR start "rule__Atom__Group_3__0__Impl" | 11303 | // $ANTLR start "rule__Atom__Group_3__0__Impl" |
9708 | // InternalProblem.g:3052:1: rule__Atom__Group_3__0__Impl : ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) ; | 11304 | // InternalProblem.g:3526:1: rule__Atom__Group_3__0__Impl : ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) ; |
9709 | public final void rule__Atom__Group_3__0__Impl() throws RecognitionException { | 11305 | public final void rule__Atom__Group_3__0__Impl() throws RecognitionException { |
9710 | 11306 | ||
9711 | int stackSize = keepStackSize(); | 11307 | int stackSize = keepStackSize(); |
9712 | 11308 | ||
9713 | try { | 11309 | try { |
9714 | // InternalProblem.g:3056:1: ( ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) ) | 11310 | // InternalProblem.g:3530:1: ( ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) ) |
9715 | // InternalProblem.g:3057:1: ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) | 11311 | // InternalProblem.g:3531:1: ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) |
9716 | { | 11312 | { |
9717 | // InternalProblem.g:3057:1: ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) | 11313 | // InternalProblem.g:3531:1: ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) |
9718 | // InternalProblem.g:3058:2: ( rule__Atom__ArgumentsAssignment_3_0 ) | 11314 | // InternalProblem.g:3532:2: ( rule__Atom__ArgumentsAssignment_3_0 ) |
9719 | { | 11315 | { |
9720 | before(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0()); | 11316 | before(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0()); |
9721 | // InternalProblem.g:3059:2: ( rule__Atom__ArgumentsAssignment_3_0 ) | 11317 | // InternalProblem.g:3533:2: ( rule__Atom__ArgumentsAssignment_3_0 ) |
9722 | // InternalProblem.g:3059:3: rule__Atom__ArgumentsAssignment_3_0 | 11318 | // InternalProblem.g:3533:3: rule__Atom__ArgumentsAssignment_3_0 |
9723 | { | 11319 | { |
9724 | pushFollow(FOLLOW_2); | 11320 | pushFollow(FOLLOW_2); |
9725 | rule__Atom__ArgumentsAssignment_3_0(); | 11321 | rule__Atom__ArgumentsAssignment_3_0(); |
@@ -9752,14 +11348,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9752 | 11348 | ||
9753 | 11349 | ||
9754 | // $ANTLR start "rule__Atom__Group_3__1" | 11350 | // $ANTLR start "rule__Atom__Group_3__1" |
9755 | // InternalProblem.g:3067:1: rule__Atom__Group_3__1 : rule__Atom__Group_3__1__Impl ; | 11351 | // InternalProblem.g:3541:1: rule__Atom__Group_3__1 : rule__Atom__Group_3__1__Impl ; |
9756 | public final void rule__Atom__Group_3__1() throws RecognitionException { | 11352 | public final void rule__Atom__Group_3__1() throws RecognitionException { |
9757 | 11353 | ||
9758 | int stackSize = keepStackSize(); | 11354 | int stackSize = keepStackSize(); |
9759 | 11355 | ||
9760 | try { | 11356 | try { |
9761 | // InternalProblem.g:3071:1: ( rule__Atom__Group_3__1__Impl ) | 11357 | // InternalProblem.g:3545:1: ( rule__Atom__Group_3__1__Impl ) |
9762 | // InternalProblem.g:3072:2: rule__Atom__Group_3__1__Impl | 11358 | // InternalProblem.g:3546:2: rule__Atom__Group_3__1__Impl |
9763 | { | 11359 | { |
9764 | pushFollow(FOLLOW_2); | 11360 | pushFollow(FOLLOW_2); |
9765 | rule__Atom__Group_3__1__Impl(); | 11361 | rule__Atom__Group_3__1__Impl(); |
@@ -9785,33 +11381,33 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9785 | 11381 | ||
9786 | 11382 | ||
9787 | // $ANTLR start "rule__Atom__Group_3__1__Impl" | 11383 | // $ANTLR start "rule__Atom__Group_3__1__Impl" |
9788 | // InternalProblem.g:3078:1: rule__Atom__Group_3__1__Impl : ( ( rule__Atom__Group_3_1__0 )* ) ; | 11384 | // InternalProblem.g:3552:1: rule__Atom__Group_3__1__Impl : ( ( rule__Atom__Group_3_1__0 )* ) ; |
9789 | public final void rule__Atom__Group_3__1__Impl() throws RecognitionException { | 11385 | public final void rule__Atom__Group_3__1__Impl() throws RecognitionException { |
9790 | 11386 | ||
9791 | int stackSize = keepStackSize(); | 11387 | int stackSize = keepStackSize(); |
9792 | 11388 | ||
9793 | try { | 11389 | try { |
9794 | // InternalProblem.g:3082:1: ( ( ( rule__Atom__Group_3_1__0 )* ) ) | 11390 | // InternalProblem.g:3556:1: ( ( ( rule__Atom__Group_3_1__0 )* ) ) |
9795 | // InternalProblem.g:3083:1: ( ( rule__Atom__Group_3_1__0 )* ) | 11391 | // InternalProblem.g:3557:1: ( ( rule__Atom__Group_3_1__0 )* ) |
9796 | { | 11392 | { |
9797 | // InternalProblem.g:3083:1: ( ( rule__Atom__Group_3_1__0 )* ) | 11393 | // InternalProblem.g:3557:1: ( ( rule__Atom__Group_3_1__0 )* ) |
9798 | // InternalProblem.g:3084:2: ( rule__Atom__Group_3_1__0 )* | 11394 | // InternalProblem.g:3558:2: ( rule__Atom__Group_3_1__0 )* |
9799 | { | 11395 | { |
9800 | before(grammarAccess.getAtomAccess().getGroup_3_1()); | 11396 | before(grammarAccess.getAtomAccess().getGroup_3_1()); |
9801 | // InternalProblem.g:3085:2: ( rule__Atom__Group_3_1__0 )* | 11397 | // InternalProblem.g:3559:2: ( rule__Atom__Group_3_1__0 )* |
9802 | loop40: | 11398 | loop46: |
9803 | do { | 11399 | do { |
9804 | int alt40=2; | 11400 | int alt46=2; |
9805 | int LA40_0 = input.LA(1); | 11401 | int LA46_0 = input.LA(1); |
9806 | 11402 | ||
9807 | if ( (LA40_0==13) ) { | 11403 | if ( (LA46_0==13) ) { |
9808 | alt40=1; | 11404 | alt46=1; |
9809 | } | 11405 | } |
9810 | 11406 | ||
9811 | 11407 | ||
9812 | switch (alt40) { | 11408 | switch (alt46) { |
9813 | case 1 : | 11409 | case 1 : |
9814 | // InternalProblem.g:3085:3: rule__Atom__Group_3_1__0 | 11410 | // InternalProblem.g:3559:3: rule__Atom__Group_3_1__0 |
9815 | { | 11411 | { |
9816 | pushFollow(FOLLOW_10); | 11412 | pushFollow(FOLLOW_10); |
9817 | rule__Atom__Group_3_1__0(); | 11413 | rule__Atom__Group_3_1__0(); |
@@ -9823,7 +11419,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9823 | break; | 11419 | break; |
9824 | 11420 | ||
9825 | default : | 11421 | default : |
9826 | break loop40; | 11422 | break loop46; |
9827 | } | 11423 | } |
9828 | } while (true); | 11424 | } while (true); |
9829 | 11425 | ||
@@ -9850,16 +11446,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9850 | 11446 | ||
9851 | 11447 | ||
9852 | // $ANTLR start "rule__Atom__Group_3_1__0" | 11448 | // $ANTLR start "rule__Atom__Group_3_1__0" |
9853 | // InternalProblem.g:3094:1: rule__Atom__Group_3_1__0 : rule__Atom__Group_3_1__0__Impl rule__Atom__Group_3_1__1 ; | 11449 | // InternalProblem.g:3568:1: rule__Atom__Group_3_1__0 : rule__Atom__Group_3_1__0__Impl rule__Atom__Group_3_1__1 ; |
9854 | public final void rule__Atom__Group_3_1__0() throws RecognitionException { | 11450 | public final void rule__Atom__Group_3_1__0() throws RecognitionException { |
9855 | 11451 | ||
9856 | int stackSize = keepStackSize(); | 11452 | int stackSize = keepStackSize(); |
9857 | 11453 | ||
9858 | try { | 11454 | try { |
9859 | // InternalProblem.g:3098:1: ( rule__Atom__Group_3_1__0__Impl rule__Atom__Group_3_1__1 ) | 11455 | // InternalProblem.g:3572:1: ( rule__Atom__Group_3_1__0__Impl rule__Atom__Group_3_1__1 ) |
9860 | // InternalProblem.g:3099:2: rule__Atom__Group_3_1__0__Impl rule__Atom__Group_3_1__1 | 11456 | // InternalProblem.g:3573:2: rule__Atom__Group_3_1__0__Impl rule__Atom__Group_3_1__1 |
9861 | { | 11457 | { |
9862 | pushFollow(FOLLOW_5); | 11458 | pushFollow(FOLLOW_30); |
9863 | rule__Atom__Group_3_1__0__Impl(); | 11459 | rule__Atom__Group_3_1__0__Impl(); |
9864 | 11460 | ||
9865 | state._fsp--; | 11461 | state._fsp--; |
@@ -9888,17 +11484,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9888 | 11484 | ||
9889 | 11485 | ||
9890 | // $ANTLR start "rule__Atom__Group_3_1__0__Impl" | 11486 | // $ANTLR start "rule__Atom__Group_3_1__0__Impl" |
9891 | // InternalProblem.g:3106:1: rule__Atom__Group_3_1__0__Impl : ( ',' ) ; | 11487 | // InternalProblem.g:3580:1: rule__Atom__Group_3_1__0__Impl : ( ',' ) ; |
9892 | public final void rule__Atom__Group_3_1__0__Impl() throws RecognitionException { | 11488 | public final void rule__Atom__Group_3_1__0__Impl() throws RecognitionException { |
9893 | 11489 | ||
9894 | int stackSize = keepStackSize(); | 11490 | int stackSize = keepStackSize(); |
9895 | 11491 | ||
9896 | try { | 11492 | try { |
9897 | // InternalProblem.g:3110:1: ( ( ',' ) ) | 11493 | // InternalProblem.g:3584:1: ( ( ',' ) ) |
9898 | // InternalProblem.g:3111:1: ( ',' ) | 11494 | // InternalProblem.g:3585:1: ( ',' ) |
9899 | { | 11495 | { |
9900 | // InternalProblem.g:3111:1: ( ',' ) | 11496 | // InternalProblem.g:3585:1: ( ',' ) |
9901 | // InternalProblem.g:3112:2: ',' | 11497 | // InternalProblem.g:3586:2: ',' |
9902 | { | 11498 | { |
9903 | before(grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); | 11499 | before(grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); |
9904 | match(input,13,FOLLOW_2); | 11500 | match(input,13,FOLLOW_2); |
@@ -9925,14 +11521,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9925 | 11521 | ||
9926 | 11522 | ||
9927 | // $ANTLR start "rule__Atom__Group_3_1__1" | 11523 | // $ANTLR start "rule__Atom__Group_3_1__1" |
9928 | // InternalProblem.g:3121:1: rule__Atom__Group_3_1__1 : rule__Atom__Group_3_1__1__Impl ; | 11524 | // InternalProblem.g:3595:1: rule__Atom__Group_3_1__1 : rule__Atom__Group_3_1__1__Impl ; |
9929 | public final void rule__Atom__Group_3_1__1() throws RecognitionException { | 11525 | public final void rule__Atom__Group_3_1__1() throws RecognitionException { |
9930 | 11526 | ||
9931 | int stackSize = keepStackSize(); | 11527 | int stackSize = keepStackSize(); |
9932 | 11528 | ||
9933 | try { | 11529 | try { |
9934 | // InternalProblem.g:3125:1: ( rule__Atom__Group_3_1__1__Impl ) | 11530 | // InternalProblem.g:3599:1: ( rule__Atom__Group_3_1__1__Impl ) |
9935 | // InternalProblem.g:3126:2: rule__Atom__Group_3_1__1__Impl | 11531 | // InternalProblem.g:3600:2: rule__Atom__Group_3_1__1__Impl |
9936 | { | 11532 | { |
9937 | pushFollow(FOLLOW_2); | 11533 | pushFollow(FOLLOW_2); |
9938 | rule__Atom__Group_3_1__1__Impl(); | 11534 | rule__Atom__Group_3_1__1__Impl(); |
@@ -9958,21 +11554,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
9958 | 11554 | ||
9959 | 11555 | ||
9960 | // $ANTLR start "rule__Atom__Group_3_1__1__Impl" | 11556 | // $ANTLR start "rule__Atom__Group_3_1__1__Impl" |
9961 | // InternalProblem.g:3132:1: rule__Atom__Group_3_1__1__Impl : ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) ; | 11557 | // InternalProblem.g:3606:1: rule__Atom__Group_3_1__1__Impl : ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) ; |
9962 | public final void rule__Atom__Group_3_1__1__Impl() throws RecognitionException { | 11558 | public final void rule__Atom__Group_3_1__1__Impl() throws RecognitionException { |
9963 | 11559 | ||
9964 | int stackSize = keepStackSize(); | 11560 | int stackSize = keepStackSize(); |
9965 | 11561 | ||
9966 | try { | 11562 | try { |
9967 | // InternalProblem.g:3136:1: ( ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) ) | 11563 | // InternalProblem.g:3610:1: ( ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) ) |
9968 | // InternalProblem.g:3137:1: ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) | 11564 | // InternalProblem.g:3611:1: ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) |
9969 | { | 11565 | { |
9970 | // InternalProblem.g:3137:1: ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) | 11566 | // InternalProblem.g:3611:1: ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) |
9971 | // InternalProblem.g:3138:2: ( rule__Atom__ArgumentsAssignment_3_1_1 ) | 11567 | // InternalProblem.g:3612:2: ( rule__Atom__ArgumentsAssignment_3_1_1 ) |
9972 | { | 11568 | { |
9973 | before(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1()); | 11569 | before(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1()); |
9974 | // InternalProblem.g:3139:2: ( rule__Atom__ArgumentsAssignment_3_1_1 ) | 11570 | // InternalProblem.g:3613:2: ( rule__Atom__ArgumentsAssignment_3_1_1 ) |
9975 | // InternalProblem.g:3139:3: rule__Atom__ArgumentsAssignment_3_1_1 | 11571 | // InternalProblem.g:3613:3: rule__Atom__ArgumentsAssignment_3_1_1 |
9976 | { | 11572 | { |
9977 | pushFollow(FOLLOW_2); | 11573 | pushFollow(FOLLOW_2); |
9978 | rule__Atom__ArgumentsAssignment_3_1_1(); | 11574 | rule__Atom__ArgumentsAssignment_3_1_1(); |
@@ -10005,14 +11601,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10005 | 11601 | ||
10006 | 11602 | ||
10007 | // $ANTLR start "rule__Assertion__Group__0" | 11603 | // $ANTLR start "rule__Assertion__Group__0" |
10008 | // InternalProblem.g:3148:1: rule__Assertion__Group__0 : rule__Assertion__Group__0__Impl rule__Assertion__Group__1 ; | 11604 | // InternalProblem.g:3622:1: rule__Assertion__Group__0 : rule__Assertion__Group__0__Impl rule__Assertion__Group__1 ; |
10009 | public final void rule__Assertion__Group__0() throws RecognitionException { | 11605 | public final void rule__Assertion__Group__0() throws RecognitionException { |
10010 | 11606 | ||
10011 | int stackSize = keepStackSize(); | 11607 | int stackSize = keepStackSize(); |
10012 | 11608 | ||
10013 | try { | 11609 | try { |
10014 | // InternalProblem.g:3152:1: ( rule__Assertion__Group__0__Impl rule__Assertion__Group__1 ) | 11610 | // InternalProblem.g:3626:1: ( rule__Assertion__Group__0__Impl rule__Assertion__Group__1 ) |
10015 | // InternalProblem.g:3153:2: rule__Assertion__Group__0__Impl rule__Assertion__Group__1 | 11611 | // InternalProblem.g:3627:2: rule__Assertion__Group__0__Impl rule__Assertion__Group__1 |
10016 | { | 11612 | { |
10017 | pushFollow(FOLLOW_6); | 11613 | pushFollow(FOLLOW_6); |
10018 | rule__Assertion__Group__0__Impl(); | 11614 | rule__Assertion__Group__0__Impl(); |
@@ -10043,21 +11639,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10043 | 11639 | ||
10044 | 11640 | ||
10045 | // $ANTLR start "rule__Assertion__Group__0__Impl" | 11641 | // $ANTLR start "rule__Assertion__Group__0__Impl" |
10046 | // InternalProblem.g:3160:1: rule__Assertion__Group__0__Impl : ( ( rule__Assertion__Alternatives_0 ) ) ; | 11642 | // InternalProblem.g:3634:1: rule__Assertion__Group__0__Impl : ( ( rule__Assertion__Alternatives_0 ) ) ; |
10047 | public final void rule__Assertion__Group__0__Impl() throws RecognitionException { | 11643 | public final void rule__Assertion__Group__0__Impl() throws RecognitionException { |
10048 | 11644 | ||
10049 | int stackSize = keepStackSize(); | 11645 | int stackSize = keepStackSize(); |
10050 | 11646 | ||
10051 | try { | 11647 | try { |
10052 | // InternalProblem.g:3164:1: ( ( ( rule__Assertion__Alternatives_0 ) ) ) | 11648 | // InternalProblem.g:3638:1: ( ( ( rule__Assertion__Alternatives_0 ) ) ) |
10053 | // InternalProblem.g:3165:1: ( ( rule__Assertion__Alternatives_0 ) ) | 11649 | // InternalProblem.g:3639:1: ( ( rule__Assertion__Alternatives_0 ) ) |
10054 | { | 11650 | { |
10055 | // InternalProblem.g:3165:1: ( ( rule__Assertion__Alternatives_0 ) ) | 11651 | // InternalProblem.g:3639:1: ( ( rule__Assertion__Alternatives_0 ) ) |
10056 | // InternalProblem.g:3166:2: ( rule__Assertion__Alternatives_0 ) | 11652 | // InternalProblem.g:3640:2: ( rule__Assertion__Alternatives_0 ) |
10057 | { | 11653 | { |
10058 | before(grammarAccess.getAssertionAccess().getAlternatives_0()); | 11654 | before(grammarAccess.getAssertionAccess().getAlternatives_0()); |
10059 | // InternalProblem.g:3167:2: ( rule__Assertion__Alternatives_0 ) | 11655 | // InternalProblem.g:3641:2: ( rule__Assertion__Alternatives_0 ) |
10060 | // InternalProblem.g:3167:3: rule__Assertion__Alternatives_0 | 11656 | // InternalProblem.g:3641:3: rule__Assertion__Alternatives_0 |
10061 | { | 11657 | { |
10062 | pushFollow(FOLLOW_2); | 11658 | pushFollow(FOLLOW_2); |
10063 | rule__Assertion__Alternatives_0(); | 11659 | rule__Assertion__Alternatives_0(); |
@@ -10090,14 +11686,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10090 | 11686 | ||
10091 | 11687 | ||
10092 | // $ANTLR start "rule__Assertion__Group__1" | 11688 | // $ANTLR start "rule__Assertion__Group__1" |
10093 | // InternalProblem.g:3175:1: rule__Assertion__Group__1 : rule__Assertion__Group__1__Impl ; | 11689 | // InternalProblem.g:3649:1: rule__Assertion__Group__1 : rule__Assertion__Group__1__Impl ; |
10094 | public final void rule__Assertion__Group__1() throws RecognitionException { | 11690 | public final void rule__Assertion__Group__1() throws RecognitionException { |
10095 | 11691 | ||
10096 | int stackSize = keepStackSize(); | 11692 | int stackSize = keepStackSize(); |
10097 | 11693 | ||
10098 | try { | 11694 | try { |
10099 | // InternalProblem.g:3179:1: ( rule__Assertion__Group__1__Impl ) | 11695 | // InternalProblem.g:3653:1: ( rule__Assertion__Group__1__Impl ) |
10100 | // InternalProblem.g:3180:2: rule__Assertion__Group__1__Impl | 11696 | // InternalProblem.g:3654:2: rule__Assertion__Group__1__Impl |
10101 | { | 11697 | { |
10102 | pushFollow(FOLLOW_2); | 11698 | pushFollow(FOLLOW_2); |
10103 | rule__Assertion__Group__1__Impl(); | 11699 | rule__Assertion__Group__1__Impl(); |
@@ -10123,17 +11719,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10123 | 11719 | ||
10124 | 11720 | ||
10125 | // $ANTLR start "rule__Assertion__Group__1__Impl" | 11721 | // $ANTLR start "rule__Assertion__Group__1__Impl" |
10126 | // InternalProblem.g:3186:1: rule__Assertion__Group__1__Impl : ( '.' ) ; | 11722 | // InternalProblem.g:3660:1: rule__Assertion__Group__1__Impl : ( '.' ) ; |
10127 | public final void rule__Assertion__Group__1__Impl() throws RecognitionException { | 11723 | public final void rule__Assertion__Group__1__Impl() throws RecognitionException { |
10128 | 11724 | ||
10129 | int stackSize = keepStackSize(); | 11725 | int stackSize = keepStackSize(); |
10130 | 11726 | ||
10131 | try { | 11727 | try { |
10132 | // InternalProblem.g:3190:1: ( ( '.' ) ) | 11728 | // InternalProblem.g:3664:1: ( ( '.' ) ) |
10133 | // InternalProblem.g:3191:1: ( '.' ) | 11729 | // InternalProblem.g:3665:1: ( '.' ) |
10134 | { | 11730 | { |
10135 | // InternalProblem.g:3191:1: ( '.' ) | 11731 | // InternalProblem.g:3665:1: ( '.' ) |
10136 | // InternalProblem.g:3192:2: '.' | 11732 | // InternalProblem.g:3666:2: '.' |
10137 | { | 11733 | { |
10138 | before(grammarAccess.getAssertionAccess().getFullStopKeyword_1()); | 11734 | before(grammarAccess.getAssertionAccess().getFullStopKeyword_1()); |
10139 | match(input,12,FOLLOW_2); | 11735 | match(input,12,FOLLOW_2); |
@@ -10160,14 +11756,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10160 | 11756 | ||
10161 | 11757 | ||
10162 | // $ANTLR start "rule__Assertion__Group_0_0__0" | 11758 | // $ANTLR start "rule__Assertion__Group_0_0__0" |
10163 | // InternalProblem.g:3202:1: rule__Assertion__Group_0_0__0 : rule__Assertion__Group_0_0__0__Impl rule__Assertion__Group_0_0__1 ; | 11759 | // InternalProblem.g:3676:1: rule__Assertion__Group_0_0__0 : rule__Assertion__Group_0_0__0__Impl rule__Assertion__Group_0_0__1 ; |
10164 | public final void rule__Assertion__Group_0_0__0() throws RecognitionException { | 11760 | public final void rule__Assertion__Group_0_0__0() throws RecognitionException { |
10165 | 11761 | ||
10166 | int stackSize = keepStackSize(); | 11762 | int stackSize = keepStackSize(); |
10167 | 11763 | ||
10168 | try { | 11764 | try { |
10169 | // InternalProblem.g:3206:1: ( rule__Assertion__Group_0_0__0__Impl rule__Assertion__Group_0_0__1 ) | 11765 | // InternalProblem.g:3680:1: ( rule__Assertion__Group_0_0__0__Impl rule__Assertion__Group_0_0__1 ) |
10170 | // InternalProblem.g:3207:2: rule__Assertion__Group_0_0__0__Impl rule__Assertion__Group_0_0__1 | 11766 | // InternalProblem.g:3681:2: rule__Assertion__Group_0_0__0__Impl rule__Assertion__Group_0_0__1 |
10171 | { | 11767 | { |
10172 | pushFollow(FOLLOW_22); | 11768 | pushFollow(FOLLOW_22); |
10173 | rule__Assertion__Group_0_0__0__Impl(); | 11769 | rule__Assertion__Group_0_0__0__Impl(); |
@@ -10198,21 +11794,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10198 | 11794 | ||
10199 | 11795 | ||
10200 | // $ANTLR start "rule__Assertion__Group_0_0__0__Impl" | 11796 | // $ANTLR start "rule__Assertion__Group_0_0__0__Impl" |
10201 | // InternalProblem.g:3214:1: rule__Assertion__Group_0_0__0__Impl : ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) ; | 11797 | // InternalProblem.g:3688:1: rule__Assertion__Group_0_0__0__Impl : ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) ; |
10202 | public final void rule__Assertion__Group_0_0__0__Impl() throws RecognitionException { | 11798 | public final void rule__Assertion__Group_0_0__0__Impl() throws RecognitionException { |
10203 | 11799 | ||
10204 | int stackSize = keepStackSize(); | 11800 | int stackSize = keepStackSize(); |
10205 | 11801 | ||
10206 | try { | 11802 | try { |
10207 | // InternalProblem.g:3218:1: ( ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) ) | 11803 | // InternalProblem.g:3692:1: ( ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) ) |
10208 | // InternalProblem.g:3219:1: ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) | 11804 | // InternalProblem.g:3693:1: ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) |
10209 | { | 11805 | { |
10210 | // InternalProblem.g:3219:1: ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) | 11806 | // InternalProblem.g:3693:1: ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) |
10211 | // InternalProblem.g:3220:2: ( rule__Assertion__RelationAssignment_0_0_0 ) | 11807 | // InternalProblem.g:3694:2: ( rule__Assertion__RelationAssignment_0_0_0 ) |
10212 | { | 11808 | { |
10213 | before(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0()); | 11809 | before(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0()); |
10214 | // InternalProblem.g:3221:2: ( rule__Assertion__RelationAssignment_0_0_0 ) | 11810 | // InternalProblem.g:3695:2: ( rule__Assertion__RelationAssignment_0_0_0 ) |
10215 | // InternalProblem.g:3221:3: rule__Assertion__RelationAssignment_0_0_0 | 11811 | // InternalProblem.g:3695:3: rule__Assertion__RelationAssignment_0_0_0 |
10216 | { | 11812 | { |
10217 | pushFollow(FOLLOW_2); | 11813 | pushFollow(FOLLOW_2); |
10218 | rule__Assertion__RelationAssignment_0_0_0(); | 11814 | rule__Assertion__RelationAssignment_0_0_0(); |
@@ -10245,16 +11841,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10245 | 11841 | ||
10246 | 11842 | ||
10247 | // $ANTLR start "rule__Assertion__Group_0_0__1" | 11843 | // $ANTLR start "rule__Assertion__Group_0_0__1" |
10248 | // InternalProblem.g:3229:1: rule__Assertion__Group_0_0__1 : rule__Assertion__Group_0_0__1__Impl rule__Assertion__Group_0_0__2 ; | 11844 | // InternalProblem.g:3703:1: rule__Assertion__Group_0_0__1 : rule__Assertion__Group_0_0__1__Impl rule__Assertion__Group_0_0__2 ; |
10249 | public final void rule__Assertion__Group_0_0__1() throws RecognitionException { | 11845 | public final void rule__Assertion__Group_0_0__1() throws RecognitionException { |
10250 | 11846 | ||
10251 | int stackSize = keepStackSize(); | 11847 | int stackSize = keepStackSize(); |
10252 | 11848 | ||
10253 | try { | 11849 | try { |
10254 | // InternalProblem.g:3233:1: ( rule__Assertion__Group_0_0__1__Impl rule__Assertion__Group_0_0__2 ) | 11850 | // InternalProblem.g:3707:1: ( rule__Assertion__Group_0_0__1__Impl rule__Assertion__Group_0_0__2 ) |
10255 | // InternalProblem.g:3234:2: rule__Assertion__Group_0_0__1__Impl rule__Assertion__Group_0_0__2 | 11851 | // InternalProblem.g:3708:2: rule__Assertion__Group_0_0__1__Impl rule__Assertion__Group_0_0__2 |
10256 | { | 11852 | { |
10257 | pushFollow(FOLLOW_23); | 11853 | pushFollow(FOLLOW_29); |
10258 | rule__Assertion__Group_0_0__1__Impl(); | 11854 | rule__Assertion__Group_0_0__1__Impl(); |
10259 | 11855 | ||
10260 | state._fsp--; | 11856 | state._fsp--; |
@@ -10283,20 +11879,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10283 | 11879 | ||
10284 | 11880 | ||
10285 | // $ANTLR start "rule__Assertion__Group_0_0__1__Impl" | 11881 | // $ANTLR start "rule__Assertion__Group_0_0__1__Impl" |
10286 | // InternalProblem.g:3241:1: rule__Assertion__Group_0_0__1__Impl : ( '(' ) ; | 11882 | // InternalProblem.g:3715:1: rule__Assertion__Group_0_0__1__Impl : ( '(' ) ; |
10287 | public final void rule__Assertion__Group_0_0__1__Impl() throws RecognitionException { | 11883 | public final void rule__Assertion__Group_0_0__1__Impl() throws RecognitionException { |
10288 | 11884 | ||
10289 | int stackSize = keepStackSize(); | 11885 | int stackSize = keepStackSize(); |
10290 | 11886 | ||
10291 | try { | 11887 | try { |
10292 | // InternalProblem.g:3245:1: ( ( '(' ) ) | 11888 | // InternalProblem.g:3719:1: ( ( '(' ) ) |
10293 | // InternalProblem.g:3246:1: ( '(' ) | 11889 | // InternalProblem.g:3720:1: ( '(' ) |
10294 | { | 11890 | { |
10295 | // InternalProblem.g:3246:1: ( '(' ) | 11891 | // InternalProblem.g:3720:1: ( '(' ) |
10296 | // InternalProblem.g:3247:2: '(' | 11892 | // InternalProblem.g:3721:2: '(' |
10297 | { | 11893 | { |
10298 | before(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); | 11894 | before(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); |
10299 | match(input,33,FOLLOW_2); | 11895 | match(input,37,FOLLOW_2); |
10300 | after(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); | 11896 | after(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); |
10301 | 11897 | ||
10302 | } | 11898 | } |
@@ -10320,16 +11916,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10320 | 11916 | ||
10321 | 11917 | ||
10322 | // $ANTLR start "rule__Assertion__Group_0_0__2" | 11918 | // $ANTLR start "rule__Assertion__Group_0_0__2" |
10323 | // InternalProblem.g:3256:1: rule__Assertion__Group_0_0__2 : rule__Assertion__Group_0_0__2__Impl rule__Assertion__Group_0_0__3 ; | 11919 | // InternalProblem.g:3730:1: rule__Assertion__Group_0_0__2 : rule__Assertion__Group_0_0__2__Impl rule__Assertion__Group_0_0__3 ; |
10324 | public final void rule__Assertion__Group_0_0__2() throws RecognitionException { | 11920 | public final void rule__Assertion__Group_0_0__2() throws RecognitionException { |
10325 | 11921 | ||
10326 | int stackSize = keepStackSize(); | 11922 | int stackSize = keepStackSize(); |
10327 | 11923 | ||
10328 | try { | 11924 | try { |
10329 | // InternalProblem.g:3260:1: ( rule__Assertion__Group_0_0__2__Impl rule__Assertion__Group_0_0__3 ) | 11925 | // InternalProblem.g:3734:1: ( rule__Assertion__Group_0_0__2__Impl rule__Assertion__Group_0_0__3 ) |
10330 | // InternalProblem.g:3261:2: rule__Assertion__Group_0_0__2__Impl rule__Assertion__Group_0_0__3 | 11926 | // InternalProblem.g:3735:2: rule__Assertion__Group_0_0__2__Impl rule__Assertion__Group_0_0__3 |
10331 | { | 11927 | { |
10332 | pushFollow(FOLLOW_23); | 11928 | pushFollow(FOLLOW_29); |
10333 | rule__Assertion__Group_0_0__2__Impl(); | 11929 | rule__Assertion__Group_0_0__2__Impl(); |
10334 | 11930 | ||
10335 | state._fsp--; | 11931 | state._fsp--; |
@@ -10358,29 +11954,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10358 | 11954 | ||
10359 | 11955 | ||
10360 | // $ANTLR start "rule__Assertion__Group_0_0__2__Impl" | 11956 | // $ANTLR start "rule__Assertion__Group_0_0__2__Impl" |
10361 | // InternalProblem.g:3268:1: rule__Assertion__Group_0_0__2__Impl : ( ( rule__Assertion__Group_0_0_2__0 )? ) ; | 11957 | // InternalProblem.g:3742:1: rule__Assertion__Group_0_0__2__Impl : ( ( rule__Assertion__Group_0_0_2__0 )? ) ; |
10362 | public final void rule__Assertion__Group_0_0__2__Impl() throws RecognitionException { | 11958 | public final void rule__Assertion__Group_0_0__2__Impl() throws RecognitionException { |
10363 | 11959 | ||
10364 | int stackSize = keepStackSize(); | 11960 | int stackSize = keepStackSize(); |
10365 | 11961 | ||
10366 | try { | 11962 | try { |
10367 | // InternalProblem.g:3272:1: ( ( ( rule__Assertion__Group_0_0_2__0 )? ) ) | 11963 | // InternalProblem.g:3746:1: ( ( ( rule__Assertion__Group_0_0_2__0 )? ) ) |
10368 | // InternalProblem.g:3273:1: ( ( rule__Assertion__Group_0_0_2__0 )? ) | 11964 | // InternalProblem.g:3747:1: ( ( rule__Assertion__Group_0_0_2__0 )? ) |
10369 | { | 11965 | { |
10370 | // InternalProblem.g:3273:1: ( ( rule__Assertion__Group_0_0_2__0 )? ) | 11966 | // InternalProblem.g:3747:1: ( ( rule__Assertion__Group_0_0_2__0 )? ) |
10371 | // InternalProblem.g:3274:2: ( rule__Assertion__Group_0_0_2__0 )? | 11967 | // InternalProblem.g:3748:2: ( rule__Assertion__Group_0_0_2__0 )? |
10372 | { | 11968 | { |
10373 | before(grammarAccess.getAssertionAccess().getGroup_0_0_2()); | 11969 | before(grammarAccess.getAssertionAccess().getGroup_0_0_2()); |
10374 | // InternalProblem.g:3275:2: ( rule__Assertion__Group_0_0_2__0 )? | 11970 | // InternalProblem.g:3749:2: ( rule__Assertion__Group_0_0_2__0 )? |
10375 | int alt41=2; | 11971 | int alt47=2; |
10376 | int LA41_0 = input.LA(1); | 11972 | int LA47_0 = input.LA(1); |
10377 | 11973 | ||
10378 | if ( ((LA41_0>=RULE_QUOTED_ID && LA41_0<=RULE_ID)||(LA41_0>=19 && LA41_0<=20)) ) { | 11974 | if ( ((LA47_0>=RULE_INT && LA47_0<=RULE_STRING)||(LA47_0>=19 && LA47_0<=23)) ) { |
10379 | alt41=1; | 11975 | alt47=1; |
10380 | } | 11976 | } |
10381 | switch (alt41) { | 11977 | switch (alt47) { |
10382 | case 1 : | 11978 | case 1 : |
10383 | // InternalProblem.g:3275:3: rule__Assertion__Group_0_0_2__0 | 11979 | // InternalProblem.g:3749:3: rule__Assertion__Group_0_0_2__0 |
10384 | { | 11980 | { |
10385 | pushFollow(FOLLOW_2); | 11981 | pushFollow(FOLLOW_2); |
10386 | rule__Assertion__Group_0_0_2__0(); | 11982 | rule__Assertion__Group_0_0_2__0(); |
@@ -10416,16 +12012,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10416 | 12012 | ||
10417 | 12013 | ||
10418 | // $ANTLR start "rule__Assertion__Group_0_0__3" | 12014 | // $ANTLR start "rule__Assertion__Group_0_0__3" |
10419 | // InternalProblem.g:3283:1: rule__Assertion__Group_0_0__3 : rule__Assertion__Group_0_0__3__Impl rule__Assertion__Group_0_0__4 ; | 12015 | // InternalProblem.g:3757:1: rule__Assertion__Group_0_0__3 : rule__Assertion__Group_0_0__3__Impl rule__Assertion__Group_0_0__4 ; |
10420 | public final void rule__Assertion__Group_0_0__3() throws RecognitionException { | 12016 | public final void rule__Assertion__Group_0_0__3() throws RecognitionException { |
10421 | 12017 | ||
10422 | int stackSize = keepStackSize(); | 12018 | int stackSize = keepStackSize(); |
10423 | 12019 | ||
10424 | try { | 12020 | try { |
10425 | // InternalProblem.g:3287:1: ( rule__Assertion__Group_0_0__3__Impl rule__Assertion__Group_0_0__4 ) | 12021 | // InternalProblem.g:3761:1: ( rule__Assertion__Group_0_0__3__Impl rule__Assertion__Group_0_0__4 ) |
10426 | // InternalProblem.g:3288:2: rule__Assertion__Group_0_0__3__Impl rule__Assertion__Group_0_0__4 | 12022 | // InternalProblem.g:3762:2: rule__Assertion__Group_0_0__3__Impl rule__Assertion__Group_0_0__4 |
10427 | { | 12023 | { |
10428 | pushFollow(FOLLOW_29); | 12024 | pushFollow(FOLLOW_31); |
10429 | rule__Assertion__Group_0_0__3__Impl(); | 12025 | rule__Assertion__Group_0_0__3__Impl(); |
10430 | 12026 | ||
10431 | state._fsp--; | 12027 | state._fsp--; |
@@ -10454,20 +12050,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10454 | 12050 | ||
10455 | 12051 | ||
10456 | // $ANTLR start "rule__Assertion__Group_0_0__3__Impl" | 12052 | // $ANTLR start "rule__Assertion__Group_0_0__3__Impl" |
10457 | // InternalProblem.g:3295:1: rule__Assertion__Group_0_0__3__Impl : ( ')' ) ; | 12053 | // InternalProblem.g:3769:1: rule__Assertion__Group_0_0__3__Impl : ( ')' ) ; |
10458 | public final void rule__Assertion__Group_0_0__3__Impl() throws RecognitionException { | 12054 | public final void rule__Assertion__Group_0_0__3__Impl() throws RecognitionException { |
10459 | 12055 | ||
10460 | int stackSize = keepStackSize(); | 12056 | int stackSize = keepStackSize(); |
10461 | 12057 | ||
10462 | try { | 12058 | try { |
10463 | // InternalProblem.g:3299:1: ( ( ')' ) ) | 12059 | // InternalProblem.g:3773:1: ( ( ')' ) ) |
10464 | // InternalProblem.g:3300:1: ( ')' ) | 12060 | // InternalProblem.g:3774:1: ( ')' ) |
10465 | { | 12061 | { |
10466 | // InternalProblem.g:3300:1: ( ')' ) | 12062 | // InternalProblem.g:3774:1: ( ')' ) |
10467 | // InternalProblem.g:3301:2: ')' | 12063 | // InternalProblem.g:3775:2: ')' |
10468 | { | 12064 | { |
10469 | before(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); | 12065 | before(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); |
10470 | match(input,34,FOLLOW_2); | 12066 | match(input,38,FOLLOW_2); |
10471 | after(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); | 12067 | after(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); |
10472 | 12068 | ||
10473 | } | 12069 | } |
@@ -10491,16 +12087,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10491 | 12087 | ||
10492 | 12088 | ||
10493 | // $ANTLR start "rule__Assertion__Group_0_0__4" | 12089 | // $ANTLR start "rule__Assertion__Group_0_0__4" |
10494 | // InternalProblem.g:3310:1: rule__Assertion__Group_0_0__4 : rule__Assertion__Group_0_0__4__Impl rule__Assertion__Group_0_0__5 ; | 12090 | // InternalProblem.g:3784:1: rule__Assertion__Group_0_0__4 : rule__Assertion__Group_0_0__4__Impl rule__Assertion__Group_0_0__5 ; |
10495 | public final void rule__Assertion__Group_0_0__4() throws RecognitionException { | 12091 | public final void rule__Assertion__Group_0_0__4() throws RecognitionException { |
10496 | 12092 | ||
10497 | int stackSize = keepStackSize(); | 12093 | int stackSize = keepStackSize(); |
10498 | 12094 | ||
10499 | try { | 12095 | try { |
10500 | // InternalProblem.g:3314:1: ( rule__Assertion__Group_0_0__4__Impl rule__Assertion__Group_0_0__5 ) | 12096 | // InternalProblem.g:3788:1: ( rule__Assertion__Group_0_0__4__Impl rule__Assertion__Group_0_0__5 ) |
10501 | // InternalProblem.g:3315:2: rule__Assertion__Group_0_0__4__Impl rule__Assertion__Group_0_0__5 | 12097 | // InternalProblem.g:3789:2: rule__Assertion__Group_0_0__4__Impl rule__Assertion__Group_0_0__5 |
10502 | { | 12098 | { |
10503 | pushFollow(FOLLOW_30); | 12099 | pushFollow(FOLLOW_32); |
10504 | rule__Assertion__Group_0_0__4__Impl(); | 12100 | rule__Assertion__Group_0_0__4__Impl(); |
10505 | 12101 | ||
10506 | state._fsp--; | 12102 | state._fsp--; |
@@ -10529,20 +12125,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10529 | 12125 | ||
10530 | 12126 | ||
10531 | // $ANTLR start "rule__Assertion__Group_0_0__4__Impl" | 12127 | // $ANTLR start "rule__Assertion__Group_0_0__4__Impl" |
10532 | // InternalProblem.g:3322:1: rule__Assertion__Group_0_0__4__Impl : ( ':' ) ; | 12128 | // InternalProblem.g:3796:1: rule__Assertion__Group_0_0__4__Impl : ( ':' ) ; |
10533 | public final void rule__Assertion__Group_0_0__4__Impl() throws RecognitionException { | 12129 | public final void rule__Assertion__Group_0_0__4__Impl() throws RecognitionException { |
10534 | 12130 | ||
10535 | int stackSize = keepStackSize(); | 12131 | int stackSize = keepStackSize(); |
10536 | 12132 | ||
10537 | try { | 12133 | try { |
10538 | // InternalProblem.g:3326:1: ( ( ':' ) ) | 12134 | // InternalProblem.g:3800:1: ( ( ':' ) ) |
10539 | // InternalProblem.g:3327:1: ( ':' ) | 12135 | // InternalProblem.g:3801:1: ( ':' ) |
10540 | { | 12136 | { |
10541 | // InternalProblem.g:3327:1: ( ':' ) | 12137 | // InternalProblem.g:3801:1: ( ':' ) |
10542 | // InternalProblem.g:3328:2: ':' | 12138 | // InternalProblem.g:3802:2: ':' |
10543 | { | 12139 | { |
10544 | before(grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); | 12140 | before(grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); |
10545 | match(input,36,FOLLOW_2); | 12141 | match(input,40,FOLLOW_2); |
10546 | after(grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); | 12142 | after(grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); |
10547 | 12143 | ||
10548 | } | 12144 | } |
@@ -10566,14 +12162,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10566 | 12162 | ||
10567 | 12163 | ||
10568 | // $ANTLR start "rule__Assertion__Group_0_0__5" | 12164 | // $ANTLR start "rule__Assertion__Group_0_0__5" |
10569 | // InternalProblem.g:3337:1: rule__Assertion__Group_0_0__5 : rule__Assertion__Group_0_0__5__Impl ; | 12165 | // InternalProblem.g:3811:1: rule__Assertion__Group_0_0__5 : rule__Assertion__Group_0_0__5__Impl ; |
10570 | public final void rule__Assertion__Group_0_0__5() throws RecognitionException { | 12166 | public final void rule__Assertion__Group_0_0__5() throws RecognitionException { |
10571 | 12167 | ||
10572 | int stackSize = keepStackSize(); | 12168 | int stackSize = keepStackSize(); |
10573 | 12169 | ||
10574 | try { | 12170 | try { |
10575 | // InternalProblem.g:3341:1: ( rule__Assertion__Group_0_0__5__Impl ) | 12171 | // InternalProblem.g:3815:1: ( rule__Assertion__Group_0_0__5__Impl ) |
10576 | // InternalProblem.g:3342:2: rule__Assertion__Group_0_0__5__Impl | 12172 | // InternalProblem.g:3816:2: rule__Assertion__Group_0_0__5__Impl |
10577 | { | 12173 | { |
10578 | pushFollow(FOLLOW_2); | 12174 | pushFollow(FOLLOW_2); |
10579 | rule__Assertion__Group_0_0__5__Impl(); | 12175 | rule__Assertion__Group_0_0__5__Impl(); |
@@ -10599,21 +12195,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10599 | 12195 | ||
10600 | 12196 | ||
10601 | // $ANTLR start "rule__Assertion__Group_0_0__5__Impl" | 12197 | // $ANTLR start "rule__Assertion__Group_0_0__5__Impl" |
10602 | // InternalProblem.g:3348:1: rule__Assertion__Group_0_0__5__Impl : ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) ; | 12198 | // InternalProblem.g:3822:1: rule__Assertion__Group_0_0__5__Impl : ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) ; |
10603 | public final void rule__Assertion__Group_0_0__5__Impl() throws RecognitionException { | 12199 | public final void rule__Assertion__Group_0_0__5__Impl() throws RecognitionException { |
10604 | 12200 | ||
10605 | int stackSize = keepStackSize(); | 12201 | int stackSize = keepStackSize(); |
10606 | 12202 | ||
10607 | try { | 12203 | try { |
10608 | // InternalProblem.g:3352:1: ( ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) ) | 12204 | // InternalProblem.g:3826:1: ( ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) ) |
10609 | // InternalProblem.g:3353:1: ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) | 12205 | // InternalProblem.g:3827:1: ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) |
10610 | { | 12206 | { |
10611 | // InternalProblem.g:3353:1: ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) | 12207 | // InternalProblem.g:3827:1: ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) |
10612 | // InternalProblem.g:3354:2: ( rule__Assertion__ValueAssignment_0_0_5 ) | 12208 | // InternalProblem.g:3828:2: ( rule__Assertion__ValueAssignment_0_0_5 ) |
10613 | { | 12209 | { |
10614 | before(grammarAccess.getAssertionAccess().getValueAssignment_0_0_5()); | 12210 | before(grammarAccess.getAssertionAccess().getValueAssignment_0_0_5()); |
10615 | // InternalProblem.g:3355:2: ( rule__Assertion__ValueAssignment_0_0_5 ) | 12211 | // InternalProblem.g:3829:2: ( rule__Assertion__ValueAssignment_0_0_5 ) |
10616 | // InternalProblem.g:3355:3: rule__Assertion__ValueAssignment_0_0_5 | 12212 | // InternalProblem.g:3829:3: rule__Assertion__ValueAssignment_0_0_5 |
10617 | { | 12213 | { |
10618 | pushFollow(FOLLOW_2); | 12214 | pushFollow(FOLLOW_2); |
10619 | rule__Assertion__ValueAssignment_0_0_5(); | 12215 | rule__Assertion__ValueAssignment_0_0_5(); |
@@ -10646,14 +12242,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10646 | 12242 | ||
10647 | 12243 | ||
10648 | // $ANTLR start "rule__Assertion__Group_0_0_2__0" | 12244 | // $ANTLR start "rule__Assertion__Group_0_0_2__0" |
10649 | // InternalProblem.g:3364:1: rule__Assertion__Group_0_0_2__0 : rule__Assertion__Group_0_0_2__0__Impl rule__Assertion__Group_0_0_2__1 ; | 12245 | // InternalProblem.g:3838:1: rule__Assertion__Group_0_0_2__0 : rule__Assertion__Group_0_0_2__0__Impl rule__Assertion__Group_0_0_2__1 ; |
10650 | public final void rule__Assertion__Group_0_0_2__0() throws RecognitionException { | 12246 | public final void rule__Assertion__Group_0_0_2__0() throws RecognitionException { |
10651 | 12247 | ||
10652 | int stackSize = keepStackSize(); | 12248 | int stackSize = keepStackSize(); |
10653 | 12249 | ||
10654 | try { | 12250 | try { |
10655 | // InternalProblem.g:3368:1: ( rule__Assertion__Group_0_0_2__0__Impl rule__Assertion__Group_0_0_2__1 ) | 12251 | // InternalProblem.g:3842:1: ( rule__Assertion__Group_0_0_2__0__Impl rule__Assertion__Group_0_0_2__1 ) |
10656 | // InternalProblem.g:3369:2: rule__Assertion__Group_0_0_2__0__Impl rule__Assertion__Group_0_0_2__1 | 12252 | // InternalProblem.g:3843:2: rule__Assertion__Group_0_0_2__0__Impl rule__Assertion__Group_0_0_2__1 |
10657 | { | 12253 | { |
10658 | pushFollow(FOLLOW_9); | 12254 | pushFollow(FOLLOW_9); |
10659 | rule__Assertion__Group_0_0_2__0__Impl(); | 12255 | rule__Assertion__Group_0_0_2__0__Impl(); |
@@ -10684,21 +12280,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10684 | 12280 | ||
10685 | 12281 | ||
10686 | // $ANTLR start "rule__Assertion__Group_0_0_2__0__Impl" | 12282 | // $ANTLR start "rule__Assertion__Group_0_0_2__0__Impl" |
10687 | // InternalProblem.g:3376:1: rule__Assertion__Group_0_0_2__0__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) ; | 12283 | // InternalProblem.g:3850:1: rule__Assertion__Group_0_0_2__0__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) ; |
10688 | public final void rule__Assertion__Group_0_0_2__0__Impl() throws RecognitionException { | 12284 | public final void rule__Assertion__Group_0_0_2__0__Impl() throws RecognitionException { |
10689 | 12285 | ||
10690 | int stackSize = keepStackSize(); | 12286 | int stackSize = keepStackSize(); |
10691 | 12287 | ||
10692 | try { | 12288 | try { |
10693 | // InternalProblem.g:3380:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) ) | 12289 | // InternalProblem.g:3854:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) ) |
10694 | // InternalProblem.g:3381:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) | 12290 | // InternalProblem.g:3855:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) |
10695 | { | 12291 | { |
10696 | // InternalProblem.g:3381:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) | 12292 | // InternalProblem.g:3855:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) |
10697 | // InternalProblem.g:3382:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) | 12293 | // InternalProblem.g:3856:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) |
10698 | { | 12294 | { |
10699 | before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0()); | 12295 | before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0()); |
10700 | // InternalProblem.g:3383:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) | 12296 | // InternalProblem.g:3857:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) |
10701 | // InternalProblem.g:3383:3: rule__Assertion__ArgumentsAssignment_0_0_2_0 | 12297 | // InternalProblem.g:3857:3: rule__Assertion__ArgumentsAssignment_0_0_2_0 |
10702 | { | 12298 | { |
10703 | pushFollow(FOLLOW_2); | 12299 | pushFollow(FOLLOW_2); |
10704 | rule__Assertion__ArgumentsAssignment_0_0_2_0(); | 12300 | rule__Assertion__ArgumentsAssignment_0_0_2_0(); |
@@ -10731,14 +12327,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10731 | 12327 | ||
10732 | 12328 | ||
10733 | // $ANTLR start "rule__Assertion__Group_0_0_2__1" | 12329 | // $ANTLR start "rule__Assertion__Group_0_0_2__1" |
10734 | // InternalProblem.g:3391:1: rule__Assertion__Group_0_0_2__1 : rule__Assertion__Group_0_0_2__1__Impl ; | 12330 | // InternalProblem.g:3865:1: rule__Assertion__Group_0_0_2__1 : rule__Assertion__Group_0_0_2__1__Impl ; |
10735 | public final void rule__Assertion__Group_0_0_2__1() throws RecognitionException { | 12331 | public final void rule__Assertion__Group_0_0_2__1() throws RecognitionException { |
10736 | 12332 | ||
10737 | int stackSize = keepStackSize(); | 12333 | int stackSize = keepStackSize(); |
10738 | 12334 | ||
10739 | try { | 12335 | try { |
10740 | // InternalProblem.g:3395:1: ( rule__Assertion__Group_0_0_2__1__Impl ) | 12336 | // InternalProblem.g:3869:1: ( rule__Assertion__Group_0_0_2__1__Impl ) |
10741 | // InternalProblem.g:3396:2: rule__Assertion__Group_0_0_2__1__Impl | 12337 | // InternalProblem.g:3870:2: rule__Assertion__Group_0_0_2__1__Impl |
10742 | { | 12338 | { |
10743 | pushFollow(FOLLOW_2); | 12339 | pushFollow(FOLLOW_2); |
10744 | rule__Assertion__Group_0_0_2__1__Impl(); | 12340 | rule__Assertion__Group_0_0_2__1__Impl(); |
@@ -10764,33 +12360,33 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10764 | 12360 | ||
10765 | 12361 | ||
10766 | // $ANTLR start "rule__Assertion__Group_0_0_2__1__Impl" | 12362 | // $ANTLR start "rule__Assertion__Group_0_0_2__1__Impl" |
10767 | // InternalProblem.g:3402:1: rule__Assertion__Group_0_0_2__1__Impl : ( ( rule__Assertion__Group_0_0_2_1__0 )* ) ; | 12363 | // InternalProblem.g:3876:1: rule__Assertion__Group_0_0_2__1__Impl : ( ( rule__Assertion__Group_0_0_2_1__0 )* ) ; |
10768 | public final void rule__Assertion__Group_0_0_2__1__Impl() throws RecognitionException { | 12364 | public final void rule__Assertion__Group_0_0_2__1__Impl() throws RecognitionException { |
10769 | 12365 | ||
10770 | int stackSize = keepStackSize(); | 12366 | int stackSize = keepStackSize(); |
10771 | 12367 | ||
10772 | try { | 12368 | try { |
10773 | // InternalProblem.g:3406:1: ( ( ( rule__Assertion__Group_0_0_2_1__0 )* ) ) | 12369 | // InternalProblem.g:3880:1: ( ( ( rule__Assertion__Group_0_0_2_1__0 )* ) ) |
10774 | // InternalProblem.g:3407:1: ( ( rule__Assertion__Group_0_0_2_1__0 )* ) | 12370 | // InternalProblem.g:3881:1: ( ( rule__Assertion__Group_0_0_2_1__0 )* ) |
10775 | { | 12371 | { |
10776 | // InternalProblem.g:3407:1: ( ( rule__Assertion__Group_0_0_2_1__0 )* ) | 12372 | // InternalProblem.g:3881:1: ( ( rule__Assertion__Group_0_0_2_1__0 )* ) |
10777 | // InternalProblem.g:3408:2: ( rule__Assertion__Group_0_0_2_1__0 )* | 12373 | // InternalProblem.g:3882:2: ( rule__Assertion__Group_0_0_2_1__0 )* |
10778 | { | 12374 | { |
10779 | before(grammarAccess.getAssertionAccess().getGroup_0_0_2_1()); | 12375 | before(grammarAccess.getAssertionAccess().getGroup_0_0_2_1()); |
10780 | // InternalProblem.g:3409:2: ( rule__Assertion__Group_0_0_2_1__0 )* | 12376 | // InternalProblem.g:3883:2: ( rule__Assertion__Group_0_0_2_1__0 )* |
10781 | loop42: | 12377 | loop48: |
10782 | do { | 12378 | do { |
10783 | int alt42=2; | 12379 | int alt48=2; |
10784 | int LA42_0 = input.LA(1); | 12380 | int LA48_0 = input.LA(1); |
10785 | 12381 | ||
10786 | if ( (LA42_0==13) ) { | 12382 | if ( (LA48_0==13) ) { |
10787 | alt42=1; | 12383 | alt48=1; |
10788 | } | 12384 | } |
10789 | 12385 | ||
10790 | 12386 | ||
10791 | switch (alt42) { | 12387 | switch (alt48) { |
10792 | case 1 : | 12388 | case 1 : |
10793 | // InternalProblem.g:3409:3: rule__Assertion__Group_0_0_2_1__0 | 12389 | // InternalProblem.g:3883:3: rule__Assertion__Group_0_0_2_1__0 |
10794 | { | 12390 | { |
10795 | pushFollow(FOLLOW_10); | 12391 | pushFollow(FOLLOW_10); |
10796 | rule__Assertion__Group_0_0_2_1__0(); | 12392 | rule__Assertion__Group_0_0_2_1__0(); |
@@ -10802,7 +12398,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10802 | break; | 12398 | break; |
10803 | 12399 | ||
10804 | default : | 12400 | default : |
10805 | break loop42; | 12401 | break loop48; |
10806 | } | 12402 | } |
10807 | } while (true); | 12403 | } while (true); |
10808 | 12404 | ||
@@ -10829,16 +12425,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10829 | 12425 | ||
10830 | 12426 | ||
10831 | // $ANTLR start "rule__Assertion__Group_0_0_2_1__0" | 12427 | // $ANTLR start "rule__Assertion__Group_0_0_2_1__0" |
10832 | // InternalProblem.g:3418:1: rule__Assertion__Group_0_0_2_1__0 : rule__Assertion__Group_0_0_2_1__0__Impl rule__Assertion__Group_0_0_2_1__1 ; | 12428 | // InternalProblem.g:3892:1: rule__Assertion__Group_0_0_2_1__0 : rule__Assertion__Group_0_0_2_1__0__Impl rule__Assertion__Group_0_0_2_1__1 ; |
10833 | public final void rule__Assertion__Group_0_0_2_1__0() throws RecognitionException { | 12429 | public final void rule__Assertion__Group_0_0_2_1__0() throws RecognitionException { |
10834 | 12430 | ||
10835 | int stackSize = keepStackSize(); | 12431 | int stackSize = keepStackSize(); |
10836 | 12432 | ||
10837 | try { | 12433 | try { |
10838 | // InternalProblem.g:3422:1: ( rule__Assertion__Group_0_0_2_1__0__Impl rule__Assertion__Group_0_0_2_1__1 ) | 12434 | // InternalProblem.g:3896:1: ( rule__Assertion__Group_0_0_2_1__0__Impl rule__Assertion__Group_0_0_2_1__1 ) |
10839 | // InternalProblem.g:3423:2: rule__Assertion__Group_0_0_2_1__0__Impl rule__Assertion__Group_0_0_2_1__1 | 12435 | // InternalProblem.g:3897:2: rule__Assertion__Group_0_0_2_1__0__Impl rule__Assertion__Group_0_0_2_1__1 |
10840 | { | 12436 | { |
10841 | pushFollow(FOLLOW_5); | 12437 | pushFollow(FOLLOW_30); |
10842 | rule__Assertion__Group_0_0_2_1__0__Impl(); | 12438 | rule__Assertion__Group_0_0_2_1__0__Impl(); |
10843 | 12439 | ||
10844 | state._fsp--; | 12440 | state._fsp--; |
@@ -10867,17 +12463,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10867 | 12463 | ||
10868 | 12464 | ||
10869 | // $ANTLR start "rule__Assertion__Group_0_0_2_1__0__Impl" | 12465 | // $ANTLR start "rule__Assertion__Group_0_0_2_1__0__Impl" |
10870 | // InternalProblem.g:3430:1: rule__Assertion__Group_0_0_2_1__0__Impl : ( ',' ) ; | 12466 | // InternalProblem.g:3904:1: rule__Assertion__Group_0_0_2_1__0__Impl : ( ',' ) ; |
10871 | public final void rule__Assertion__Group_0_0_2_1__0__Impl() throws RecognitionException { | 12467 | public final void rule__Assertion__Group_0_0_2_1__0__Impl() throws RecognitionException { |
10872 | 12468 | ||
10873 | int stackSize = keepStackSize(); | 12469 | int stackSize = keepStackSize(); |
10874 | 12470 | ||
10875 | try { | 12471 | try { |
10876 | // InternalProblem.g:3434:1: ( ( ',' ) ) | 12472 | // InternalProblem.g:3908:1: ( ( ',' ) ) |
10877 | // InternalProblem.g:3435:1: ( ',' ) | 12473 | // InternalProblem.g:3909:1: ( ',' ) |
10878 | { | 12474 | { |
10879 | // InternalProblem.g:3435:1: ( ',' ) | 12475 | // InternalProblem.g:3909:1: ( ',' ) |
10880 | // InternalProblem.g:3436:2: ',' | 12476 | // InternalProblem.g:3910:2: ',' |
10881 | { | 12477 | { |
10882 | before(grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); | 12478 | before(grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); |
10883 | match(input,13,FOLLOW_2); | 12479 | match(input,13,FOLLOW_2); |
@@ -10904,14 +12500,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10904 | 12500 | ||
10905 | 12501 | ||
10906 | // $ANTLR start "rule__Assertion__Group_0_0_2_1__1" | 12502 | // $ANTLR start "rule__Assertion__Group_0_0_2_1__1" |
10907 | // InternalProblem.g:3445:1: rule__Assertion__Group_0_0_2_1__1 : rule__Assertion__Group_0_0_2_1__1__Impl ; | 12503 | // InternalProblem.g:3919:1: rule__Assertion__Group_0_0_2_1__1 : rule__Assertion__Group_0_0_2_1__1__Impl ; |
10908 | public final void rule__Assertion__Group_0_0_2_1__1() throws RecognitionException { | 12504 | public final void rule__Assertion__Group_0_0_2_1__1() throws RecognitionException { |
10909 | 12505 | ||
10910 | int stackSize = keepStackSize(); | 12506 | int stackSize = keepStackSize(); |
10911 | 12507 | ||
10912 | try { | 12508 | try { |
10913 | // InternalProblem.g:3449:1: ( rule__Assertion__Group_0_0_2_1__1__Impl ) | 12509 | // InternalProblem.g:3923:1: ( rule__Assertion__Group_0_0_2_1__1__Impl ) |
10914 | // InternalProblem.g:3450:2: rule__Assertion__Group_0_0_2_1__1__Impl | 12510 | // InternalProblem.g:3924:2: rule__Assertion__Group_0_0_2_1__1__Impl |
10915 | { | 12511 | { |
10916 | pushFollow(FOLLOW_2); | 12512 | pushFollow(FOLLOW_2); |
10917 | rule__Assertion__Group_0_0_2_1__1__Impl(); | 12513 | rule__Assertion__Group_0_0_2_1__1__Impl(); |
@@ -10937,21 +12533,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10937 | 12533 | ||
10938 | 12534 | ||
10939 | // $ANTLR start "rule__Assertion__Group_0_0_2_1__1__Impl" | 12535 | // $ANTLR start "rule__Assertion__Group_0_0_2_1__1__Impl" |
10940 | // InternalProblem.g:3456:1: rule__Assertion__Group_0_0_2_1__1__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) ; | 12536 | // InternalProblem.g:3930:1: rule__Assertion__Group_0_0_2_1__1__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) ; |
10941 | public final void rule__Assertion__Group_0_0_2_1__1__Impl() throws RecognitionException { | 12537 | public final void rule__Assertion__Group_0_0_2_1__1__Impl() throws RecognitionException { |
10942 | 12538 | ||
10943 | int stackSize = keepStackSize(); | 12539 | int stackSize = keepStackSize(); |
10944 | 12540 | ||
10945 | try { | 12541 | try { |
10946 | // InternalProblem.g:3460:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) ) | 12542 | // InternalProblem.g:3934:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) ) |
10947 | // InternalProblem.g:3461:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) | 12543 | // InternalProblem.g:3935:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) |
10948 | { | 12544 | { |
10949 | // InternalProblem.g:3461:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) | 12545 | // InternalProblem.g:3935:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) |
10950 | // InternalProblem.g:3462:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) | 12546 | // InternalProblem.g:3936:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) |
10951 | { | 12547 | { |
10952 | before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1()); | 12548 | before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1()); |
10953 | // InternalProblem.g:3463:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) | 12549 | // InternalProblem.g:3937:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) |
10954 | // InternalProblem.g:3463:3: rule__Assertion__ArgumentsAssignment_0_0_2_1_1 | 12550 | // InternalProblem.g:3937:3: rule__Assertion__ArgumentsAssignment_0_0_2_1_1 |
10955 | { | 12551 | { |
10956 | pushFollow(FOLLOW_2); | 12552 | pushFollow(FOLLOW_2); |
10957 | rule__Assertion__ArgumentsAssignment_0_0_2_1_1(); | 12553 | rule__Assertion__ArgumentsAssignment_0_0_2_1_1(); |
@@ -10984,16 +12580,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
10984 | 12580 | ||
10985 | 12581 | ||
10986 | // $ANTLR start "rule__Assertion__Group_0_1__0" | 12582 | // $ANTLR start "rule__Assertion__Group_0_1__0" |
10987 | // InternalProblem.g:3472:1: rule__Assertion__Group_0_1__0 : rule__Assertion__Group_0_1__0__Impl rule__Assertion__Group_0_1__1 ; | 12583 | // InternalProblem.g:3946:1: rule__Assertion__Group_0_1__0 : rule__Assertion__Group_0_1__0__Impl rule__Assertion__Group_0_1__1 ; |
10988 | public final void rule__Assertion__Group_0_1__0() throws RecognitionException { | 12584 | public final void rule__Assertion__Group_0_1__0() throws RecognitionException { |
10989 | 12585 | ||
10990 | int stackSize = keepStackSize(); | 12586 | int stackSize = keepStackSize(); |
10991 | 12587 | ||
10992 | try { | 12588 | try { |
10993 | // InternalProblem.g:3476:1: ( rule__Assertion__Group_0_1__0__Impl rule__Assertion__Group_0_1__1 ) | 12589 | // InternalProblem.g:3950:1: ( rule__Assertion__Group_0_1__0__Impl rule__Assertion__Group_0_1__1 ) |
10994 | // InternalProblem.g:3477:2: rule__Assertion__Group_0_1__0__Impl rule__Assertion__Group_0_1__1 | 12590 | // InternalProblem.g:3951:2: rule__Assertion__Group_0_1__0__Impl rule__Assertion__Group_0_1__1 |
10995 | { | 12591 | { |
10996 | pushFollow(FOLLOW_31); | 12592 | pushFollow(FOLLOW_33); |
10997 | rule__Assertion__Group_0_1__0__Impl(); | 12593 | rule__Assertion__Group_0_1__0__Impl(); |
10998 | 12594 | ||
10999 | state._fsp--; | 12595 | state._fsp--; |
@@ -11022,29 +12618,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11022 | 12618 | ||
11023 | 12619 | ||
11024 | // $ANTLR start "rule__Assertion__Group_0_1__0__Impl" | 12620 | // $ANTLR start "rule__Assertion__Group_0_1__0__Impl" |
11025 | // InternalProblem.g:3484:1: rule__Assertion__Group_0_1__0__Impl : ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) ; | 12621 | // InternalProblem.g:3958:1: rule__Assertion__Group_0_1__0__Impl : ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) ; |
11026 | public final void rule__Assertion__Group_0_1__0__Impl() throws RecognitionException { | 12622 | public final void rule__Assertion__Group_0_1__0__Impl() throws RecognitionException { |
11027 | 12623 | ||
11028 | int stackSize = keepStackSize(); | 12624 | int stackSize = keepStackSize(); |
11029 | 12625 | ||
11030 | try { | 12626 | try { |
11031 | // InternalProblem.g:3488:1: ( ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) ) | 12627 | // InternalProblem.g:3962:1: ( ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) ) |
11032 | // InternalProblem.g:3489:1: ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) | 12628 | // InternalProblem.g:3963:1: ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) |
11033 | { | 12629 | { |
11034 | // InternalProblem.g:3489:1: ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) | 12630 | // InternalProblem.g:3963:1: ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) |
11035 | // InternalProblem.g:3490:2: ( rule__Assertion__ValueAssignment_0_1_0 )? | 12631 | // InternalProblem.g:3964:2: ( rule__Assertion__ValueAssignment_0_1_0 )? |
11036 | { | 12632 | { |
11037 | before(grammarAccess.getAssertionAccess().getValueAssignment_0_1_0()); | 12633 | before(grammarAccess.getAssertionAccess().getValueAssignment_0_1_0()); |
11038 | // InternalProblem.g:3491:2: ( rule__Assertion__ValueAssignment_0_1_0 )? | 12634 | // InternalProblem.g:3965:2: ( rule__Assertion__ValueAssignment_0_1_0 )? |
11039 | int alt43=2; | 12635 | int alt49=2; |
11040 | int LA43_0 = input.LA(1); | 12636 | int LA49_0 = input.LA(1); |
11041 | 12637 | ||
11042 | if ( ((LA43_0>=22 && LA43_0<=23)) ) { | 12638 | if ( ((LA49_0>=26 && LA49_0<=27)) ) { |
11043 | alt43=1; | 12639 | alt49=1; |
11044 | } | 12640 | } |
11045 | switch (alt43) { | 12641 | switch (alt49) { |
11046 | case 1 : | 12642 | case 1 : |
11047 | // InternalProblem.g:3491:3: rule__Assertion__ValueAssignment_0_1_0 | 12643 | // InternalProblem.g:3965:3: rule__Assertion__ValueAssignment_0_1_0 |
11048 | { | 12644 | { |
11049 | pushFollow(FOLLOW_2); | 12645 | pushFollow(FOLLOW_2); |
11050 | rule__Assertion__ValueAssignment_0_1_0(); | 12646 | rule__Assertion__ValueAssignment_0_1_0(); |
@@ -11080,14 +12676,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11080 | 12676 | ||
11081 | 12677 | ||
11082 | // $ANTLR start "rule__Assertion__Group_0_1__1" | 12678 | // $ANTLR start "rule__Assertion__Group_0_1__1" |
11083 | // InternalProblem.g:3499:1: rule__Assertion__Group_0_1__1 : rule__Assertion__Group_0_1__1__Impl rule__Assertion__Group_0_1__2 ; | 12679 | // InternalProblem.g:3973:1: rule__Assertion__Group_0_1__1 : rule__Assertion__Group_0_1__1__Impl rule__Assertion__Group_0_1__2 ; |
11084 | public final void rule__Assertion__Group_0_1__1() throws RecognitionException { | 12680 | public final void rule__Assertion__Group_0_1__1() throws RecognitionException { |
11085 | 12681 | ||
11086 | int stackSize = keepStackSize(); | 12682 | int stackSize = keepStackSize(); |
11087 | 12683 | ||
11088 | try { | 12684 | try { |
11089 | // InternalProblem.g:3503:1: ( rule__Assertion__Group_0_1__1__Impl rule__Assertion__Group_0_1__2 ) | 12685 | // InternalProblem.g:3977:1: ( rule__Assertion__Group_0_1__1__Impl rule__Assertion__Group_0_1__2 ) |
11090 | // InternalProblem.g:3504:2: rule__Assertion__Group_0_1__1__Impl rule__Assertion__Group_0_1__2 | 12686 | // InternalProblem.g:3978:2: rule__Assertion__Group_0_1__1__Impl rule__Assertion__Group_0_1__2 |
11091 | { | 12687 | { |
11092 | pushFollow(FOLLOW_22); | 12688 | pushFollow(FOLLOW_22); |
11093 | rule__Assertion__Group_0_1__1__Impl(); | 12689 | rule__Assertion__Group_0_1__1__Impl(); |
@@ -11118,21 +12714,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11118 | 12714 | ||
11119 | 12715 | ||
11120 | // $ANTLR start "rule__Assertion__Group_0_1__1__Impl" | 12716 | // $ANTLR start "rule__Assertion__Group_0_1__1__Impl" |
11121 | // InternalProblem.g:3511:1: rule__Assertion__Group_0_1__1__Impl : ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) ; | 12717 | // InternalProblem.g:3985:1: rule__Assertion__Group_0_1__1__Impl : ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) ; |
11122 | public final void rule__Assertion__Group_0_1__1__Impl() throws RecognitionException { | 12718 | public final void rule__Assertion__Group_0_1__1__Impl() throws RecognitionException { |
11123 | 12719 | ||
11124 | int stackSize = keepStackSize(); | 12720 | int stackSize = keepStackSize(); |
11125 | 12721 | ||
11126 | try { | 12722 | try { |
11127 | // InternalProblem.g:3515:1: ( ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) ) | 12723 | // InternalProblem.g:3989:1: ( ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) ) |
11128 | // InternalProblem.g:3516:1: ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) | 12724 | // InternalProblem.g:3990:1: ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) |
11129 | { | 12725 | { |
11130 | // InternalProblem.g:3516:1: ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) | 12726 | // InternalProblem.g:3990:1: ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) |
11131 | // InternalProblem.g:3517:2: ( rule__Assertion__RelationAssignment_0_1_1 ) | 12727 | // InternalProblem.g:3991:2: ( rule__Assertion__RelationAssignment_0_1_1 ) |
11132 | { | 12728 | { |
11133 | before(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1()); | 12729 | before(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1()); |
11134 | // InternalProblem.g:3518:2: ( rule__Assertion__RelationAssignment_0_1_1 ) | 12730 | // InternalProblem.g:3992:2: ( rule__Assertion__RelationAssignment_0_1_1 ) |
11135 | // InternalProblem.g:3518:3: rule__Assertion__RelationAssignment_0_1_1 | 12731 | // InternalProblem.g:3992:3: rule__Assertion__RelationAssignment_0_1_1 |
11136 | { | 12732 | { |
11137 | pushFollow(FOLLOW_2); | 12733 | pushFollow(FOLLOW_2); |
11138 | rule__Assertion__RelationAssignment_0_1_1(); | 12734 | rule__Assertion__RelationAssignment_0_1_1(); |
@@ -11165,16 +12761,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11165 | 12761 | ||
11166 | 12762 | ||
11167 | // $ANTLR start "rule__Assertion__Group_0_1__2" | 12763 | // $ANTLR start "rule__Assertion__Group_0_1__2" |
11168 | // InternalProblem.g:3526:1: rule__Assertion__Group_0_1__2 : rule__Assertion__Group_0_1__2__Impl rule__Assertion__Group_0_1__3 ; | 12764 | // InternalProblem.g:4000:1: rule__Assertion__Group_0_1__2 : rule__Assertion__Group_0_1__2__Impl rule__Assertion__Group_0_1__3 ; |
11169 | public final void rule__Assertion__Group_0_1__2() throws RecognitionException { | 12765 | public final void rule__Assertion__Group_0_1__2() throws RecognitionException { |
11170 | 12766 | ||
11171 | int stackSize = keepStackSize(); | 12767 | int stackSize = keepStackSize(); |
11172 | 12768 | ||
11173 | try { | 12769 | try { |
11174 | // InternalProblem.g:3530:1: ( rule__Assertion__Group_0_1__2__Impl rule__Assertion__Group_0_1__3 ) | 12770 | // InternalProblem.g:4004:1: ( rule__Assertion__Group_0_1__2__Impl rule__Assertion__Group_0_1__3 ) |
11175 | // InternalProblem.g:3531:2: rule__Assertion__Group_0_1__2__Impl rule__Assertion__Group_0_1__3 | 12771 | // InternalProblem.g:4005:2: rule__Assertion__Group_0_1__2__Impl rule__Assertion__Group_0_1__3 |
11176 | { | 12772 | { |
11177 | pushFollow(FOLLOW_23); | 12773 | pushFollow(FOLLOW_29); |
11178 | rule__Assertion__Group_0_1__2__Impl(); | 12774 | rule__Assertion__Group_0_1__2__Impl(); |
11179 | 12775 | ||
11180 | state._fsp--; | 12776 | state._fsp--; |
@@ -11203,20 +12799,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11203 | 12799 | ||
11204 | 12800 | ||
11205 | // $ANTLR start "rule__Assertion__Group_0_1__2__Impl" | 12801 | // $ANTLR start "rule__Assertion__Group_0_1__2__Impl" |
11206 | // InternalProblem.g:3538:1: rule__Assertion__Group_0_1__2__Impl : ( '(' ) ; | 12802 | // InternalProblem.g:4012:1: rule__Assertion__Group_0_1__2__Impl : ( '(' ) ; |
11207 | public final void rule__Assertion__Group_0_1__2__Impl() throws RecognitionException { | 12803 | public final void rule__Assertion__Group_0_1__2__Impl() throws RecognitionException { |
11208 | 12804 | ||
11209 | int stackSize = keepStackSize(); | 12805 | int stackSize = keepStackSize(); |
11210 | 12806 | ||
11211 | try { | 12807 | try { |
11212 | // InternalProblem.g:3542:1: ( ( '(' ) ) | 12808 | // InternalProblem.g:4016:1: ( ( '(' ) ) |
11213 | // InternalProblem.g:3543:1: ( '(' ) | 12809 | // InternalProblem.g:4017:1: ( '(' ) |
11214 | { | 12810 | { |
11215 | // InternalProblem.g:3543:1: ( '(' ) | 12811 | // InternalProblem.g:4017:1: ( '(' ) |
11216 | // InternalProblem.g:3544:2: '(' | 12812 | // InternalProblem.g:4018:2: '(' |
11217 | { | 12813 | { |
11218 | before(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); | 12814 | before(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); |
11219 | match(input,33,FOLLOW_2); | 12815 | match(input,37,FOLLOW_2); |
11220 | after(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); | 12816 | after(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); |
11221 | 12817 | ||
11222 | } | 12818 | } |
@@ -11240,16 +12836,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11240 | 12836 | ||
11241 | 12837 | ||
11242 | // $ANTLR start "rule__Assertion__Group_0_1__3" | 12838 | // $ANTLR start "rule__Assertion__Group_0_1__3" |
11243 | // InternalProblem.g:3553:1: rule__Assertion__Group_0_1__3 : rule__Assertion__Group_0_1__3__Impl rule__Assertion__Group_0_1__4 ; | 12839 | // InternalProblem.g:4027:1: rule__Assertion__Group_0_1__3 : rule__Assertion__Group_0_1__3__Impl rule__Assertion__Group_0_1__4 ; |
11244 | public final void rule__Assertion__Group_0_1__3() throws RecognitionException { | 12840 | public final void rule__Assertion__Group_0_1__3() throws RecognitionException { |
11245 | 12841 | ||
11246 | int stackSize = keepStackSize(); | 12842 | int stackSize = keepStackSize(); |
11247 | 12843 | ||
11248 | try { | 12844 | try { |
11249 | // InternalProblem.g:3557:1: ( rule__Assertion__Group_0_1__3__Impl rule__Assertion__Group_0_1__4 ) | 12845 | // InternalProblem.g:4031:1: ( rule__Assertion__Group_0_1__3__Impl rule__Assertion__Group_0_1__4 ) |
11250 | // InternalProblem.g:3558:2: rule__Assertion__Group_0_1__3__Impl rule__Assertion__Group_0_1__4 | 12846 | // InternalProblem.g:4032:2: rule__Assertion__Group_0_1__3__Impl rule__Assertion__Group_0_1__4 |
11251 | { | 12847 | { |
11252 | pushFollow(FOLLOW_23); | 12848 | pushFollow(FOLLOW_29); |
11253 | rule__Assertion__Group_0_1__3__Impl(); | 12849 | rule__Assertion__Group_0_1__3__Impl(); |
11254 | 12850 | ||
11255 | state._fsp--; | 12851 | state._fsp--; |
@@ -11278,29 +12874,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11278 | 12874 | ||
11279 | 12875 | ||
11280 | // $ANTLR start "rule__Assertion__Group_0_1__3__Impl" | 12876 | // $ANTLR start "rule__Assertion__Group_0_1__3__Impl" |
11281 | // InternalProblem.g:3565:1: rule__Assertion__Group_0_1__3__Impl : ( ( rule__Assertion__Group_0_1_3__0 )? ) ; | 12877 | // InternalProblem.g:4039:1: rule__Assertion__Group_0_1__3__Impl : ( ( rule__Assertion__Group_0_1_3__0 )? ) ; |
11282 | public final void rule__Assertion__Group_0_1__3__Impl() throws RecognitionException { | 12878 | public final void rule__Assertion__Group_0_1__3__Impl() throws RecognitionException { |
11283 | 12879 | ||
11284 | int stackSize = keepStackSize(); | 12880 | int stackSize = keepStackSize(); |
11285 | 12881 | ||
11286 | try { | 12882 | try { |
11287 | // InternalProblem.g:3569:1: ( ( ( rule__Assertion__Group_0_1_3__0 )? ) ) | 12883 | // InternalProblem.g:4043:1: ( ( ( rule__Assertion__Group_0_1_3__0 )? ) ) |
11288 | // InternalProblem.g:3570:1: ( ( rule__Assertion__Group_0_1_3__0 )? ) | 12884 | // InternalProblem.g:4044:1: ( ( rule__Assertion__Group_0_1_3__0 )? ) |
11289 | { | 12885 | { |
11290 | // InternalProblem.g:3570:1: ( ( rule__Assertion__Group_0_1_3__0 )? ) | 12886 | // InternalProblem.g:4044:1: ( ( rule__Assertion__Group_0_1_3__0 )? ) |
11291 | // InternalProblem.g:3571:2: ( rule__Assertion__Group_0_1_3__0 )? | 12887 | // InternalProblem.g:4045:2: ( rule__Assertion__Group_0_1_3__0 )? |
11292 | { | 12888 | { |
11293 | before(grammarAccess.getAssertionAccess().getGroup_0_1_3()); | 12889 | before(grammarAccess.getAssertionAccess().getGroup_0_1_3()); |
11294 | // InternalProblem.g:3572:2: ( rule__Assertion__Group_0_1_3__0 )? | 12890 | // InternalProblem.g:4046:2: ( rule__Assertion__Group_0_1_3__0 )? |
11295 | int alt44=2; | 12891 | int alt50=2; |
11296 | int LA44_0 = input.LA(1); | 12892 | int LA50_0 = input.LA(1); |
11297 | 12893 | ||
11298 | if ( ((LA44_0>=RULE_QUOTED_ID && LA44_0<=RULE_ID)||(LA44_0>=19 && LA44_0<=20)) ) { | 12894 | if ( ((LA50_0>=RULE_INT && LA50_0<=RULE_STRING)||(LA50_0>=19 && LA50_0<=23)) ) { |
11299 | alt44=1; | 12895 | alt50=1; |
11300 | } | 12896 | } |
11301 | switch (alt44) { | 12897 | switch (alt50) { |
11302 | case 1 : | 12898 | case 1 : |
11303 | // InternalProblem.g:3572:3: rule__Assertion__Group_0_1_3__0 | 12899 | // InternalProblem.g:4046:3: rule__Assertion__Group_0_1_3__0 |
11304 | { | 12900 | { |
11305 | pushFollow(FOLLOW_2); | 12901 | pushFollow(FOLLOW_2); |
11306 | rule__Assertion__Group_0_1_3__0(); | 12902 | rule__Assertion__Group_0_1_3__0(); |
@@ -11336,14 +12932,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11336 | 12932 | ||
11337 | 12933 | ||
11338 | // $ANTLR start "rule__Assertion__Group_0_1__4" | 12934 | // $ANTLR start "rule__Assertion__Group_0_1__4" |
11339 | // InternalProblem.g:3580:1: rule__Assertion__Group_0_1__4 : rule__Assertion__Group_0_1__4__Impl ; | 12935 | // InternalProblem.g:4054:1: rule__Assertion__Group_0_1__4 : rule__Assertion__Group_0_1__4__Impl ; |
11340 | public final void rule__Assertion__Group_0_1__4() throws RecognitionException { | 12936 | public final void rule__Assertion__Group_0_1__4() throws RecognitionException { |
11341 | 12937 | ||
11342 | int stackSize = keepStackSize(); | 12938 | int stackSize = keepStackSize(); |
11343 | 12939 | ||
11344 | try { | 12940 | try { |
11345 | // InternalProblem.g:3584:1: ( rule__Assertion__Group_0_1__4__Impl ) | 12941 | // InternalProblem.g:4058:1: ( rule__Assertion__Group_0_1__4__Impl ) |
11346 | // InternalProblem.g:3585:2: rule__Assertion__Group_0_1__4__Impl | 12942 | // InternalProblem.g:4059:2: rule__Assertion__Group_0_1__4__Impl |
11347 | { | 12943 | { |
11348 | pushFollow(FOLLOW_2); | 12944 | pushFollow(FOLLOW_2); |
11349 | rule__Assertion__Group_0_1__4__Impl(); | 12945 | rule__Assertion__Group_0_1__4__Impl(); |
@@ -11369,20 +12965,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11369 | 12965 | ||
11370 | 12966 | ||
11371 | // $ANTLR start "rule__Assertion__Group_0_1__4__Impl" | 12967 | // $ANTLR start "rule__Assertion__Group_0_1__4__Impl" |
11372 | // InternalProblem.g:3591:1: rule__Assertion__Group_0_1__4__Impl : ( ')' ) ; | 12968 | // InternalProblem.g:4065:1: rule__Assertion__Group_0_1__4__Impl : ( ')' ) ; |
11373 | public final void rule__Assertion__Group_0_1__4__Impl() throws RecognitionException { | 12969 | public final void rule__Assertion__Group_0_1__4__Impl() throws RecognitionException { |
11374 | 12970 | ||
11375 | int stackSize = keepStackSize(); | 12971 | int stackSize = keepStackSize(); |
11376 | 12972 | ||
11377 | try { | 12973 | try { |
11378 | // InternalProblem.g:3595:1: ( ( ')' ) ) | 12974 | // InternalProblem.g:4069:1: ( ( ')' ) ) |
11379 | // InternalProblem.g:3596:1: ( ')' ) | 12975 | // InternalProblem.g:4070:1: ( ')' ) |
11380 | { | 12976 | { |
11381 | // InternalProblem.g:3596:1: ( ')' ) | 12977 | // InternalProblem.g:4070:1: ( ')' ) |
11382 | // InternalProblem.g:3597:2: ')' | 12978 | // InternalProblem.g:4071:2: ')' |
11383 | { | 12979 | { |
11384 | before(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); | 12980 | before(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); |
11385 | match(input,34,FOLLOW_2); | 12981 | match(input,38,FOLLOW_2); |
11386 | after(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); | 12982 | after(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); |
11387 | 12983 | ||
11388 | } | 12984 | } |
@@ -11406,14 +13002,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11406 | 13002 | ||
11407 | 13003 | ||
11408 | // $ANTLR start "rule__Assertion__Group_0_1_3__0" | 13004 | // $ANTLR start "rule__Assertion__Group_0_1_3__0" |
11409 | // InternalProblem.g:3607:1: rule__Assertion__Group_0_1_3__0 : rule__Assertion__Group_0_1_3__0__Impl rule__Assertion__Group_0_1_3__1 ; | 13005 | // InternalProblem.g:4081:1: rule__Assertion__Group_0_1_3__0 : rule__Assertion__Group_0_1_3__0__Impl rule__Assertion__Group_0_1_3__1 ; |
11410 | public final void rule__Assertion__Group_0_1_3__0() throws RecognitionException { | 13006 | public final void rule__Assertion__Group_0_1_3__0() throws RecognitionException { |
11411 | 13007 | ||
11412 | int stackSize = keepStackSize(); | 13008 | int stackSize = keepStackSize(); |
11413 | 13009 | ||
11414 | try { | 13010 | try { |
11415 | // InternalProblem.g:3611:1: ( rule__Assertion__Group_0_1_3__0__Impl rule__Assertion__Group_0_1_3__1 ) | 13011 | // InternalProblem.g:4085:1: ( rule__Assertion__Group_0_1_3__0__Impl rule__Assertion__Group_0_1_3__1 ) |
11416 | // InternalProblem.g:3612:2: rule__Assertion__Group_0_1_3__0__Impl rule__Assertion__Group_0_1_3__1 | 13012 | // InternalProblem.g:4086:2: rule__Assertion__Group_0_1_3__0__Impl rule__Assertion__Group_0_1_3__1 |
11417 | { | 13013 | { |
11418 | pushFollow(FOLLOW_9); | 13014 | pushFollow(FOLLOW_9); |
11419 | rule__Assertion__Group_0_1_3__0__Impl(); | 13015 | rule__Assertion__Group_0_1_3__0__Impl(); |
@@ -11444,21 +13040,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11444 | 13040 | ||
11445 | 13041 | ||
11446 | // $ANTLR start "rule__Assertion__Group_0_1_3__0__Impl" | 13042 | // $ANTLR start "rule__Assertion__Group_0_1_3__0__Impl" |
11447 | // InternalProblem.g:3619:1: rule__Assertion__Group_0_1_3__0__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) ; | 13043 | // InternalProblem.g:4093:1: rule__Assertion__Group_0_1_3__0__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) ; |
11448 | public final void rule__Assertion__Group_0_1_3__0__Impl() throws RecognitionException { | 13044 | public final void rule__Assertion__Group_0_1_3__0__Impl() throws RecognitionException { |
11449 | 13045 | ||
11450 | int stackSize = keepStackSize(); | 13046 | int stackSize = keepStackSize(); |
11451 | 13047 | ||
11452 | try { | 13048 | try { |
11453 | // InternalProblem.g:3623:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) ) | 13049 | // InternalProblem.g:4097:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) ) |
11454 | // InternalProblem.g:3624:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) | 13050 | // InternalProblem.g:4098:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) |
11455 | { | 13051 | { |
11456 | // InternalProblem.g:3624:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) | 13052 | // InternalProblem.g:4098:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) |
11457 | // InternalProblem.g:3625:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) | 13053 | // InternalProblem.g:4099:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) |
11458 | { | 13054 | { |
11459 | before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0()); | 13055 | before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0()); |
11460 | // InternalProblem.g:3626:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) | 13056 | // InternalProblem.g:4100:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) |
11461 | // InternalProblem.g:3626:3: rule__Assertion__ArgumentsAssignment_0_1_3_0 | 13057 | // InternalProblem.g:4100:3: rule__Assertion__ArgumentsAssignment_0_1_3_0 |
11462 | { | 13058 | { |
11463 | pushFollow(FOLLOW_2); | 13059 | pushFollow(FOLLOW_2); |
11464 | rule__Assertion__ArgumentsAssignment_0_1_3_0(); | 13060 | rule__Assertion__ArgumentsAssignment_0_1_3_0(); |
@@ -11491,14 +13087,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11491 | 13087 | ||
11492 | 13088 | ||
11493 | // $ANTLR start "rule__Assertion__Group_0_1_3__1" | 13089 | // $ANTLR start "rule__Assertion__Group_0_1_3__1" |
11494 | // InternalProblem.g:3634:1: rule__Assertion__Group_0_1_3__1 : rule__Assertion__Group_0_1_3__1__Impl ; | 13090 | // InternalProblem.g:4108:1: rule__Assertion__Group_0_1_3__1 : rule__Assertion__Group_0_1_3__1__Impl ; |
11495 | public final void rule__Assertion__Group_0_1_3__1() throws RecognitionException { | 13091 | public final void rule__Assertion__Group_0_1_3__1() throws RecognitionException { |
11496 | 13092 | ||
11497 | int stackSize = keepStackSize(); | 13093 | int stackSize = keepStackSize(); |
11498 | 13094 | ||
11499 | try { | 13095 | try { |
11500 | // InternalProblem.g:3638:1: ( rule__Assertion__Group_0_1_3__1__Impl ) | 13096 | // InternalProblem.g:4112:1: ( rule__Assertion__Group_0_1_3__1__Impl ) |
11501 | // InternalProblem.g:3639:2: rule__Assertion__Group_0_1_3__1__Impl | 13097 | // InternalProblem.g:4113:2: rule__Assertion__Group_0_1_3__1__Impl |
11502 | { | 13098 | { |
11503 | pushFollow(FOLLOW_2); | 13099 | pushFollow(FOLLOW_2); |
11504 | rule__Assertion__Group_0_1_3__1__Impl(); | 13100 | rule__Assertion__Group_0_1_3__1__Impl(); |
@@ -11524,33 +13120,33 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11524 | 13120 | ||
11525 | 13121 | ||
11526 | // $ANTLR start "rule__Assertion__Group_0_1_3__1__Impl" | 13122 | // $ANTLR start "rule__Assertion__Group_0_1_3__1__Impl" |
11527 | // InternalProblem.g:3645:1: rule__Assertion__Group_0_1_3__1__Impl : ( ( rule__Assertion__Group_0_1_3_1__0 )* ) ; | 13123 | // InternalProblem.g:4119:1: rule__Assertion__Group_0_1_3__1__Impl : ( ( rule__Assertion__Group_0_1_3_1__0 )* ) ; |
11528 | public final void rule__Assertion__Group_0_1_3__1__Impl() throws RecognitionException { | 13124 | public final void rule__Assertion__Group_0_1_3__1__Impl() throws RecognitionException { |
11529 | 13125 | ||
11530 | int stackSize = keepStackSize(); | 13126 | int stackSize = keepStackSize(); |
11531 | 13127 | ||
11532 | try { | 13128 | try { |
11533 | // InternalProblem.g:3649:1: ( ( ( rule__Assertion__Group_0_1_3_1__0 )* ) ) | 13129 | // InternalProblem.g:4123:1: ( ( ( rule__Assertion__Group_0_1_3_1__0 )* ) ) |
11534 | // InternalProblem.g:3650:1: ( ( rule__Assertion__Group_0_1_3_1__0 )* ) | 13130 | // InternalProblem.g:4124:1: ( ( rule__Assertion__Group_0_1_3_1__0 )* ) |
11535 | { | 13131 | { |
11536 | // InternalProblem.g:3650:1: ( ( rule__Assertion__Group_0_1_3_1__0 )* ) | 13132 | // InternalProblem.g:4124:1: ( ( rule__Assertion__Group_0_1_3_1__0 )* ) |
11537 | // InternalProblem.g:3651:2: ( rule__Assertion__Group_0_1_3_1__0 )* | 13133 | // InternalProblem.g:4125:2: ( rule__Assertion__Group_0_1_3_1__0 )* |
11538 | { | 13134 | { |
11539 | before(grammarAccess.getAssertionAccess().getGroup_0_1_3_1()); | 13135 | before(grammarAccess.getAssertionAccess().getGroup_0_1_3_1()); |
11540 | // InternalProblem.g:3652:2: ( rule__Assertion__Group_0_1_3_1__0 )* | 13136 | // InternalProblem.g:4126:2: ( rule__Assertion__Group_0_1_3_1__0 )* |
11541 | loop45: | 13137 | loop51: |
11542 | do { | 13138 | do { |
11543 | int alt45=2; | 13139 | int alt51=2; |
11544 | int LA45_0 = input.LA(1); | 13140 | int LA51_0 = input.LA(1); |
11545 | 13141 | ||
11546 | if ( (LA45_0==13) ) { | 13142 | if ( (LA51_0==13) ) { |
11547 | alt45=1; | 13143 | alt51=1; |
11548 | } | 13144 | } |
11549 | 13145 | ||
11550 | 13146 | ||
11551 | switch (alt45) { | 13147 | switch (alt51) { |
11552 | case 1 : | 13148 | case 1 : |
11553 | // InternalProblem.g:3652:3: rule__Assertion__Group_0_1_3_1__0 | 13149 | // InternalProblem.g:4126:3: rule__Assertion__Group_0_1_3_1__0 |
11554 | { | 13150 | { |
11555 | pushFollow(FOLLOW_10); | 13151 | pushFollow(FOLLOW_10); |
11556 | rule__Assertion__Group_0_1_3_1__0(); | 13152 | rule__Assertion__Group_0_1_3_1__0(); |
@@ -11562,7 +13158,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11562 | break; | 13158 | break; |
11563 | 13159 | ||
11564 | default : | 13160 | default : |
11565 | break loop45; | 13161 | break loop51; |
11566 | } | 13162 | } |
11567 | } while (true); | 13163 | } while (true); |
11568 | 13164 | ||
@@ -11589,16 +13185,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11589 | 13185 | ||
11590 | 13186 | ||
11591 | // $ANTLR start "rule__Assertion__Group_0_1_3_1__0" | 13187 | // $ANTLR start "rule__Assertion__Group_0_1_3_1__0" |
11592 | // InternalProblem.g:3661:1: rule__Assertion__Group_0_1_3_1__0 : rule__Assertion__Group_0_1_3_1__0__Impl rule__Assertion__Group_0_1_3_1__1 ; | 13188 | // InternalProblem.g:4135:1: rule__Assertion__Group_0_1_3_1__0 : rule__Assertion__Group_0_1_3_1__0__Impl rule__Assertion__Group_0_1_3_1__1 ; |
11593 | public final void rule__Assertion__Group_0_1_3_1__0() throws RecognitionException { | 13189 | public final void rule__Assertion__Group_0_1_3_1__0() throws RecognitionException { |
11594 | 13190 | ||
11595 | int stackSize = keepStackSize(); | 13191 | int stackSize = keepStackSize(); |
11596 | 13192 | ||
11597 | try { | 13193 | try { |
11598 | // InternalProblem.g:3665:1: ( rule__Assertion__Group_0_1_3_1__0__Impl rule__Assertion__Group_0_1_3_1__1 ) | 13194 | // InternalProblem.g:4139:1: ( rule__Assertion__Group_0_1_3_1__0__Impl rule__Assertion__Group_0_1_3_1__1 ) |
11599 | // InternalProblem.g:3666:2: rule__Assertion__Group_0_1_3_1__0__Impl rule__Assertion__Group_0_1_3_1__1 | 13195 | // InternalProblem.g:4140:2: rule__Assertion__Group_0_1_3_1__0__Impl rule__Assertion__Group_0_1_3_1__1 |
11600 | { | 13196 | { |
11601 | pushFollow(FOLLOW_5); | 13197 | pushFollow(FOLLOW_30); |
11602 | rule__Assertion__Group_0_1_3_1__0__Impl(); | 13198 | rule__Assertion__Group_0_1_3_1__0__Impl(); |
11603 | 13199 | ||
11604 | state._fsp--; | 13200 | state._fsp--; |
@@ -11627,17 +13223,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11627 | 13223 | ||
11628 | 13224 | ||
11629 | // $ANTLR start "rule__Assertion__Group_0_1_3_1__0__Impl" | 13225 | // $ANTLR start "rule__Assertion__Group_0_1_3_1__0__Impl" |
11630 | // InternalProblem.g:3673:1: rule__Assertion__Group_0_1_3_1__0__Impl : ( ',' ) ; | 13226 | // InternalProblem.g:4147:1: rule__Assertion__Group_0_1_3_1__0__Impl : ( ',' ) ; |
11631 | public final void rule__Assertion__Group_0_1_3_1__0__Impl() throws RecognitionException { | 13227 | public final void rule__Assertion__Group_0_1_3_1__0__Impl() throws RecognitionException { |
11632 | 13228 | ||
11633 | int stackSize = keepStackSize(); | 13229 | int stackSize = keepStackSize(); |
11634 | 13230 | ||
11635 | try { | 13231 | try { |
11636 | // InternalProblem.g:3677:1: ( ( ',' ) ) | 13232 | // InternalProblem.g:4151:1: ( ( ',' ) ) |
11637 | // InternalProblem.g:3678:1: ( ',' ) | 13233 | // InternalProblem.g:4152:1: ( ',' ) |
11638 | { | 13234 | { |
11639 | // InternalProblem.g:3678:1: ( ',' ) | 13235 | // InternalProblem.g:4152:1: ( ',' ) |
11640 | // InternalProblem.g:3679:2: ',' | 13236 | // InternalProblem.g:4153:2: ',' |
11641 | { | 13237 | { |
11642 | before(grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); | 13238 | before(grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); |
11643 | match(input,13,FOLLOW_2); | 13239 | match(input,13,FOLLOW_2); |
@@ -11664,14 +13260,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11664 | 13260 | ||
11665 | 13261 | ||
11666 | // $ANTLR start "rule__Assertion__Group_0_1_3_1__1" | 13262 | // $ANTLR start "rule__Assertion__Group_0_1_3_1__1" |
11667 | // InternalProblem.g:3688:1: rule__Assertion__Group_0_1_3_1__1 : rule__Assertion__Group_0_1_3_1__1__Impl ; | 13263 | // InternalProblem.g:4162:1: rule__Assertion__Group_0_1_3_1__1 : rule__Assertion__Group_0_1_3_1__1__Impl ; |
11668 | public final void rule__Assertion__Group_0_1_3_1__1() throws RecognitionException { | 13264 | public final void rule__Assertion__Group_0_1_3_1__1() throws RecognitionException { |
11669 | 13265 | ||
11670 | int stackSize = keepStackSize(); | 13266 | int stackSize = keepStackSize(); |
11671 | 13267 | ||
11672 | try { | 13268 | try { |
11673 | // InternalProblem.g:3692:1: ( rule__Assertion__Group_0_1_3_1__1__Impl ) | 13269 | // InternalProblem.g:4166:1: ( rule__Assertion__Group_0_1_3_1__1__Impl ) |
11674 | // InternalProblem.g:3693:2: rule__Assertion__Group_0_1_3_1__1__Impl | 13270 | // InternalProblem.g:4167:2: rule__Assertion__Group_0_1_3_1__1__Impl |
11675 | { | 13271 | { |
11676 | pushFollow(FOLLOW_2); | 13272 | pushFollow(FOLLOW_2); |
11677 | rule__Assertion__Group_0_1_3_1__1__Impl(); | 13273 | rule__Assertion__Group_0_1_3_1__1__Impl(); |
@@ -11697,21 +13293,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11697 | 13293 | ||
11698 | 13294 | ||
11699 | // $ANTLR start "rule__Assertion__Group_0_1_3_1__1__Impl" | 13295 | // $ANTLR start "rule__Assertion__Group_0_1_3_1__1__Impl" |
11700 | // InternalProblem.g:3699:1: rule__Assertion__Group_0_1_3_1__1__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) ; | 13296 | // InternalProblem.g:4173:1: rule__Assertion__Group_0_1_3_1__1__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) ; |
11701 | public final void rule__Assertion__Group_0_1_3_1__1__Impl() throws RecognitionException { | 13297 | public final void rule__Assertion__Group_0_1_3_1__1__Impl() throws RecognitionException { |
11702 | 13298 | ||
11703 | int stackSize = keepStackSize(); | 13299 | int stackSize = keepStackSize(); |
11704 | 13300 | ||
11705 | try { | 13301 | try { |
11706 | // InternalProblem.g:3703:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) ) | 13302 | // InternalProblem.g:4177:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) ) |
11707 | // InternalProblem.g:3704:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) | 13303 | // InternalProblem.g:4178:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) |
11708 | { | 13304 | { |
11709 | // InternalProblem.g:3704:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) | 13305 | // InternalProblem.g:4178:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) |
11710 | // InternalProblem.g:3705:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) | 13306 | // InternalProblem.g:4179:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) |
11711 | { | 13307 | { |
11712 | before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1()); | 13308 | before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1()); |
11713 | // InternalProblem.g:3706:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) | 13309 | // InternalProblem.g:4180:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) |
11714 | // InternalProblem.g:3706:3: rule__Assertion__ArgumentsAssignment_0_1_3_1_1 | 13310 | // InternalProblem.g:4180:3: rule__Assertion__ArgumentsAssignment_0_1_3_1_1 |
11715 | { | 13311 | { |
11716 | pushFollow(FOLLOW_2); | 13312 | pushFollow(FOLLOW_2); |
11717 | rule__Assertion__ArgumentsAssignment_0_1_3_1_1(); | 13313 | rule__Assertion__ArgumentsAssignment_0_1_3_1_1(); |
@@ -11743,17 +13339,332 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11743 | // $ANTLR end "rule__Assertion__Group_0_1_3_1__1__Impl" | 13339 | // $ANTLR end "rule__Assertion__Group_0_1_3_1__1__Impl" |
11744 | 13340 | ||
11745 | 13341 | ||
13342 | // $ANTLR start "rule__NodeValueAssertion__Group__0" | ||
13343 | // InternalProblem.g:4189:1: rule__NodeValueAssertion__Group__0 : rule__NodeValueAssertion__Group__0__Impl rule__NodeValueAssertion__Group__1 ; | ||
13344 | public final void rule__NodeValueAssertion__Group__0() throws RecognitionException { | ||
13345 | |||
13346 | int stackSize = keepStackSize(); | ||
13347 | |||
13348 | try { | ||
13349 | // InternalProblem.g:4193:1: ( rule__NodeValueAssertion__Group__0__Impl rule__NodeValueAssertion__Group__1 ) | ||
13350 | // InternalProblem.g:4194:2: rule__NodeValueAssertion__Group__0__Impl rule__NodeValueAssertion__Group__1 | ||
13351 | { | ||
13352 | pushFollow(FOLLOW_31); | ||
13353 | rule__NodeValueAssertion__Group__0__Impl(); | ||
13354 | |||
13355 | state._fsp--; | ||
13356 | |||
13357 | pushFollow(FOLLOW_2); | ||
13358 | rule__NodeValueAssertion__Group__1(); | ||
13359 | |||
13360 | state._fsp--; | ||
13361 | |||
13362 | |||
13363 | } | ||
13364 | |||
13365 | } | ||
13366 | catch (RecognitionException re) { | ||
13367 | reportError(re); | ||
13368 | recover(input,re); | ||
13369 | } | ||
13370 | finally { | ||
13371 | |||
13372 | restoreStackSize(stackSize); | ||
13373 | |||
13374 | } | ||
13375 | return ; | ||
13376 | } | ||
13377 | // $ANTLR end "rule__NodeValueAssertion__Group__0" | ||
13378 | |||
13379 | |||
13380 | // $ANTLR start "rule__NodeValueAssertion__Group__0__Impl" | ||
13381 | // InternalProblem.g:4201:1: rule__NodeValueAssertion__Group__0__Impl : ( ( rule__NodeValueAssertion__NodeAssignment_0 ) ) ; | ||
13382 | public final void rule__NodeValueAssertion__Group__0__Impl() throws RecognitionException { | ||
13383 | |||
13384 | int stackSize = keepStackSize(); | ||
13385 | |||
13386 | try { | ||
13387 | // InternalProblem.g:4205:1: ( ( ( rule__NodeValueAssertion__NodeAssignment_0 ) ) ) | ||
13388 | // InternalProblem.g:4206:1: ( ( rule__NodeValueAssertion__NodeAssignment_0 ) ) | ||
13389 | { | ||
13390 | // InternalProblem.g:4206:1: ( ( rule__NodeValueAssertion__NodeAssignment_0 ) ) | ||
13391 | // InternalProblem.g:4207:2: ( rule__NodeValueAssertion__NodeAssignment_0 ) | ||
13392 | { | ||
13393 | before(grammarAccess.getNodeValueAssertionAccess().getNodeAssignment_0()); | ||
13394 | // InternalProblem.g:4208:2: ( rule__NodeValueAssertion__NodeAssignment_0 ) | ||
13395 | // InternalProblem.g:4208:3: rule__NodeValueAssertion__NodeAssignment_0 | ||
13396 | { | ||
13397 | pushFollow(FOLLOW_2); | ||
13398 | rule__NodeValueAssertion__NodeAssignment_0(); | ||
13399 | |||
13400 | state._fsp--; | ||
13401 | |||
13402 | |||
13403 | } | ||
13404 | |||
13405 | after(grammarAccess.getNodeValueAssertionAccess().getNodeAssignment_0()); | ||
13406 | |||
13407 | } | ||
13408 | |||
13409 | |||
13410 | } | ||
13411 | |||
13412 | } | ||
13413 | catch (RecognitionException re) { | ||
13414 | reportError(re); | ||
13415 | recover(input,re); | ||
13416 | } | ||
13417 | finally { | ||
13418 | |||
13419 | restoreStackSize(stackSize); | ||
13420 | |||
13421 | } | ||
13422 | return ; | ||
13423 | } | ||
13424 | // $ANTLR end "rule__NodeValueAssertion__Group__0__Impl" | ||
13425 | |||
13426 | |||
13427 | // $ANTLR start "rule__NodeValueAssertion__Group__1" | ||
13428 | // InternalProblem.g:4216:1: rule__NodeValueAssertion__Group__1 : rule__NodeValueAssertion__Group__1__Impl rule__NodeValueAssertion__Group__2 ; | ||
13429 | public final void rule__NodeValueAssertion__Group__1() throws RecognitionException { | ||
13430 | |||
13431 | int stackSize = keepStackSize(); | ||
13432 | |||
13433 | try { | ||
13434 | // InternalProblem.g:4220:1: ( rule__NodeValueAssertion__Group__1__Impl rule__NodeValueAssertion__Group__2 ) | ||
13435 | // InternalProblem.g:4221:2: rule__NodeValueAssertion__Group__1__Impl rule__NodeValueAssertion__Group__2 | ||
13436 | { | ||
13437 | pushFollow(FOLLOW_30); | ||
13438 | rule__NodeValueAssertion__Group__1__Impl(); | ||
13439 | |||
13440 | state._fsp--; | ||
13441 | |||
13442 | pushFollow(FOLLOW_2); | ||
13443 | rule__NodeValueAssertion__Group__2(); | ||
13444 | |||
13445 | state._fsp--; | ||
13446 | |||
13447 | |||
13448 | } | ||
13449 | |||
13450 | } | ||
13451 | catch (RecognitionException re) { | ||
13452 | reportError(re); | ||
13453 | recover(input,re); | ||
13454 | } | ||
13455 | finally { | ||
13456 | |||
13457 | restoreStackSize(stackSize); | ||
13458 | |||
13459 | } | ||
13460 | return ; | ||
13461 | } | ||
13462 | // $ANTLR end "rule__NodeValueAssertion__Group__1" | ||
13463 | |||
13464 | |||
13465 | // $ANTLR start "rule__NodeValueAssertion__Group__1__Impl" | ||
13466 | // InternalProblem.g:4228:1: rule__NodeValueAssertion__Group__1__Impl : ( ':' ) ; | ||
13467 | public final void rule__NodeValueAssertion__Group__1__Impl() throws RecognitionException { | ||
13468 | |||
13469 | int stackSize = keepStackSize(); | ||
13470 | |||
13471 | try { | ||
13472 | // InternalProblem.g:4232:1: ( ( ':' ) ) | ||
13473 | // InternalProblem.g:4233:1: ( ':' ) | ||
13474 | { | ||
13475 | // InternalProblem.g:4233:1: ( ':' ) | ||
13476 | // InternalProblem.g:4234:2: ':' | ||
13477 | { | ||
13478 | before(grammarAccess.getNodeValueAssertionAccess().getColonKeyword_1()); | ||
13479 | match(input,40,FOLLOW_2); | ||
13480 | after(grammarAccess.getNodeValueAssertionAccess().getColonKeyword_1()); | ||
13481 | |||
13482 | } | ||
13483 | |||
13484 | |||
13485 | } | ||
13486 | |||
13487 | } | ||
13488 | catch (RecognitionException re) { | ||
13489 | reportError(re); | ||
13490 | recover(input,re); | ||
13491 | } | ||
13492 | finally { | ||
13493 | |||
13494 | restoreStackSize(stackSize); | ||
13495 | |||
13496 | } | ||
13497 | return ; | ||
13498 | } | ||
13499 | // $ANTLR end "rule__NodeValueAssertion__Group__1__Impl" | ||
13500 | |||
13501 | |||
13502 | // $ANTLR start "rule__NodeValueAssertion__Group__2" | ||
13503 | // InternalProblem.g:4243:1: rule__NodeValueAssertion__Group__2 : rule__NodeValueAssertion__Group__2__Impl rule__NodeValueAssertion__Group__3 ; | ||
13504 | public final void rule__NodeValueAssertion__Group__2() throws RecognitionException { | ||
13505 | |||
13506 | int stackSize = keepStackSize(); | ||
13507 | |||
13508 | try { | ||
13509 | // InternalProblem.g:4247:1: ( rule__NodeValueAssertion__Group__2__Impl rule__NodeValueAssertion__Group__3 ) | ||
13510 | // InternalProblem.g:4248:2: rule__NodeValueAssertion__Group__2__Impl rule__NodeValueAssertion__Group__3 | ||
13511 | { | ||
13512 | pushFollow(FOLLOW_6); | ||
13513 | rule__NodeValueAssertion__Group__2__Impl(); | ||
13514 | |||
13515 | state._fsp--; | ||
13516 | |||
13517 | pushFollow(FOLLOW_2); | ||
13518 | rule__NodeValueAssertion__Group__3(); | ||
13519 | |||
13520 | state._fsp--; | ||
13521 | |||
13522 | |||
13523 | } | ||
13524 | |||
13525 | } | ||
13526 | catch (RecognitionException re) { | ||
13527 | reportError(re); | ||
13528 | recover(input,re); | ||
13529 | } | ||
13530 | finally { | ||
13531 | |||
13532 | restoreStackSize(stackSize); | ||
13533 | |||
13534 | } | ||
13535 | return ; | ||
13536 | } | ||
13537 | // $ANTLR end "rule__NodeValueAssertion__Group__2" | ||
13538 | |||
13539 | |||
13540 | // $ANTLR start "rule__NodeValueAssertion__Group__2__Impl" | ||
13541 | // InternalProblem.g:4255:1: rule__NodeValueAssertion__Group__2__Impl : ( ( rule__NodeValueAssertion__ValueAssignment_2 ) ) ; | ||
13542 | public final void rule__NodeValueAssertion__Group__2__Impl() throws RecognitionException { | ||
13543 | |||
13544 | int stackSize = keepStackSize(); | ||
13545 | |||
13546 | try { | ||
13547 | // InternalProblem.g:4259:1: ( ( ( rule__NodeValueAssertion__ValueAssignment_2 ) ) ) | ||
13548 | // InternalProblem.g:4260:1: ( ( rule__NodeValueAssertion__ValueAssignment_2 ) ) | ||
13549 | { | ||
13550 | // InternalProblem.g:4260:1: ( ( rule__NodeValueAssertion__ValueAssignment_2 ) ) | ||
13551 | // InternalProblem.g:4261:2: ( rule__NodeValueAssertion__ValueAssignment_2 ) | ||
13552 | { | ||
13553 | before(grammarAccess.getNodeValueAssertionAccess().getValueAssignment_2()); | ||
13554 | // InternalProblem.g:4262:2: ( rule__NodeValueAssertion__ValueAssignment_2 ) | ||
13555 | // InternalProblem.g:4262:3: rule__NodeValueAssertion__ValueAssignment_2 | ||
13556 | { | ||
13557 | pushFollow(FOLLOW_2); | ||
13558 | rule__NodeValueAssertion__ValueAssignment_2(); | ||
13559 | |||
13560 | state._fsp--; | ||
13561 | |||
13562 | |||
13563 | } | ||
13564 | |||
13565 | after(grammarAccess.getNodeValueAssertionAccess().getValueAssignment_2()); | ||
13566 | |||
13567 | } | ||
13568 | |||
13569 | |||
13570 | } | ||
13571 | |||
13572 | } | ||
13573 | catch (RecognitionException re) { | ||
13574 | reportError(re); | ||
13575 | recover(input,re); | ||
13576 | } | ||
13577 | finally { | ||
13578 | |||
13579 | restoreStackSize(stackSize); | ||
13580 | |||
13581 | } | ||
13582 | return ; | ||
13583 | } | ||
13584 | // $ANTLR end "rule__NodeValueAssertion__Group__2__Impl" | ||
13585 | |||
13586 | |||
13587 | // $ANTLR start "rule__NodeValueAssertion__Group__3" | ||
13588 | // InternalProblem.g:4270:1: rule__NodeValueAssertion__Group__3 : rule__NodeValueAssertion__Group__3__Impl ; | ||
13589 | public final void rule__NodeValueAssertion__Group__3() throws RecognitionException { | ||
13590 | |||
13591 | int stackSize = keepStackSize(); | ||
13592 | |||
13593 | try { | ||
13594 | // InternalProblem.g:4274:1: ( rule__NodeValueAssertion__Group__3__Impl ) | ||
13595 | // InternalProblem.g:4275:2: rule__NodeValueAssertion__Group__3__Impl | ||
13596 | { | ||
13597 | pushFollow(FOLLOW_2); | ||
13598 | rule__NodeValueAssertion__Group__3__Impl(); | ||
13599 | |||
13600 | state._fsp--; | ||
13601 | |||
13602 | |||
13603 | } | ||
13604 | |||
13605 | } | ||
13606 | catch (RecognitionException re) { | ||
13607 | reportError(re); | ||
13608 | recover(input,re); | ||
13609 | } | ||
13610 | finally { | ||
13611 | |||
13612 | restoreStackSize(stackSize); | ||
13613 | |||
13614 | } | ||
13615 | return ; | ||
13616 | } | ||
13617 | // $ANTLR end "rule__NodeValueAssertion__Group__3" | ||
13618 | |||
13619 | |||
13620 | // $ANTLR start "rule__NodeValueAssertion__Group__3__Impl" | ||
13621 | // InternalProblem.g:4281:1: rule__NodeValueAssertion__Group__3__Impl : ( '.' ) ; | ||
13622 | public final void rule__NodeValueAssertion__Group__3__Impl() throws RecognitionException { | ||
13623 | |||
13624 | int stackSize = keepStackSize(); | ||
13625 | |||
13626 | try { | ||
13627 | // InternalProblem.g:4285:1: ( ( '.' ) ) | ||
13628 | // InternalProblem.g:4286:1: ( '.' ) | ||
13629 | { | ||
13630 | // InternalProblem.g:4286:1: ( '.' ) | ||
13631 | // InternalProblem.g:4287:2: '.' | ||
13632 | { | ||
13633 | before(grammarAccess.getNodeValueAssertionAccess().getFullStopKeyword_3()); | ||
13634 | match(input,12,FOLLOW_2); | ||
13635 | after(grammarAccess.getNodeValueAssertionAccess().getFullStopKeyword_3()); | ||
13636 | |||
13637 | } | ||
13638 | |||
13639 | |||
13640 | } | ||
13641 | |||
13642 | } | ||
13643 | catch (RecognitionException re) { | ||
13644 | reportError(re); | ||
13645 | recover(input,re); | ||
13646 | } | ||
13647 | finally { | ||
13648 | |||
13649 | restoreStackSize(stackSize); | ||
13650 | |||
13651 | } | ||
13652 | return ; | ||
13653 | } | ||
13654 | // $ANTLR end "rule__NodeValueAssertion__Group__3__Impl" | ||
13655 | |||
13656 | |||
11746 | // $ANTLR start "rule__ScopeDeclaration__Group__0" | 13657 | // $ANTLR start "rule__ScopeDeclaration__Group__0" |
11747 | // InternalProblem.g:3715:1: rule__ScopeDeclaration__Group__0 : rule__ScopeDeclaration__Group__0__Impl rule__ScopeDeclaration__Group__1 ; | 13658 | // InternalProblem.g:4297:1: rule__ScopeDeclaration__Group__0 : rule__ScopeDeclaration__Group__0__Impl rule__ScopeDeclaration__Group__1 ; |
11748 | public final void rule__ScopeDeclaration__Group__0() throws RecognitionException { | 13659 | public final void rule__ScopeDeclaration__Group__0() throws RecognitionException { |
11749 | 13660 | ||
11750 | int stackSize = keepStackSize(); | 13661 | int stackSize = keepStackSize(); |
11751 | 13662 | ||
11752 | try { | 13663 | try { |
11753 | // InternalProblem.g:3719:1: ( rule__ScopeDeclaration__Group__0__Impl rule__ScopeDeclaration__Group__1 ) | 13664 | // InternalProblem.g:4301:1: ( rule__ScopeDeclaration__Group__0__Impl rule__ScopeDeclaration__Group__1 ) |
11754 | // InternalProblem.g:3720:2: rule__ScopeDeclaration__Group__0__Impl rule__ScopeDeclaration__Group__1 | 13665 | // InternalProblem.g:4302:2: rule__ScopeDeclaration__Group__0__Impl rule__ScopeDeclaration__Group__1 |
11755 | { | 13666 | { |
11756 | pushFollow(FOLLOW_32); | 13667 | pushFollow(FOLLOW_34); |
11757 | rule__ScopeDeclaration__Group__0__Impl(); | 13668 | rule__ScopeDeclaration__Group__0__Impl(); |
11758 | 13669 | ||
11759 | state._fsp--; | 13670 | state._fsp--; |
@@ -11782,20 +13693,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11782 | 13693 | ||
11783 | 13694 | ||
11784 | // $ANTLR start "rule__ScopeDeclaration__Group__0__Impl" | 13695 | // $ANTLR start "rule__ScopeDeclaration__Group__0__Impl" |
11785 | // InternalProblem.g:3727:1: rule__ScopeDeclaration__Group__0__Impl : ( 'scope' ) ; | 13696 | // InternalProblem.g:4309:1: rule__ScopeDeclaration__Group__0__Impl : ( 'scope' ) ; |
11786 | public final void rule__ScopeDeclaration__Group__0__Impl() throws RecognitionException { | 13697 | public final void rule__ScopeDeclaration__Group__0__Impl() throws RecognitionException { |
11787 | 13698 | ||
11788 | int stackSize = keepStackSize(); | 13699 | int stackSize = keepStackSize(); |
11789 | 13700 | ||
11790 | try { | 13701 | try { |
11791 | // InternalProblem.g:3731:1: ( ( 'scope' ) ) | 13702 | // InternalProblem.g:4313:1: ( ( 'scope' ) ) |
11792 | // InternalProblem.g:3732:1: ( 'scope' ) | 13703 | // InternalProblem.g:4314:1: ( 'scope' ) |
11793 | { | 13704 | { |
11794 | // InternalProblem.g:3732:1: ( 'scope' ) | 13705 | // InternalProblem.g:4314:1: ( 'scope' ) |
11795 | // InternalProblem.g:3733:2: 'scope' | 13706 | // InternalProblem.g:4315:2: 'scope' |
11796 | { | 13707 | { |
11797 | before(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); | 13708 | before(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); |
11798 | match(input,37,FOLLOW_2); | 13709 | match(input,41,FOLLOW_2); |
11799 | after(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); | 13710 | after(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); |
11800 | 13711 | ||
11801 | } | 13712 | } |
@@ -11819,16 +13730,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11819 | 13730 | ||
11820 | 13731 | ||
11821 | // $ANTLR start "rule__ScopeDeclaration__Group__1" | 13732 | // $ANTLR start "rule__ScopeDeclaration__Group__1" |
11822 | // InternalProblem.g:3742:1: rule__ScopeDeclaration__Group__1 : rule__ScopeDeclaration__Group__1__Impl rule__ScopeDeclaration__Group__2 ; | 13733 | // InternalProblem.g:4324:1: rule__ScopeDeclaration__Group__1 : rule__ScopeDeclaration__Group__1__Impl rule__ScopeDeclaration__Group__2 ; |
11823 | public final void rule__ScopeDeclaration__Group__1() throws RecognitionException { | 13734 | public final void rule__ScopeDeclaration__Group__1() throws RecognitionException { |
11824 | 13735 | ||
11825 | int stackSize = keepStackSize(); | 13736 | int stackSize = keepStackSize(); |
11826 | 13737 | ||
11827 | try { | 13738 | try { |
11828 | // InternalProblem.g:3746:1: ( rule__ScopeDeclaration__Group__1__Impl rule__ScopeDeclaration__Group__2 ) | 13739 | // InternalProblem.g:4328:1: ( rule__ScopeDeclaration__Group__1__Impl rule__ScopeDeclaration__Group__2 ) |
11829 | // InternalProblem.g:3747:2: rule__ScopeDeclaration__Group__1__Impl rule__ScopeDeclaration__Group__2 | 13740 | // InternalProblem.g:4329:2: rule__ScopeDeclaration__Group__1__Impl rule__ScopeDeclaration__Group__2 |
11830 | { | 13741 | { |
11831 | pushFollow(FOLLOW_33); | 13742 | pushFollow(FOLLOW_35); |
11832 | rule__ScopeDeclaration__Group__1__Impl(); | 13743 | rule__ScopeDeclaration__Group__1__Impl(); |
11833 | 13744 | ||
11834 | state._fsp--; | 13745 | state._fsp--; |
@@ -11857,21 +13768,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11857 | 13768 | ||
11858 | 13769 | ||
11859 | // $ANTLR start "rule__ScopeDeclaration__Group__1__Impl" | 13770 | // $ANTLR start "rule__ScopeDeclaration__Group__1__Impl" |
11860 | // InternalProblem.g:3754:1: rule__ScopeDeclaration__Group__1__Impl : ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) ; | 13771 | // InternalProblem.g:4336:1: rule__ScopeDeclaration__Group__1__Impl : ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) ; |
11861 | public final void rule__ScopeDeclaration__Group__1__Impl() throws RecognitionException { | 13772 | public final void rule__ScopeDeclaration__Group__1__Impl() throws RecognitionException { |
11862 | 13773 | ||
11863 | int stackSize = keepStackSize(); | 13774 | int stackSize = keepStackSize(); |
11864 | 13775 | ||
11865 | try { | 13776 | try { |
11866 | // InternalProblem.g:3758:1: ( ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) ) | 13777 | // InternalProblem.g:4340:1: ( ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) ) |
11867 | // InternalProblem.g:3759:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) | 13778 | // InternalProblem.g:4341:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) |
11868 | { | 13779 | { |
11869 | // InternalProblem.g:3759:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) | 13780 | // InternalProblem.g:4341:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) |
11870 | // InternalProblem.g:3760:2: ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) | 13781 | // InternalProblem.g:4342:2: ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) |
11871 | { | 13782 | { |
11872 | before(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1()); | 13783 | before(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1()); |
11873 | // InternalProblem.g:3761:2: ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) | 13784 | // InternalProblem.g:4343:2: ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) |
11874 | // InternalProblem.g:3761:3: rule__ScopeDeclaration__TypeScopesAssignment_1 | 13785 | // InternalProblem.g:4343:3: rule__ScopeDeclaration__TypeScopesAssignment_1 |
11875 | { | 13786 | { |
11876 | pushFollow(FOLLOW_2); | 13787 | pushFollow(FOLLOW_2); |
11877 | rule__ScopeDeclaration__TypeScopesAssignment_1(); | 13788 | rule__ScopeDeclaration__TypeScopesAssignment_1(); |
@@ -11904,16 +13815,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11904 | 13815 | ||
11905 | 13816 | ||
11906 | // $ANTLR start "rule__ScopeDeclaration__Group__2" | 13817 | // $ANTLR start "rule__ScopeDeclaration__Group__2" |
11907 | // InternalProblem.g:3769:1: rule__ScopeDeclaration__Group__2 : rule__ScopeDeclaration__Group__2__Impl rule__ScopeDeclaration__Group__3 ; | 13818 | // InternalProblem.g:4351:1: rule__ScopeDeclaration__Group__2 : rule__ScopeDeclaration__Group__2__Impl rule__ScopeDeclaration__Group__3 ; |
11908 | public final void rule__ScopeDeclaration__Group__2() throws RecognitionException { | 13819 | public final void rule__ScopeDeclaration__Group__2() throws RecognitionException { |
11909 | 13820 | ||
11910 | int stackSize = keepStackSize(); | 13821 | int stackSize = keepStackSize(); |
11911 | 13822 | ||
11912 | try { | 13823 | try { |
11913 | // InternalProblem.g:3773:1: ( rule__ScopeDeclaration__Group__2__Impl rule__ScopeDeclaration__Group__3 ) | 13824 | // InternalProblem.g:4355:1: ( rule__ScopeDeclaration__Group__2__Impl rule__ScopeDeclaration__Group__3 ) |
11914 | // InternalProblem.g:3774:2: rule__ScopeDeclaration__Group__2__Impl rule__ScopeDeclaration__Group__3 | 13825 | // InternalProblem.g:4356:2: rule__ScopeDeclaration__Group__2__Impl rule__ScopeDeclaration__Group__3 |
11915 | { | 13826 | { |
11916 | pushFollow(FOLLOW_33); | 13827 | pushFollow(FOLLOW_35); |
11917 | rule__ScopeDeclaration__Group__2__Impl(); | 13828 | rule__ScopeDeclaration__Group__2__Impl(); |
11918 | 13829 | ||
11919 | state._fsp--; | 13830 | state._fsp--; |
@@ -11942,33 +13853,33 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11942 | 13853 | ||
11943 | 13854 | ||
11944 | // $ANTLR start "rule__ScopeDeclaration__Group__2__Impl" | 13855 | // $ANTLR start "rule__ScopeDeclaration__Group__2__Impl" |
11945 | // InternalProblem.g:3781:1: rule__ScopeDeclaration__Group__2__Impl : ( ( rule__ScopeDeclaration__Group_2__0 )* ) ; | 13856 | // InternalProblem.g:4363:1: rule__ScopeDeclaration__Group__2__Impl : ( ( rule__ScopeDeclaration__Group_2__0 )* ) ; |
11946 | public final void rule__ScopeDeclaration__Group__2__Impl() throws RecognitionException { | 13857 | public final void rule__ScopeDeclaration__Group__2__Impl() throws RecognitionException { |
11947 | 13858 | ||
11948 | int stackSize = keepStackSize(); | 13859 | int stackSize = keepStackSize(); |
11949 | 13860 | ||
11950 | try { | 13861 | try { |
11951 | // InternalProblem.g:3785:1: ( ( ( rule__ScopeDeclaration__Group_2__0 )* ) ) | 13862 | // InternalProblem.g:4367:1: ( ( ( rule__ScopeDeclaration__Group_2__0 )* ) ) |
11952 | // InternalProblem.g:3786:1: ( ( rule__ScopeDeclaration__Group_2__0 )* ) | 13863 | // InternalProblem.g:4368:1: ( ( rule__ScopeDeclaration__Group_2__0 )* ) |
11953 | { | 13864 | { |
11954 | // InternalProblem.g:3786:1: ( ( rule__ScopeDeclaration__Group_2__0 )* ) | 13865 | // InternalProblem.g:4368:1: ( ( rule__ScopeDeclaration__Group_2__0 )* ) |
11955 | // InternalProblem.g:3787:2: ( rule__ScopeDeclaration__Group_2__0 )* | 13866 | // InternalProblem.g:4369:2: ( rule__ScopeDeclaration__Group_2__0 )* |
11956 | { | 13867 | { |
11957 | before(grammarAccess.getScopeDeclarationAccess().getGroup_2()); | 13868 | before(grammarAccess.getScopeDeclarationAccess().getGroup_2()); |
11958 | // InternalProblem.g:3788:2: ( rule__ScopeDeclaration__Group_2__0 )* | 13869 | // InternalProblem.g:4370:2: ( rule__ScopeDeclaration__Group_2__0 )* |
11959 | loop46: | 13870 | loop52: |
11960 | do { | 13871 | do { |
11961 | int alt46=2; | 13872 | int alt52=2; |
11962 | int LA46_0 = input.LA(1); | 13873 | int LA52_0 = input.LA(1); |
11963 | 13874 | ||
11964 | if ( (LA46_0==13) ) { | 13875 | if ( (LA52_0==13) ) { |
11965 | alt46=1; | 13876 | alt52=1; |
11966 | } | 13877 | } |
11967 | 13878 | ||
11968 | 13879 | ||
11969 | switch (alt46) { | 13880 | switch (alt52) { |
11970 | case 1 : | 13881 | case 1 : |
11971 | // InternalProblem.g:3788:3: rule__ScopeDeclaration__Group_2__0 | 13882 | // InternalProblem.g:4370:3: rule__ScopeDeclaration__Group_2__0 |
11972 | { | 13883 | { |
11973 | pushFollow(FOLLOW_10); | 13884 | pushFollow(FOLLOW_10); |
11974 | rule__ScopeDeclaration__Group_2__0(); | 13885 | rule__ScopeDeclaration__Group_2__0(); |
@@ -11980,7 +13891,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
11980 | break; | 13891 | break; |
11981 | 13892 | ||
11982 | default : | 13893 | default : |
11983 | break loop46; | 13894 | break loop52; |
11984 | } | 13895 | } |
11985 | } while (true); | 13896 | } while (true); |
11986 | 13897 | ||
@@ -12007,14 +13918,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12007 | 13918 | ||
12008 | 13919 | ||
12009 | // $ANTLR start "rule__ScopeDeclaration__Group__3" | 13920 | // $ANTLR start "rule__ScopeDeclaration__Group__3" |
12010 | // InternalProblem.g:3796:1: rule__ScopeDeclaration__Group__3 : rule__ScopeDeclaration__Group__3__Impl ; | 13921 | // InternalProblem.g:4378:1: rule__ScopeDeclaration__Group__3 : rule__ScopeDeclaration__Group__3__Impl ; |
12011 | public final void rule__ScopeDeclaration__Group__3() throws RecognitionException { | 13922 | public final void rule__ScopeDeclaration__Group__3() throws RecognitionException { |
12012 | 13923 | ||
12013 | int stackSize = keepStackSize(); | 13924 | int stackSize = keepStackSize(); |
12014 | 13925 | ||
12015 | try { | 13926 | try { |
12016 | // InternalProblem.g:3800:1: ( rule__ScopeDeclaration__Group__3__Impl ) | 13927 | // InternalProblem.g:4382:1: ( rule__ScopeDeclaration__Group__3__Impl ) |
12017 | // InternalProblem.g:3801:2: rule__ScopeDeclaration__Group__3__Impl | 13928 | // InternalProblem.g:4383:2: rule__ScopeDeclaration__Group__3__Impl |
12018 | { | 13929 | { |
12019 | pushFollow(FOLLOW_2); | 13930 | pushFollow(FOLLOW_2); |
12020 | rule__ScopeDeclaration__Group__3__Impl(); | 13931 | rule__ScopeDeclaration__Group__3__Impl(); |
@@ -12040,17 +13951,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12040 | 13951 | ||
12041 | 13952 | ||
12042 | // $ANTLR start "rule__ScopeDeclaration__Group__3__Impl" | 13953 | // $ANTLR start "rule__ScopeDeclaration__Group__3__Impl" |
12043 | // InternalProblem.g:3807:1: rule__ScopeDeclaration__Group__3__Impl : ( '.' ) ; | 13954 | // InternalProblem.g:4389:1: rule__ScopeDeclaration__Group__3__Impl : ( '.' ) ; |
12044 | public final void rule__ScopeDeclaration__Group__3__Impl() throws RecognitionException { | 13955 | public final void rule__ScopeDeclaration__Group__3__Impl() throws RecognitionException { |
12045 | 13956 | ||
12046 | int stackSize = keepStackSize(); | 13957 | int stackSize = keepStackSize(); |
12047 | 13958 | ||
12048 | try { | 13959 | try { |
12049 | // InternalProblem.g:3811:1: ( ( '.' ) ) | 13960 | // InternalProblem.g:4393:1: ( ( '.' ) ) |
12050 | // InternalProblem.g:3812:1: ( '.' ) | 13961 | // InternalProblem.g:4394:1: ( '.' ) |
12051 | { | 13962 | { |
12052 | // InternalProblem.g:3812:1: ( '.' ) | 13963 | // InternalProblem.g:4394:1: ( '.' ) |
12053 | // InternalProblem.g:3813:2: '.' | 13964 | // InternalProblem.g:4395:2: '.' |
12054 | { | 13965 | { |
12055 | before(grammarAccess.getScopeDeclarationAccess().getFullStopKeyword_3()); | 13966 | before(grammarAccess.getScopeDeclarationAccess().getFullStopKeyword_3()); |
12056 | match(input,12,FOLLOW_2); | 13967 | match(input,12,FOLLOW_2); |
@@ -12077,16 +13988,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12077 | 13988 | ||
12078 | 13989 | ||
12079 | // $ANTLR start "rule__ScopeDeclaration__Group_2__0" | 13990 | // $ANTLR start "rule__ScopeDeclaration__Group_2__0" |
12080 | // InternalProblem.g:3823:1: rule__ScopeDeclaration__Group_2__0 : rule__ScopeDeclaration__Group_2__0__Impl rule__ScopeDeclaration__Group_2__1 ; | 13991 | // InternalProblem.g:4405:1: rule__ScopeDeclaration__Group_2__0 : rule__ScopeDeclaration__Group_2__0__Impl rule__ScopeDeclaration__Group_2__1 ; |
12081 | public final void rule__ScopeDeclaration__Group_2__0() throws RecognitionException { | 13992 | public final void rule__ScopeDeclaration__Group_2__0() throws RecognitionException { |
12082 | 13993 | ||
12083 | int stackSize = keepStackSize(); | 13994 | int stackSize = keepStackSize(); |
12084 | 13995 | ||
12085 | try { | 13996 | try { |
12086 | // InternalProblem.g:3827:1: ( rule__ScopeDeclaration__Group_2__0__Impl rule__ScopeDeclaration__Group_2__1 ) | 13997 | // InternalProblem.g:4409:1: ( rule__ScopeDeclaration__Group_2__0__Impl rule__ScopeDeclaration__Group_2__1 ) |
12087 | // InternalProblem.g:3828:2: rule__ScopeDeclaration__Group_2__0__Impl rule__ScopeDeclaration__Group_2__1 | 13998 | // InternalProblem.g:4410:2: rule__ScopeDeclaration__Group_2__0__Impl rule__ScopeDeclaration__Group_2__1 |
12088 | { | 13999 | { |
12089 | pushFollow(FOLLOW_32); | 14000 | pushFollow(FOLLOW_34); |
12090 | rule__ScopeDeclaration__Group_2__0__Impl(); | 14001 | rule__ScopeDeclaration__Group_2__0__Impl(); |
12091 | 14002 | ||
12092 | state._fsp--; | 14003 | state._fsp--; |
@@ -12115,17 +14026,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12115 | 14026 | ||
12116 | 14027 | ||
12117 | // $ANTLR start "rule__ScopeDeclaration__Group_2__0__Impl" | 14028 | // $ANTLR start "rule__ScopeDeclaration__Group_2__0__Impl" |
12118 | // InternalProblem.g:3835:1: rule__ScopeDeclaration__Group_2__0__Impl : ( ',' ) ; | 14029 | // InternalProblem.g:4417:1: rule__ScopeDeclaration__Group_2__0__Impl : ( ',' ) ; |
12119 | public final void rule__ScopeDeclaration__Group_2__0__Impl() throws RecognitionException { | 14030 | public final void rule__ScopeDeclaration__Group_2__0__Impl() throws RecognitionException { |
12120 | 14031 | ||
12121 | int stackSize = keepStackSize(); | 14032 | int stackSize = keepStackSize(); |
12122 | 14033 | ||
12123 | try { | 14034 | try { |
12124 | // InternalProblem.g:3839:1: ( ( ',' ) ) | 14035 | // InternalProblem.g:4421:1: ( ( ',' ) ) |
12125 | // InternalProblem.g:3840:1: ( ',' ) | 14036 | // InternalProblem.g:4422:1: ( ',' ) |
12126 | { | 14037 | { |
12127 | // InternalProblem.g:3840:1: ( ',' ) | 14038 | // InternalProblem.g:4422:1: ( ',' ) |
12128 | // InternalProblem.g:3841:2: ',' | 14039 | // InternalProblem.g:4423:2: ',' |
12129 | { | 14040 | { |
12130 | before(grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); | 14041 | before(grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); |
12131 | match(input,13,FOLLOW_2); | 14042 | match(input,13,FOLLOW_2); |
@@ -12152,14 +14063,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12152 | 14063 | ||
12153 | 14064 | ||
12154 | // $ANTLR start "rule__ScopeDeclaration__Group_2__1" | 14065 | // $ANTLR start "rule__ScopeDeclaration__Group_2__1" |
12155 | // InternalProblem.g:3850:1: rule__ScopeDeclaration__Group_2__1 : rule__ScopeDeclaration__Group_2__1__Impl ; | 14066 | // InternalProblem.g:4432:1: rule__ScopeDeclaration__Group_2__1 : rule__ScopeDeclaration__Group_2__1__Impl ; |
12156 | public final void rule__ScopeDeclaration__Group_2__1() throws RecognitionException { | 14067 | public final void rule__ScopeDeclaration__Group_2__1() throws RecognitionException { |
12157 | 14068 | ||
12158 | int stackSize = keepStackSize(); | 14069 | int stackSize = keepStackSize(); |
12159 | 14070 | ||
12160 | try { | 14071 | try { |
12161 | // InternalProblem.g:3854:1: ( rule__ScopeDeclaration__Group_2__1__Impl ) | 14072 | // InternalProblem.g:4436:1: ( rule__ScopeDeclaration__Group_2__1__Impl ) |
12162 | // InternalProblem.g:3855:2: rule__ScopeDeclaration__Group_2__1__Impl | 14073 | // InternalProblem.g:4437:2: rule__ScopeDeclaration__Group_2__1__Impl |
12163 | { | 14074 | { |
12164 | pushFollow(FOLLOW_2); | 14075 | pushFollow(FOLLOW_2); |
12165 | rule__ScopeDeclaration__Group_2__1__Impl(); | 14076 | rule__ScopeDeclaration__Group_2__1__Impl(); |
@@ -12185,21 +14096,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12185 | 14096 | ||
12186 | 14097 | ||
12187 | // $ANTLR start "rule__ScopeDeclaration__Group_2__1__Impl" | 14098 | // $ANTLR start "rule__ScopeDeclaration__Group_2__1__Impl" |
12188 | // InternalProblem.g:3861:1: rule__ScopeDeclaration__Group_2__1__Impl : ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) ; | 14099 | // InternalProblem.g:4443:1: rule__ScopeDeclaration__Group_2__1__Impl : ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) ; |
12189 | public final void rule__ScopeDeclaration__Group_2__1__Impl() throws RecognitionException { | 14100 | public final void rule__ScopeDeclaration__Group_2__1__Impl() throws RecognitionException { |
12190 | 14101 | ||
12191 | int stackSize = keepStackSize(); | 14102 | int stackSize = keepStackSize(); |
12192 | 14103 | ||
12193 | try { | 14104 | try { |
12194 | // InternalProblem.g:3865:1: ( ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) ) | 14105 | // InternalProblem.g:4447:1: ( ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) ) |
12195 | // InternalProblem.g:3866:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) | 14106 | // InternalProblem.g:4448:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) |
12196 | { | 14107 | { |
12197 | // InternalProblem.g:3866:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) | 14108 | // InternalProblem.g:4448:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) |
12198 | // InternalProblem.g:3867:2: ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) | 14109 | // InternalProblem.g:4449:2: ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) |
12199 | { | 14110 | { |
12200 | before(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1()); | 14111 | before(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1()); |
12201 | // InternalProblem.g:3868:2: ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) | 14112 | // InternalProblem.g:4450:2: ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) |
12202 | // InternalProblem.g:3868:3: rule__ScopeDeclaration__TypeScopesAssignment_2_1 | 14113 | // InternalProblem.g:4450:3: rule__ScopeDeclaration__TypeScopesAssignment_2_1 |
12203 | { | 14114 | { |
12204 | pushFollow(FOLLOW_2); | 14115 | pushFollow(FOLLOW_2); |
12205 | rule__ScopeDeclaration__TypeScopesAssignment_2_1(); | 14116 | rule__ScopeDeclaration__TypeScopesAssignment_2_1(); |
@@ -12232,16 +14143,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12232 | 14143 | ||
12233 | 14144 | ||
12234 | // $ANTLR start "rule__TypeScope__Group__0" | 14145 | // $ANTLR start "rule__TypeScope__Group__0" |
12235 | // InternalProblem.g:3877:1: rule__TypeScope__Group__0 : rule__TypeScope__Group__0__Impl rule__TypeScope__Group__1 ; | 14146 | // InternalProblem.g:4459:1: rule__TypeScope__Group__0 : rule__TypeScope__Group__0__Impl rule__TypeScope__Group__1 ; |
12236 | public final void rule__TypeScope__Group__0() throws RecognitionException { | 14147 | public final void rule__TypeScope__Group__0() throws RecognitionException { |
12237 | 14148 | ||
12238 | int stackSize = keepStackSize(); | 14149 | int stackSize = keepStackSize(); |
12239 | 14150 | ||
12240 | try { | 14151 | try { |
12241 | // InternalProblem.g:3881:1: ( rule__TypeScope__Group__0__Impl rule__TypeScope__Group__1 ) | 14152 | // InternalProblem.g:4463:1: ( rule__TypeScope__Group__0__Impl rule__TypeScope__Group__1 ) |
12242 | // InternalProblem.g:3882:2: rule__TypeScope__Group__0__Impl rule__TypeScope__Group__1 | 14153 | // InternalProblem.g:4464:2: rule__TypeScope__Group__0__Impl rule__TypeScope__Group__1 |
12243 | { | 14154 | { |
12244 | pushFollow(FOLLOW_34); | 14155 | pushFollow(FOLLOW_36); |
12245 | rule__TypeScope__Group__0__Impl(); | 14156 | rule__TypeScope__Group__0__Impl(); |
12246 | 14157 | ||
12247 | state._fsp--; | 14158 | state._fsp--; |
@@ -12270,21 +14181,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12270 | 14181 | ||
12271 | 14182 | ||
12272 | // $ANTLR start "rule__TypeScope__Group__0__Impl" | 14183 | // $ANTLR start "rule__TypeScope__Group__0__Impl" |
12273 | // InternalProblem.g:3889:1: rule__TypeScope__Group__0__Impl : ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) ; | 14184 | // InternalProblem.g:4471:1: rule__TypeScope__Group__0__Impl : ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) ; |
12274 | public final void rule__TypeScope__Group__0__Impl() throws RecognitionException { | 14185 | public final void rule__TypeScope__Group__0__Impl() throws RecognitionException { |
12275 | 14186 | ||
12276 | int stackSize = keepStackSize(); | 14187 | int stackSize = keepStackSize(); |
12277 | 14188 | ||
12278 | try { | 14189 | try { |
12279 | // InternalProblem.g:3893:1: ( ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) ) | 14190 | // InternalProblem.g:4475:1: ( ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) ) |
12280 | // InternalProblem.g:3894:1: ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) | 14191 | // InternalProblem.g:4476:1: ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) |
12281 | { | 14192 | { |
12282 | // InternalProblem.g:3894:1: ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) | 14193 | // InternalProblem.g:4476:1: ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) |
12283 | // InternalProblem.g:3895:2: ( rule__TypeScope__TargetTypeAssignment_0 ) | 14194 | // InternalProblem.g:4477:2: ( rule__TypeScope__TargetTypeAssignment_0 ) |
12284 | { | 14195 | { |
12285 | before(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0()); | 14196 | before(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0()); |
12286 | // InternalProblem.g:3896:2: ( rule__TypeScope__TargetTypeAssignment_0 ) | 14197 | // InternalProblem.g:4478:2: ( rule__TypeScope__TargetTypeAssignment_0 ) |
12287 | // InternalProblem.g:3896:3: rule__TypeScope__TargetTypeAssignment_0 | 14198 | // InternalProblem.g:4478:3: rule__TypeScope__TargetTypeAssignment_0 |
12288 | { | 14199 | { |
12289 | pushFollow(FOLLOW_2); | 14200 | pushFollow(FOLLOW_2); |
12290 | rule__TypeScope__TargetTypeAssignment_0(); | 14201 | rule__TypeScope__TargetTypeAssignment_0(); |
@@ -12317,14 +14228,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12317 | 14228 | ||
12318 | 14229 | ||
12319 | // $ANTLR start "rule__TypeScope__Group__1" | 14230 | // $ANTLR start "rule__TypeScope__Group__1" |
12320 | // InternalProblem.g:3904:1: rule__TypeScope__Group__1 : rule__TypeScope__Group__1__Impl rule__TypeScope__Group__2 ; | 14231 | // InternalProblem.g:4486:1: rule__TypeScope__Group__1 : rule__TypeScope__Group__1__Impl rule__TypeScope__Group__2 ; |
12321 | public final void rule__TypeScope__Group__1() throws RecognitionException { | 14232 | public final void rule__TypeScope__Group__1() throws RecognitionException { |
12322 | 14233 | ||
12323 | int stackSize = keepStackSize(); | 14234 | int stackSize = keepStackSize(); |
12324 | 14235 | ||
12325 | try { | 14236 | try { |
12326 | // InternalProblem.g:3908:1: ( rule__TypeScope__Group__1__Impl rule__TypeScope__Group__2 ) | 14237 | // InternalProblem.g:4490:1: ( rule__TypeScope__Group__1__Impl rule__TypeScope__Group__2 ) |
12327 | // InternalProblem.g:3909:2: rule__TypeScope__Group__1__Impl rule__TypeScope__Group__2 | 14238 | // InternalProblem.g:4491:2: rule__TypeScope__Group__1__Impl rule__TypeScope__Group__2 |
12328 | { | 14239 | { |
12329 | pushFollow(FOLLOW_20); | 14240 | pushFollow(FOLLOW_20); |
12330 | rule__TypeScope__Group__1__Impl(); | 14241 | rule__TypeScope__Group__1__Impl(); |
@@ -12355,21 +14266,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12355 | 14266 | ||
12356 | 14267 | ||
12357 | // $ANTLR start "rule__TypeScope__Group__1__Impl" | 14268 | // $ANTLR start "rule__TypeScope__Group__1__Impl" |
12358 | // InternalProblem.g:3916:1: rule__TypeScope__Group__1__Impl : ( ( rule__TypeScope__Alternatives_1 ) ) ; | 14269 | // InternalProblem.g:4498:1: rule__TypeScope__Group__1__Impl : ( ( rule__TypeScope__Alternatives_1 ) ) ; |
12359 | public final void rule__TypeScope__Group__1__Impl() throws RecognitionException { | 14270 | public final void rule__TypeScope__Group__1__Impl() throws RecognitionException { |
12360 | 14271 | ||
12361 | int stackSize = keepStackSize(); | 14272 | int stackSize = keepStackSize(); |
12362 | 14273 | ||
12363 | try { | 14274 | try { |
12364 | // InternalProblem.g:3920:1: ( ( ( rule__TypeScope__Alternatives_1 ) ) ) | 14275 | // InternalProblem.g:4502:1: ( ( ( rule__TypeScope__Alternatives_1 ) ) ) |
12365 | // InternalProblem.g:3921:1: ( ( rule__TypeScope__Alternatives_1 ) ) | 14276 | // InternalProblem.g:4503:1: ( ( rule__TypeScope__Alternatives_1 ) ) |
12366 | { | 14277 | { |
12367 | // InternalProblem.g:3921:1: ( ( rule__TypeScope__Alternatives_1 ) ) | 14278 | // InternalProblem.g:4503:1: ( ( rule__TypeScope__Alternatives_1 ) ) |
12368 | // InternalProblem.g:3922:2: ( rule__TypeScope__Alternatives_1 ) | 14279 | // InternalProblem.g:4504:2: ( rule__TypeScope__Alternatives_1 ) |
12369 | { | 14280 | { |
12370 | before(grammarAccess.getTypeScopeAccess().getAlternatives_1()); | 14281 | before(grammarAccess.getTypeScopeAccess().getAlternatives_1()); |
12371 | // InternalProblem.g:3923:2: ( rule__TypeScope__Alternatives_1 ) | 14282 | // InternalProblem.g:4505:2: ( rule__TypeScope__Alternatives_1 ) |
12372 | // InternalProblem.g:3923:3: rule__TypeScope__Alternatives_1 | 14283 | // InternalProblem.g:4505:3: rule__TypeScope__Alternatives_1 |
12373 | { | 14284 | { |
12374 | pushFollow(FOLLOW_2); | 14285 | pushFollow(FOLLOW_2); |
12375 | rule__TypeScope__Alternatives_1(); | 14286 | rule__TypeScope__Alternatives_1(); |
@@ -12402,14 +14313,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12402 | 14313 | ||
12403 | 14314 | ||
12404 | // $ANTLR start "rule__TypeScope__Group__2" | 14315 | // $ANTLR start "rule__TypeScope__Group__2" |
12405 | // InternalProblem.g:3931:1: rule__TypeScope__Group__2 : rule__TypeScope__Group__2__Impl ; | 14316 | // InternalProblem.g:4513:1: rule__TypeScope__Group__2 : rule__TypeScope__Group__2__Impl ; |
12406 | public final void rule__TypeScope__Group__2() throws RecognitionException { | 14317 | public final void rule__TypeScope__Group__2() throws RecognitionException { |
12407 | 14318 | ||
12408 | int stackSize = keepStackSize(); | 14319 | int stackSize = keepStackSize(); |
12409 | 14320 | ||
12410 | try { | 14321 | try { |
12411 | // InternalProblem.g:3935:1: ( rule__TypeScope__Group__2__Impl ) | 14322 | // InternalProblem.g:4517:1: ( rule__TypeScope__Group__2__Impl ) |
12412 | // InternalProblem.g:3936:2: rule__TypeScope__Group__2__Impl | 14323 | // InternalProblem.g:4518:2: rule__TypeScope__Group__2__Impl |
12413 | { | 14324 | { |
12414 | pushFollow(FOLLOW_2); | 14325 | pushFollow(FOLLOW_2); |
12415 | rule__TypeScope__Group__2__Impl(); | 14326 | rule__TypeScope__Group__2__Impl(); |
@@ -12435,21 +14346,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12435 | 14346 | ||
12436 | 14347 | ||
12437 | // $ANTLR start "rule__TypeScope__Group__2__Impl" | 14348 | // $ANTLR start "rule__TypeScope__Group__2__Impl" |
12438 | // InternalProblem.g:3942:1: rule__TypeScope__Group__2__Impl : ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) ; | 14349 | // InternalProblem.g:4524:1: rule__TypeScope__Group__2__Impl : ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) ; |
12439 | public final void rule__TypeScope__Group__2__Impl() throws RecognitionException { | 14350 | public final void rule__TypeScope__Group__2__Impl() throws RecognitionException { |
12440 | 14351 | ||
12441 | int stackSize = keepStackSize(); | 14352 | int stackSize = keepStackSize(); |
12442 | 14353 | ||
12443 | try { | 14354 | try { |
12444 | // InternalProblem.g:3946:1: ( ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) ) | 14355 | // InternalProblem.g:4528:1: ( ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) ) |
12445 | // InternalProblem.g:3947:1: ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) | 14356 | // InternalProblem.g:4529:1: ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) |
12446 | { | 14357 | { |
12447 | // InternalProblem.g:3947:1: ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) | 14358 | // InternalProblem.g:4529:1: ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) |
12448 | // InternalProblem.g:3948:2: ( rule__TypeScope__MultiplicityAssignment_2 ) | 14359 | // InternalProblem.g:4530:2: ( rule__TypeScope__MultiplicityAssignment_2 ) |
12449 | { | 14360 | { |
12450 | before(grammarAccess.getTypeScopeAccess().getMultiplicityAssignment_2()); | 14361 | before(grammarAccess.getTypeScopeAccess().getMultiplicityAssignment_2()); |
12451 | // InternalProblem.g:3949:2: ( rule__TypeScope__MultiplicityAssignment_2 ) | 14362 | // InternalProblem.g:4531:2: ( rule__TypeScope__MultiplicityAssignment_2 ) |
12452 | // InternalProblem.g:3949:3: rule__TypeScope__MultiplicityAssignment_2 | 14363 | // InternalProblem.g:4531:3: rule__TypeScope__MultiplicityAssignment_2 |
12453 | { | 14364 | { |
12454 | pushFollow(FOLLOW_2); | 14365 | pushFollow(FOLLOW_2); |
12455 | rule__TypeScope__MultiplicityAssignment_2(); | 14366 | rule__TypeScope__MultiplicityAssignment_2(); |
@@ -12482,16 +14393,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12482 | 14393 | ||
12483 | 14394 | ||
12484 | // $ANTLR start "rule__RangeMultiplicity__Group__0" | 14395 | // $ANTLR start "rule__RangeMultiplicity__Group__0" |
12485 | // InternalProblem.g:3958:1: rule__RangeMultiplicity__Group__0 : rule__RangeMultiplicity__Group__0__Impl rule__RangeMultiplicity__Group__1 ; | 14396 | // InternalProblem.g:4540:1: rule__RangeMultiplicity__Group__0 : rule__RangeMultiplicity__Group__0__Impl rule__RangeMultiplicity__Group__1 ; |
12486 | public final void rule__RangeMultiplicity__Group__0() throws RecognitionException { | 14397 | public final void rule__RangeMultiplicity__Group__0() throws RecognitionException { |
12487 | 14398 | ||
12488 | int stackSize = keepStackSize(); | 14399 | int stackSize = keepStackSize(); |
12489 | 14400 | ||
12490 | try { | 14401 | try { |
12491 | // InternalProblem.g:3962:1: ( rule__RangeMultiplicity__Group__0__Impl rule__RangeMultiplicity__Group__1 ) | 14402 | // InternalProblem.g:4544:1: ( rule__RangeMultiplicity__Group__0__Impl rule__RangeMultiplicity__Group__1 ) |
12492 | // InternalProblem.g:3963:2: rule__RangeMultiplicity__Group__0__Impl rule__RangeMultiplicity__Group__1 | 14403 | // InternalProblem.g:4545:2: rule__RangeMultiplicity__Group__0__Impl rule__RangeMultiplicity__Group__1 |
12493 | { | 14404 | { |
12494 | pushFollow(FOLLOW_35); | 14405 | pushFollow(FOLLOW_37); |
12495 | rule__RangeMultiplicity__Group__0__Impl(); | 14406 | rule__RangeMultiplicity__Group__0__Impl(); |
12496 | 14407 | ||
12497 | state._fsp--; | 14408 | state._fsp--; |
@@ -12520,21 +14431,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12520 | 14431 | ||
12521 | 14432 | ||
12522 | // $ANTLR start "rule__RangeMultiplicity__Group__0__Impl" | 14433 | // $ANTLR start "rule__RangeMultiplicity__Group__0__Impl" |
12523 | // InternalProblem.g:3970:1: rule__RangeMultiplicity__Group__0__Impl : ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) ; | 14434 | // InternalProblem.g:4552:1: rule__RangeMultiplicity__Group__0__Impl : ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) ; |
12524 | public final void rule__RangeMultiplicity__Group__0__Impl() throws RecognitionException { | 14435 | public final void rule__RangeMultiplicity__Group__0__Impl() throws RecognitionException { |
12525 | 14436 | ||
12526 | int stackSize = keepStackSize(); | 14437 | int stackSize = keepStackSize(); |
12527 | 14438 | ||
12528 | try { | 14439 | try { |
12529 | // InternalProblem.g:3974:1: ( ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) ) | 14440 | // InternalProblem.g:4556:1: ( ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) ) |
12530 | // InternalProblem.g:3975:1: ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) | 14441 | // InternalProblem.g:4557:1: ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) |
12531 | { | 14442 | { |
12532 | // InternalProblem.g:3975:1: ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) | 14443 | // InternalProblem.g:4557:1: ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) |
12533 | // InternalProblem.g:3976:2: ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) | 14444 | // InternalProblem.g:4558:2: ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) |
12534 | { | 14445 | { |
12535 | before(grammarAccess.getRangeMultiplicityAccess().getLowerBoundAssignment_0()); | 14446 | before(grammarAccess.getRangeMultiplicityAccess().getLowerBoundAssignment_0()); |
12536 | // InternalProblem.g:3977:2: ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) | 14447 | // InternalProblem.g:4559:2: ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) |
12537 | // InternalProblem.g:3977:3: rule__RangeMultiplicity__LowerBoundAssignment_0 | 14448 | // InternalProblem.g:4559:3: rule__RangeMultiplicity__LowerBoundAssignment_0 |
12538 | { | 14449 | { |
12539 | pushFollow(FOLLOW_2); | 14450 | pushFollow(FOLLOW_2); |
12540 | rule__RangeMultiplicity__LowerBoundAssignment_0(); | 14451 | rule__RangeMultiplicity__LowerBoundAssignment_0(); |
@@ -12567,16 +14478,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12567 | 14478 | ||
12568 | 14479 | ||
12569 | // $ANTLR start "rule__RangeMultiplicity__Group__1" | 14480 | // $ANTLR start "rule__RangeMultiplicity__Group__1" |
12570 | // InternalProblem.g:3985:1: rule__RangeMultiplicity__Group__1 : rule__RangeMultiplicity__Group__1__Impl rule__RangeMultiplicity__Group__2 ; | 14481 | // InternalProblem.g:4567:1: rule__RangeMultiplicity__Group__1 : rule__RangeMultiplicity__Group__1__Impl rule__RangeMultiplicity__Group__2 ; |
12571 | public final void rule__RangeMultiplicity__Group__1() throws RecognitionException { | 14482 | public final void rule__RangeMultiplicity__Group__1() throws RecognitionException { |
12572 | 14483 | ||
12573 | int stackSize = keepStackSize(); | 14484 | int stackSize = keepStackSize(); |
12574 | 14485 | ||
12575 | try { | 14486 | try { |
12576 | // InternalProblem.g:3989:1: ( rule__RangeMultiplicity__Group__1__Impl rule__RangeMultiplicity__Group__2 ) | 14487 | // InternalProblem.g:4571:1: ( rule__RangeMultiplicity__Group__1__Impl rule__RangeMultiplicity__Group__2 ) |
12577 | // InternalProblem.g:3990:2: rule__RangeMultiplicity__Group__1__Impl rule__RangeMultiplicity__Group__2 | 14488 | // InternalProblem.g:4572:2: rule__RangeMultiplicity__Group__1__Impl rule__RangeMultiplicity__Group__2 |
12578 | { | 14489 | { |
12579 | pushFollow(FOLLOW_36); | 14490 | pushFollow(FOLLOW_38); |
12580 | rule__RangeMultiplicity__Group__1__Impl(); | 14491 | rule__RangeMultiplicity__Group__1__Impl(); |
12581 | 14492 | ||
12582 | state._fsp--; | 14493 | state._fsp--; |
@@ -12605,20 +14516,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12605 | 14516 | ||
12606 | 14517 | ||
12607 | // $ANTLR start "rule__RangeMultiplicity__Group__1__Impl" | 14518 | // $ANTLR start "rule__RangeMultiplicity__Group__1__Impl" |
12608 | // InternalProblem.g:3997:1: rule__RangeMultiplicity__Group__1__Impl : ( '..' ) ; | 14519 | // InternalProblem.g:4579:1: rule__RangeMultiplicity__Group__1__Impl : ( '..' ) ; |
12609 | public final void rule__RangeMultiplicity__Group__1__Impl() throws RecognitionException { | 14520 | public final void rule__RangeMultiplicity__Group__1__Impl() throws RecognitionException { |
12610 | 14521 | ||
12611 | int stackSize = keepStackSize(); | 14522 | int stackSize = keepStackSize(); |
12612 | 14523 | ||
12613 | try { | 14524 | try { |
12614 | // InternalProblem.g:4001:1: ( ( '..' ) ) | 14525 | // InternalProblem.g:4583:1: ( ( '..' ) ) |
12615 | // InternalProblem.g:4002:1: ( '..' ) | 14526 | // InternalProblem.g:4584:1: ( '..' ) |
12616 | { | 14527 | { |
12617 | // InternalProblem.g:4002:1: ( '..' ) | 14528 | // InternalProblem.g:4584:1: ( '..' ) |
12618 | // InternalProblem.g:4003:2: '..' | 14529 | // InternalProblem.g:4585:2: '..' |
12619 | { | 14530 | { |
12620 | before(grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); | 14531 | before(grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); |
12621 | match(input,38,FOLLOW_2); | 14532 | match(input,42,FOLLOW_2); |
12622 | after(grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); | 14533 | after(grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); |
12623 | 14534 | ||
12624 | } | 14535 | } |
@@ -12642,14 +14553,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12642 | 14553 | ||
12643 | 14554 | ||
12644 | // $ANTLR start "rule__RangeMultiplicity__Group__2" | 14555 | // $ANTLR start "rule__RangeMultiplicity__Group__2" |
12645 | // InternalProblem.g:4012:1: rule__RangeMultiplicity__Group__2 : rule__RangeMultiplicity__Group__2__Impl ; | 14556 | // InternalProblem.g:4594:1: rule__RangeMultiplicity__Group__2 : rule__RangeMultiplicity__Group__2__Impl ; |
12646 | public final void rule__RangeMultiplicity__Group__2() throws RecognitionException { | 14557 | public final void rule__RangeMultiplicity__Group__2() throws RecognitionException { |
12647 | 14558 | ||
12648 | int stackSize = keepStackSize(); | 14559 | int stackSize = keepStackSize(); |
12649 | 14560 | ||
12650 | try { | 14561 | try { |
12651 | // InternalProblem.g:4016:1: ( rule__RangeMultiplicity__Group__2__Impl ) | 14562 | // InternalProblem.g:4598:1: ( rule__RangeMultiplicity__Group__2__Impl ) |
12652 | // InternalProblem.g:4017:2: rule__RangeMultiplicity__Group__2__Impl | 14563 | // InternalProblem.g:4599:2: rule__RangeMultiplicity__Group__2__Impl |
12653 | { | 14564 | { |
12654 | pushFollow(FOLLOW_2); | 14565 | pushFollow(FOLLOW_2); |
12655 | rule__RangeMultiplicity__Group__2__Impl(); | 14566 | rule__RangeMultiplicity__Group__2__Impl(); |
@@ -12675,21 +14586,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12675 | 14586 | ||
12676 | 14587 | ||
12677 | // $ANTLR start "rule__RangeMultiplicity__Group__2__Impl" | 14588 | // $ANTLR start "rule__RangeMultiplicity__Group__2__Impl" |
12678 | // InternalProblem.g:4023:1: rule__RangeMultiplicity__Group__2__Impl : ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) ; | 14589 | // InternalProblem.g:4605:1: rule__RangeMultiplicity__Group__2__Impl : ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) ; |
12679 | public final void rule__RangeMultiplicity__Group__2__Impl() throws RecognitionException { | 14590 | public final void rule__RangeMultiplicity__Group__2__Impl() throws RecognitionException { |
12680 | 14591 | ||
12681 | int stackSize = keepStackSize(); | 14592 | int stackSize = keepStackSize(); |
12682 | 14593 | ||
12683 | try { | 14594 | try { |
12684 | // InternalProblem.g:4027:1: ( ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) ) | 14595 | // InternalProblem.g:4609:1: ( ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) ) |
12685 | // InternalProblem.g:4028:1: ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) | 14596 | // InternalProblem.g:4610:1: ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) |
12686 | { | 14597 | { |
12687 | // InternalProblem.g:4028:1: ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) | 14598 | // InternalProblem.g:4610:1: ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) |
12688 | // InternalProblem.g:4029:2: ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) | 14599 | // InternalProblem.g:4611:2: ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) |
12689 | { | 14600 | { |
12690 | before(grammarAccess.getRangeMultiplicityAccess().getUpperBoundAssignment_2()); | 14601 | before(grammarAccess.getRangeMultiplicityAccess().getUpperBoundAssignment_2()); |
12691 | // InternalProblem.g:4030:2: ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) | 14602 | // InternalProblem.g:4612:2: ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) |
12692 | // InternalProblem.g:4030:3: rule__RangeMultiplicity__UpperBoundAssignment_2 | 14603 | // InternalProblem.g:4612:3: rule__RangeMultiplicity__UpperBoundAssignment_2 |
12693 | { | 14604 | { |
12694 | pushFollow(FOLLOW_2); | 14605 | pushFollow(FOLLOW_2); |
12695 | rule__RangeMultiplicity__UpperBoundAssignment_2(); | 14606 | rule__RangeMultiplicity__UpperBoundAssignment_2(); |
@@ -12722,16 +14633,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12722 | 14633 | ||
12723 | 14634 | ||
12724 | // $ANTLR start "rule__QualifiedName__Group_1__0" | 14635 | // $ANTLR start "rule__QualifiedName__Group_1__0" |
12725 | // InternalProblem.g:4039:1: rule__QualifiedName__Group_1__0 : rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ; | 14636 | // InternalProblem.g:4621:1: rule__QualifiedName__Group_1__0 : rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ; |
12726 | public final void rule__QualifiedName__Group_1__0() throws RecognitionException { | 14637 | public final void rule__QualifiedName__Group_1__0() throws RecognitionException { |
12727 | 14638 | ||
12728 | int stackSize = keepStackSize(); | 14639 | int stackSize = keepStackSize(); |
12729 | 14640 | ||
12730 | try { | 14641 | try { |
12731 | // InternalProblem.g:4043:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ) | 14642 | // InternalProblem.g:4625:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ) |
12732 | // InternalProblem.g:4044:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 | 14643 | // InternalProblem.g:4626:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 |
12733 | { | 14644 | { |
12734 | pushFollow(FOLLOW_37); | 14645 | pushFollow(FOLLOW_39); |
12735 | rule__QualifiedName__Group_1__0__Impl(); | 14646 | rule__QualifiedName__Group_1__0__Impl(); |
12736 | 14647 | ||
12737 | state._fsp--; | 14648 | state._fsp--; |
@@ -12760,17 +14671,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12760 | 14671 | ||
12761 | 14672 | ||
12762 | // $ANTLR start "rule__QualifiedName__Group_1__0__Impl" | 14673 | // $ANTLR start "rule__QualifiedName__Group_1__0__Impl" |
12763 | // InternalProblem.g:4051:1: rule__QualifiedName__Group_1__0__Impl : ( ruleIdentifier ) ; | 14674 | // InternalProblem.g:4633:1: rule__QualifiedName__Group_1__0__Impl : ( ruleIdentifier ) ; |
12764 | public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException { | 14675 | public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException { |
12765 | 14676 | ||
12766 | int stackSize = keepStackSize(); | 14677 | int stackSize = keepStackSize(); |
12767 | 14678 | ||
12768 | try { | 14679 | try { |
12769 | // InternalProblem.g:4055:1: ( ( ruleIdentifier ) ) | 14680 | // InternalProblem.g:4637:1: ( ( ruleIdentifier ) ) |
12770 | // InternalProblem.g:4056:1: ( ruleIdentifier ) | 14681 | // InternalProblem.g:4638:1: ( ruleIdentifier ) |
12771 | { | 14682 | { |
12772 | // InternalProblem.g:4056:1: ( ruleIdentifier ) | 14683 | // InternalProblem.g:4638:1: ( ruleIdentifier ) |
12773 | // InternalProblem.g:4057:2: ruleIdentifier | 14684 | // InternalProblem.g:4639:2: ruleIdentifier |
12774 | { | 14685 | { |
12775 | before(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); | 14686 | before(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); |
12776 | pushFollow(FOLLOW_2); | 14687 | pushFollow(FOLLOW_2); |
@@ -12801,16 +14712,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12801 | 14712 | ||
12802 | 14713 | ||
12803 | // $ANTLR start "rule__QualifiedName__Group_1__1" | 14714 | // $ANTLR start "rule__QualifiedName__Group_1__1" |
12804 | // InternalProblem.g:4066:1: rule__QualifiedName__Group_1__1 : rule__QualifiedName__Group_1__1__Impl rule__QualifiedName__Group_1__2 ; | 14715 | // InternalProblem.g:4648:1: rule__QualifiedName__Group_1__1 : rule__QualifiedName__Group_1__1__Impl rule__QualifiedName__Group_1__2 ; |
12805 | public final void rule__QualifiedName__Group_1__1() throws RecognitionException { | 14716 | public final void rule__QualifiedName__Group_1__1() throws RecognitionException { |
12806 | 14717 | ||
12807 | int stackSize = keepStackSize(); | 14718 | int stackSize = keepStackSize(); |
12808 | 14719 | ||
12809 | try { | 14720 | try { |
12810 | // InternalProblem.g:4070:1: ( rule__QualifiedName__Group_1__1__Impl rule__QualifiedName__Group_1__2 ) | 14721 | // InternalProblem.g:4652:1: ( rule__QualifiedName__Group_1__1__Impl rule__QualifiedName__Group_1__2 ) |
12811 | // InternalProblem.g:4071:2: rule__QualifiedName__Group_1__1__Impl rule__QualifiedName__Group_1__2 | 14722 | // InternalProblem.g:4653:2: rule__QualifiedName__Group_1__1__Impl rule__QualifiedName__Group_1__2 |
12812 | { | 14723 | { |
12813 | pushFollow(FOLLOW_37); | 14724 | pushFollow(FOLLOW_39); |
12814 | rule__QualifiedName__Group_1__1__Impl(); | 14725 | rule__QualifiedName__Group_1__1__Impl(); |
12815 | 14726 | ||
12816 | state._fsp--; | 14727 | state._fsp--; |
@@ -12839,41 +14750,41 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12839 | 14750 | ||
12840 | 14751 | ||
12841 | // $ANTLR start "rule__QualifiedName__Group_1__1__Impl" | 14752 | // $ANTLR start "rule__QualifiedName__Group_1__1__Impl" |
12842 | // InternalProblem.g:4078:1: rule__QualifiedName__Group_1__1__Impl : ( ( rule__QualifiedName__Group_1_1__0 )* ) ; | 14753 | // InternalProblem.g:4660:1: rule__QualifiedName__Group_1__1__Impl : ( ( rule__QualifiedName__Group_1_1__0 )* ) ; |
12843 | public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException { | 14754 | public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException { |
12844 | 14755 | ||
12845 | int stackSize = keepStackSize(); | 14756 | int stackSize = keepStackSize(); |
12846 | 14757 | ||
12847 | try { | 14758 | try { |
12848 | // InternalProblem.g:4082:1: ( ( ( rule__QualifiedName__Group_1_1__0 )* ) ) | 14759 | // InternalProblem.g:4664:1: ( ( ( rule__QualifiedName__Group_1_1__0 )* ) ) |
12849 | // InternalProblem.g:4083:1: ( ( rule__QualifiedName__Group_1_1__0 )* ) | 14760 | // InternalProblem.g:4665:1: ( ( rule__QualifiedName__Group_1_1__0 )* ) |
12850 | { | 14761 | { |
12851 | // InternalProblem.g:4083:1: ( ( rule__QualifiedName__Group_1_1__0 )* ) | 14762 | // InternalProblem.g:4665:1: ( ( rule__QualifiedName__Group_1_1__0 )* ) |
12852 | // InternalProblem.g:4084:2: ( rule__QualifiedName__Group_1_1__0 )* | 14763 | // InternalProblem.g:4666:2: ( rule__QualifiedName__Group_1_1__0 )* |
12853 | { | 14764 | { |
12854 | before(grammarAccess.getQualifiedNameAccess().getGroup_1_1()); | 14765 | before(grammarAccess.getQualifiedNameAccess().getGroup_1_1()); |
12855 | // InternalProblem.g:4085:2: ( rule__QualifiedName__Group_1_1__0 )* | 14766 | // InternalProblem.g:4667:2: ( rule__QualifiedName__Group_1_1__0 )* |
12856 | loop47: | 14767 | loop53: |
12857 | do { | 14768 | do { |
12858 | int alt47=2; | 14769 | int alt53=2; |
12859 | int LA47_0 = input.LA(1); | 14770 | int LA53_0 = input.LA(1); |
12860 | 14771 | ||
12861 | if ( (LA47_0==39) ) { | 14772 | if ( (LA53_0==43) ) { |
12862 | int LA47_1 = input.LA(2); | 14773 | int LA53_1 = input.LA(2); |
12863 | 14774 | ||
12864 | if ( (LA47_1==RULE_ID||(LA47_1>=19 && LA47_1<=20)) ) { | 14775 | if ( (LA53_1==RULE_ID||(LA53_1>=19 && LA53_1<=22)) ) { |
12865 | alt47=1; | 14776 | alt53=1; |
12866 | } | 14777 | } |
12867 | 14778 | ||
12868 | 14779 | ||
12869 | } | 14780 | } |
12870 | 14781 | ||
12871 | 14782 | ||
12872 | switch (alt47) { | 14783 | switch (alt53) { |
12873 | case 1 : | 14784 | case 1 : |
12874 | // InternalProblem.g:4085:3: rule__QualifiedName__Group_1_1__0 | 14785 | // InternalProblem.g:4667:3: rule__QualifiedName__Group_1_1__0 |
12875 | { | 14786 | { |
12876 | pushFollow(FOLLOW_38); | 14787 | pushFollow(FOLLOW_40); |
12877 | rule__QualifiedName__Group_1_1__0(); | 14788 | rule__QualifiedName__Group_1_1__0(); |
12878 | 14789 | ||
12879 | state._fsp--; | 14790 | state._fsp--; |
@@ -12883,7 +14794,7 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12883 | break; | 14794 | break; |
12884 | 14795 | ||
12885 | default : | 14796 | default : |
12886 | break loop47; | 14797 | break loop53; |
12887 | } | 14798 | } |
12888 | } while (true); | 14799 | } while (true); |
12889 | 14800 | ||
@@ -12910,14 +14821,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12910 | 14821 | ||
12911 | 14822 | ||
12912 | // $ANTLR start "rule__QualifiedName__Group_1__2" | 14823 | // $ANTLR start "rule__QualifiedName__Group_1__2" |
12913 | // InternalProblem.g:4093:1: rule__QualifiedName__Group_1__2 : rule__QualifiedName__Group_1__2__Impl ; | 14824 | // InternalProblem.g:4675:1: rule__QualifiedName__Group_1__2 : rule__QualifiedName__Group_1__2__Impl ; |
12914 | public final void rule__QualifiedName__Group_1__2() throws RecognitionException { | 14825 | public final void rule__QualifiedName__Group_1__2() throws RecognitionException { |
12915 | 14826 | ||
12916 | int stackSize = keepStackSize(); | 14827 | int stackSize = keepStackSize(); |
12917 | 14828 | ||
12918 | try { | 14829 | try { |
12919 | // InternalProblem.g:4097:1: ( rule__QualifiedName__Group_1__2__Impl ) | 14830 | // InternalProblem.g:4679:1: ( rule__QualifiedName__Group_1__2__Impl ) |
12920 | // InternalProblem.g:4098:2: rule__QualifiedName__Group_1__2__Impl | 14831 | // InternalProblem.g:4680:2: rule__QualifiedName__Group_1__2__Impl |
12921 | { | 14832 | { |
12922 | pushFollow(FOLLOW_2); | 14833 | pushFollow(FOLLOW_2); |
12923 | rule__QualifiedName__Group_1__2__Impl(); | 14834 | rule__QualifiedName__Group_1__2__Impl(); |
@@ -12943,29 +14854,29 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
12943 | 14854 | ||
12944 | 14855 | ||
12945 | // $ANTLR start "rule__QualifiedName__Group_1__2__Impl" | 14856 | // $ANTLR start "rule__QualifiedName__Group_1__2__Impl" |
12946 | // InternalProblem.g:4104:1: rule__QualifiedName__Group_1__2__Impl : ( ( rule__QualifiedName__Group_1_2__0 )? ) ; | 14857 | // InternalProblem.g:4686:1: rule__QualifiedName__Group_1__2__Impl : ( ( rule__QualifiedName__Group_1_2__0 )? ) ; |
12947 | public final void rule__QualifiedName__Group_1__2__Impl() throws RecognitionException { | 14858 | public final void rule__QualifiedName__Group_1__2__Impl() throws RecognitionException { |
12948 | 14859 | ||
12949 | int stackSize = keepStackSize(); | 14860 | int stackSize = keepStackSize(); |
12950 | 14861 | ||
12951 | try { | 14862 | try { |
12952 | // InternalProblem.g:4108:1: ( ( ( rule__QualifiedName__Group_1_2__0 )? ) ) | 14863 | // InternalProblem.g:4690:1: ( ( ( rule__QualifiedName__Group_1_2__0 )? ) ) |
12953 | // InternalProblem.g:4109:1: ( ( rule__QualifiedName__Group_1_2__0 )? ) | 14864 | // InternalProblem.g:4691:1: ( ( rule__QualifiedName__Group_1_2__0 )? ) |
12954 | { | 14865 | { |
12955 | // InternalProblem.g:4109:1: ( ( rule__QualifiedName__Group_1_2__0 )? ) | 14866 | // InternalProblem.g:4691:1: ( ( rule__QualifiedName__Group_1_2__0 )? ) |
12956 | // InternalProblem.g:4110:2: ( rule__QualifiedName__Group_1_2__0 )? | 14867 | // InternalProblem.g:4692:2: ( rule__QualifiedName__Group_1_2__0 )? |
12957 | { | 14868 | { |
12958 | before(grammarAccess.getQualifiedNameAccess().getGroup_1_2()); | 14869 | before(grammarAccess.getQualifiedNameAccess().getGroup_1_2()); |
12959 | // InternalProblem.g:4111:2: ( rule__QualifiedName__Group_1_2__0 )? | 14870 | // InternalProblem.g:4693:2: ( rule__QualifiedName__Group_1_2__0 )? |
12960 | int alt48=2; | 14871 | int alt54=2; |
12961 | int LA48_0 = input.LA(1); | 14872 | int LA54_0 = input.LA(1); |
12962 | 14873 | ||
12963 | if ( (LA48_0==39) ) { | 14874 | if ( (LA54_0==43) ) { |
12964 | alt48=1; | 14875 | alt54=1; |
12965 | } | 14876 | } |
12966 | switch (alt48) { | 14877 | switch (alt54) { |
12967 | case 1 : | 14878 | case 1 : |
12968 | // InternalProblem.g:4111:3: rule__QualifiedName__Group_1_2__0 | 14879 | // InternalProblem.g:4693:3: rule__QualifiedName__Group_1_2__0 |
12969 | { | 14880 | { |
12970 | pushFollow(FOLLOW_2); | 14881 | pushFollow(FOLLOW_2); |
12971 | rule__QualifiedName__Group_1_2__0(); | 14882 | rule__QualifiedName__Group_1_2__0(); |
@@ -13001,14 +14912,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13001 | 14912 | ||
13002 | 14913 | ||
13003 | // $ANTLR start "rule__QualifiedName__Group_1_1__0" | 14914 | // $ANTLR start "rule__QualifiedName__Group_1_1__0" |
13004 | // InternalProblem.g:4120:1: rule__QualifiedName__Group_1_1__0 : rule__QualifiedName__Group_1_1__0__Impl rule__QualifiedName__Group_1_1__1 ; | 14915 | // InternalProblem.g:4702:1: rule__QualifiedName__Group_1_1__0 : rule__QualifiedName__Group_1_1__0__Impl rule__QualifiedName__Group_1_1__1 ; |
13005 | public final void rule__QualifiedName__Group_1_1__0() throws RecognitionException { | 14916 | public final void rule__QualifiedName__Group_1_1__0() throws RecognitionException { |
13006 | 14917 | ||
13007 | int stackSize = keepStackSize(); | 14918 | int stackSize = keepStackSize(); |
13008 | 14919 | ||
13009 | try { | 14920 | try { |
13010 | // InternalProblem.g:4124:1: ( rule__QualifiedName__Group_1_1__0__Impl rule__QualifiedName__Group_1_1__1 ) | 14921 | // InternalProblem.g:4706:1: ( rule__QualifiedName__Group_1_1__0__Impl rule__QualifiedName__Group_1_1__1 ) |
13011 | // InternalProblem.g:4125:2: rule__QualifiedName__Group_1_1__0__Impl rule__QualifiedName__Group_1_1__1 | 14922 | // InternalProblem.g:4707:2: rule__QualifiedName__Group_1_1__0__Impl rule__QualifiedName__Group_1_1__1 |
13012 | { | 14923 | { |
13013 | pushFollow(FOLLOW_5); | 14924 | pushFollow(FOLLOW_5); |
13014 | rule__QualifiedName__Group_1_1__0__Impl(); | 14925 | rule__QualifiedName__Group_1_1__0__Impl(); |
@@ -13039,20 +14950,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13039 | 14950 | ||
13040 | 14951 | ||
13041 | // $ANTLR start "rule__QualifiedName__Group_1_1__0__Impl" | 14952 | // $ANTLR start "rule__QualifiedName__Group_1_1__0__Impl" |
13042 | // InternalProblem.g:4132:1: rule__QualifiedName__Group_1_1__0__Impl : ( '::' ) ; | 14953 | // InternalProblem.g:4714:1: rule__QualifiedName__Group_1_1__0__Impl : ( '::' ) ; |
13043 | public final void rule__QualifiedName__Group_1_1__0__Impl() throws RecognitionException { | 14954 | public final void rule__QualifiedName__Group_1_1__0__Impl() throws RecognitionException { |
13044 | 14955 | ||
13045 | int stackSize = keepStackSize(); | 14956 | int stackSize = keepStackSize(); |
13046 | 14957 | ||
13047 | try { | 14958 | try { |
13048 | // InternalProblem.g:4136:1: ( ( '::' ) ) | 14959 | // InternalProblem.g:4718:1: ( ( '::' ) ) |
13049 | // InternalProblem.g:4137:1: ( '::' ) | 14960 | // InternalProblem.g:4719:1: ( '::' ) |
13050 | { | 14961 | { |
13051 | // InternalProblem.g:4137:1: ( '::' ) | 14962 | // InternalProblem.g:4719:1: ( '::' ) |
13052 | // InternalProblem.g:4138:2: '::' | 14963 | // InternalProblem.g:4720:2: '::' |
13053 | { | 14964 | { |
13054 | before(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_1_0()); | 14965 | before(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_1_0()); |
13055 | match(input,39,FOLLOW_2); | 14966 | match(input,43,FOLLOW_2); |
13056 | after(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_1_0()); | 14967 | after(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_1_0()); |
13057 | 14968 | ||
13058 | } | 14969 | } |
@@ -13076,14 +14987,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13076 | 14987 | ||
13077 | 14988 | ||
13078 | // $ANTLR start "rule__QualifiedName__Group_1_1__1" | 14989 | // $ANTLR start "rule__QualifiedName__Group_1_1__1" |
13079 | // InternalProblem.g:4147:1: rule__QualifiedName__Group_1_1__1 : rule__QualifiedName__Group_1_1__1__Impl ; | 14990 | // InternalProblem.g:4729:1: rule__QualifiedName__Group_1_1__1 : rule__QualifiedName__Group_1_1__1__Impl ; |
13080 | public final void rule__QualifiedName__Group_1_1__1() throws RecognitionException { | 14991 | public final void rule__QualifiedName__Group_1_1__1() throws RecognitionException { |
13081 | 14992 | ||
13082 | int stackSize = keepStackSize(); | 14993 | int stackSize = keepStackSize(); |
13083 | 14994 | ||
13084 | try { | 14995 | try { |
13085 | // InternalProblem.g:4151:1: ( rule__QualifiedName__Group_1_1__1__Impl ) | 14996 | // InternalProblem.g:4733:1: ( rule__QualifiedName__Group_1_1__1__Impl ) |
13086 | // InternalProblem.g:4152:2: rule__QualifiedName__Group_1_1__1__Impl | 14997 | // InternalProblem.g:4734:2: rule__QualifiedName__Group_1_1__1__Impl |
13087 | { | 14998 | { |
13088 | pushFollow(FOLLOW_2); | 14999 | pushFollow(FOLLOW_2); |
13089 | rule__QualifiedName__Group_1_1__1__Impl(); | 15000 | rule__QualifiedName__Group_1_1__1__Impl(); |
@@ -13109,17 +15020,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13109 | 15020 | ||
13110 | 15021 | ||
13111 | // $ANTLR start "rule__QualifiedName__Group_1_1__1__Impl" | 15022 | // $ANTLR start "rule__QualifiedName__Group_1_1__1__Impl" |
13112 | // InternalProblem.g:4158:1: rule__QualifiedName__Group_1_1__1__Impl : ( ruleIdentifier ) ; | 15023 | // InternalProblem.g:4740:1: rule__QualifiedName__Group_1_1__1__Impl : ( ruleIdentifier ) ; |
13113 | public final void rule__QualifiedName__Group_1_1__1__Impl() throws RecognitionException { | 15024 | public final void rule__QualifiedName__Group_1_1__1__Impl() throws RecognitionException { |
13114 | 15025 | ||
13115 | int stackSize = keepStackSize(); | 15026 | int stackSize = keepStackSize(); |
13116 | 15027 | ||
13117 | try { | 15028 | try { |
13118 | // InternalProblem.g:4162:1: ( ( ruleIdentifier ) ) | 15029 | // InternalProblem.g:4744:1: ( ( ruleIdentifier ) ) |
13119 | // InternalProblem.g:4163:1: ( ruleIdentifier ) | 15030 | // InternalProblem.g:4745:1: ( ruleIdentifier ) |
13120 | { | 15031 | { |
13121 | // InternalProblem.g:4163:1: ( ruleIdentifier ) | 15032 | // InternalProblem.g:4745:1: ( ruleIdentifier ) |
13122 | // InternalProblem.g:4164:2: ruleIdentifier | 15033 | // InternalProblem.g:4746:2: ruleIdentifier |
13123 | { | 15034 | { |
13124 | before(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); | 15035 | before(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); |
13125 | pushFollow(FOLLOW_2); | 15036 | pushFollow(FOLLOW_2); |
@@ -13150,16 +15061,16 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13150 | 15061 | ||
13151 | 15062 | ||
13152 | // $ANTLR start "rule__QualifiedName__Group_1_2__0" | 15063 | // $ANTLR start "rule__QualifiedName__Group_1_2__0" |
13153 | // InternalProblem.g:4174:1: rule__QualifiedName__Group_1_2__0 : rule__QualifiedName__Group_1_2__0__Impl rule__QualifiedName__Group_1_2__1 ; | 15064 | // InternalProblem.g:4756:1: rule__QualifiedName__Group_1_2__0 : rule__QualifiedName__Group_1_2__0__Impl rule__QualifiedName__Group_1_2__1 ; |
13154 | public final void rule__QualifiedName__Group_1_2__0() throws RecognitionException { | 15065 | public final void rule__QualifiedName__Group_1_2__0() throws RecognitionException { |
13155 | 15066 | ||
13156 | int stackSize = keepStackSize(); | 15067 | int stackSize = keepStackSize(); |
13157 | 15068 | ||
13158 | try { | 15069 | try { |
13159 | // InternalProblem.g:4178:1: ( rule__QualifiedName__Group_1_2__0__Impl rule__QualifiedName__Group_1_2__1 ) | 15070 | // InternalProblem.g:4760:1: ( rule__QualifiedName__Group_1_2__0__Impl rule__QualifiedName__Group_1_2__1 ) |
13160 | // InternalProblem.g:4179:2: rule__QualifiedName__Group_1_2__0__Impl rule__QualifiedName__Group_1_2__1 | 15071 | // InternalProblem.g:4761:2: rule__QualifiedName__Group_1_2__0__Impl rule__QualifiedName__Group_1_2__1 |
13161 | { | 15072 | { |
13162 | pushFollow(FOLLOW_39); | 15073 | pushFollow(FOLLOW_41); |
13163 | rule__QualifiedName__Group_1_2__0__Impl(); | 15074 | rule__QualifiedName__Group_1_2__0__Impl(); |
13164 | 15075 | ||
13165 | state._fsp--; | 15076 | state._fsp--; |
@@ -13188,20 +15099,20 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13188 | 15099 | ||
13189 | 15100 | ||
13190 | // $ANTLR start "rule__QualifiedName__Group_1_2__0__Impl" | 15101 | // $ANTLR start "rule__QualifiedName__Group_1_2__0__Impl" |
13191 | // InternalProblem.g:4186:1: rule__QualifiedName__Group_1_2__0__Impl : ( '::' ) ; | 15102 | // InternalProblem.g:4768:1: rule__QualifiedName__Group_1_2__0__Impl : ( '::' ) ; |
13192 | public final void rule__QualifiedName__Group_1_2__0__Impl() throws RecognitionException { | 15103 | public final void rule__QualifiedName__Group_1_2__0__Impl() throws RecognitionException { |
13193 | 15104 | ||
13194 | int stackSize = keepStackSize(); | 15105 | int stackSize = keepStackSize(); |
13195 | 15106 | ||
13196 | try { | 15107 | try { |
13197 | // InternalProblem.g:4190:1: ( ( '::' ) ) | 15108 | // InternalProblem.g:4772:1: ( ( '::' ) ) |
13198 | // InternalProblem.g:4191:1: ( '::' ) | 15109 | // InternalProblem.g:4773:1: ( '::' ) |
13199 | { | 15110 | { |
13200 | // InternalProblem.g:4191:1: ( '::' ) | 15111 | // InternalProblem.g:4773:1: ( '::' ) |
13201 | // InternalProblem.g:4192:2: '::' | 15112 | // InternalProblem.g:4774:2: '::' |
13202 | { | 15113 | { |
13203 | before(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_2_0()); | 15114 | before(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_2_0()); |
13204 | match(input,39,FOLLOW_2); | 15115 | match(input,43,FOLLOW_2); |
13205 | after(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_2_0()); | 15116 | after(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_2_0()); |
13206 | 15117 | ||
13207 | } | 15118 | } |
@@ -13225,14 +15136,14 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13225 | 15136 | ||
13226 | 15137 | ||
13227 | // $ANTLR start "rule__QualifiedName__Group_1_2__1" | 15138 | // $ANTLR start "rule__QualifiedName__Group_1_2__1" |
13228 | // InternalProblem.g:4201:1: rule__QualifiedName__Group_1_2__1 : rule__QualifiedName__Group_1_2__1__Impl ; | 15139 | // InternalProblem.g:4783:1: rule__QualifiedName__Group_1_2__1 : rule__QualifiedName__Group_1_2__1__Impl ; |
13229 | public final void rule__QualifiedName__Group_1_2__1() throws RecognitionException { | 15140 | public final void rule__QualifiedName__Group_1_2__1() throws RecognitionException { |
13230 | 15141 | ||
13231 | int stackSize = keepStackSize(); | 15142 | int stackSize = keepStackSize(); |
13232 | 15143 | ||
13233 | try { | 15144 | try { |
13234 | // InternalProblem.g:4205:1: ( rule__QualifiedName__Group_1_2__1__Impl ) | 15145 | // InternalProblem.g:4787:1: ( rule__QualifiedName__Group_1_2__1__Impl ) |
13235 | // InternalProblem.g:4206:2: rule__QualifiedName__Group_1_2__1__Impl | 15146 | // InternalProblem.g:4788:2: rule__QualifiedName__Group_1_2__1__Impl |
13236 | { | 15147 | { |
13237 | pushFollow(FOLLOW_2); | 15148 | pushFollow(FOLLOW_2); |
13238 | rule__QualifiedName__Group_1_2__1__Impl(); | 15149 | rule__QualifiedName__Group_1_2__1__Impl(); |
@@ -13258,17 +15169,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13258 | 15169 | ||
13259 | 15170 | ||
13260 | // $ANTLR start "rule__QualifiedName__Group_1_2__1__Impl" | 15171 | // $ANTLR start "rule__QualifiedName__Group_1_2__1__Impl" |
13261 | // InternalProblem.g:4212:1: rule__QualifiedName__Group_1_2__1__Impl : ( RULE_QUOTED_ID ) ; | 15172 | // InternalProblem.g:4794:1: rule__QualifiedName__Group_1_2__1__Impl : ( RULE_QUOTED_ID ) ; |
13262 | public final void rule__QualifiedName__Group_1_2__1__Impl() throws RecognitionException { | 15173 | public final void rule__QualifiedName__Group_1_2__1__Impl() throws RecognitionException { |
13263 | 15174 | ||
13264 | int stackSize = keepStackSize(); | 15175 | int stackSize = keepStackSize(); |
13265 | 15176 | ||
13266 | try { | 15177 | try { |
13267 | // InternalProblem.g:4216:1: ( ( RULE_QUOTED_ID ) ) | 15178 | // InternalProblem.g:4798:1: ( ( RULE_QUOTED_ID ) ) |
13268 | // InternalProblem.g:4217:1: ( RULE_QUOTED_ID ) | 15179 | // InternalProblem.g:4799:1: ( RULE_QUOTED_ID ) |
13269 | { | 15180 | { |
13270 | // InternalProblem.g:4217:1: ( RULE_QUOTED_ID ) | 15181 | // InternalProblem.g:4799:1: ( RULE_QUOTED_ID ) |
13271 | // InternalProblem.g:4218:2: RULE_QUOTED_ID | 15182 | // InternalProblem.g:4800:2: RULE_QUOTED_ID |
13272 | { | 15183 | { |
13273 | before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1_2_1()); | 15184 | before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1_2_1()); |
13274 | match(input,RULE_QUOTED_ID,FOLLOW_2); | 15185 | match(input,RULE_QUOTED_ID,FOLLOW_2); |
@@ -13294,18 +15205,1064 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13294 | // $ANTLR end "rule__QualifiedName__Group_1_2__1__Impl" | 15205 | // $ANTLR end "rule__QualifiedName__Group_1_2__1__Impl" |
13295 | 15206 | ||
13296 | 15207 | ||
15208 | // $ANTLR start "rule__Integer__Group__0" | ||
15209 | // InternalProblem.g:4810:1: rule__Integer__Group__0 : rule__Integer__Group__0__Impl rule__Integer__Group__1 ; | ||
15210 | public final void rule__Integer__Group__0() throws RecognitionException { | ||
15211 | |||
15212 | int stackSize = keepStackSize(); | ||
15213 | |||
15214 | try { | ||
15215 | // InternalProblem.g:4814:1: ( rule__Integer__Group__0__Impl rule__Integer__Group__1 ) | ||
15216 | // InternalProblem.g:4815:2: rule__Integer__Group__0__Impl rule__Integer__Group__1 | ||
15217 | { | ||
15218 | pushFollow(FOLLOW_42); | ||
15219 | rule__Integer__Group__0__Impl(); | ||
15220 | |||
15221 | state._fsp--; | ||
15222 | |||
15223 | pushFollow(FOLLOW_2); | ||
15224 | rule__Integer__Group__1(); | ||
15225 | |||
15226 | state._fsp--; | ||
15227 | |||
15228 | |||
15229 | } | ||
15230 | |||
15231 | } | ||
15232 | catch (RecognitionException re) { | ||
15233 | reportError(re); | ||
15234 | recover(input,re); | ||
15235 | } | ||
15236 | finally { | ||
15237 | |||
15238 | restoreStackSize(stackSize); | ||
15239 | |||
15240 | } | ||
15241 | return ; | ||
15242 | } | ||
15243 | // $ANTLR end "rule__Integer__Group__0" | ||
15244 | |||
15245 | |||
15246 | // $ANTLR start "rule__Integer__Group__0__Impl" | ||
15247 | // InternalProblem.g:4822:1: rule__Integer__Group__0__Impl : ( ( '-' )? ) ; | ||
15248 | public final void rule__Integer__Group__0__Impl() throws RecognitionException { | ||
15249 | |||
15250 | int stackSize = keepStackSize(); | ||
15251 | |||
15252 | try { | ||
15253 | // InternalProblem.g:4826:1: ( ( ( '-' )? ) ) | ||
15254 | // InternalProblem.g:4827:1: ( ( '-' )? ) | ||
15255 | { | ||
15256 | // InternalProblem.g:4827:1: ( ( '-' )? ) | ||
15257 | // InternalProblem.g:4828:2: ( '-' )? | ||
15258 | { | ||
15259 | before(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0()); | ||
15260 | // InternalProblem.g:4829:2: ( '-' )? | ||
15261 | int alt55=2; | ||
15262 | int LA55_0 = input.LA(1); | ||
15263 | |||
15264 | if ( (LA55_0==23) ) { | ||
15265 | alt55=1; | ||
15266 | } | ||
15267 | switch (alt55) { | ||
15268 | case 1 : | ||
15269 | // InternalProblem.g:4829:3: '-' | ||
15270 | { | ||
15271 | match(input,23,FOLLOW_2); | ||
15272 | |||
15273 | } | ||
15274 | break; | ||
15275 | |||
15276 | } | ||
15277 | |||
15278 | after(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0()); | ||
15279 | |||
15280 | } | ||
15281 | |||
15282 | |||
15283 | } | ||
15284 | |||
15285 | } | ||
15286 | catch (RecognitionException re) { | ||
15287 | reportError(re); | ||
15288 | recover(input,re); | ||
15289 | } | ||
15290 | finally { | ||
15291 | |||
15292 | restoreStackSize(stackSize); | ||
15293 | |||
15294 | } | ||
15295 | return ; | ||
15296 | } | ||
15297 | // $ANTLR end "rule__Integer__Group__0__Impl" | ||
15298 | |||
15299 | |||
15300 | // $ANTLR start "rule__Integer__Group__1" | ||
15301 | // InternalProblem.g:4837:1: rule__Integer__Group__1 : rule__Integer__Group__1__Impl ; | ||
15302 | public final void rule__Integer__Group__1() throws RecognitionException { | ||
15303 | |||
15304 | int stackSize = keepStackSize(); | ||
15305 | |||
15306 | try { | ||
15307 | // InternalProblem.g:4841:1: ( rule__Integer__Group__1__Impl ) | ||
15308 | // InternalProblem.g:4842:2: rule__Integer__Group__1__Impl | ||
15309 | { | ||
15310 | pushFollow(FOLLOW_2); | ||
15311 | rule__Integer__Group__1__Impl(); | ||
15312 | |||
15313 | state._fsp--; | ||
15314 | |||
15315 | |||
15316 | } | ||
15317 | |||
15318 | } | ||
15319 | catch (RecognitionException re) { | ||
15320 | reportError(re); | ||
15321 | recover(input,re); | ||
15322 | } | ||
15323 | finally { | ||
15324 | |||
15325 | restoreStackSize(stackSize); | ||
15326 | |||
15327 | } | ||
15328 | return ; | ||
15329 | } | ||
15330 | // $ANTLR end "rule__Integer__Group__1" | ||
15331 | |||
15332 | |||
15333 | // $ANTLR start "rule__Integer__Group__1__Impl" | ||
15334 | // InternalProblem.g:4848:1: rule__Integer__Group__1__Impl : ( RULE_INT ) ; | ||
15335 | public final void rule__Integer__Group__1__Impl() throws RecognitionException { | ||
15336 | |||
15337 | int stackSize = keepStackSize(); | ||
15338 | |||
15339 | try { | ||
15340 | // InternalProblem.g:4852:1: ( ( RULE_INT ) ) | ||
15341 | // InternalProblem.g:4853:1: ( RULE_INT ) | ||
15342 | { | ||
15343 | // InternalProblem.g:4853:1: ( RULE_INT ) | ||
15344 | // InternalProblem.g:4854:2: RULE_INT | ||
15345 | { | ||
15346 | before(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_1()); | ||
15347 | match(input,RULE_INT,FOLLOW_2); | ||
15348 | after(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_1()); | ||
15349 | |||
15350 | } | ||
15351 | |||
15352 | |||
15353 | } | ||
15354 | |||
15355 | } | ||
15356 | catch (RecognitionException re) { | ||
15357 | reportError(re); | ||
15358 | recover(input,re); | ||
15359 | } | ||
15360 | finally { | ||
15361 | |||
15362 | restoreStackSize(stackSize); | ||
15363 | |||
15364 | } | ||
15365 | return ; | ||
15366 | } | ||
15367 | // $ANTLR end "rule__Integer__Group__1__Impl" | ||
15368 | |||
15369 | |||
15370 | // $ANTLR start "rule__Real__Group__0" | ||
15371 | // InternalProblem.g:4864:1: rule__Real__Group__0 : rule__Real__Group__0__Impl rule__Real__Group__1 ; | ||
15372 | public final void rule__Real__Group__0() throws RecognitionException { | ||
15373 | |||
15374 | int stackSize = keepStackSize(); | ||
15375 | |||
15376 | try { | ||
15377 | // InternalProblem.g:4868:1: ( rule__Real__Group__0__Impl rule__Real__Group__1 ) | ||
15378 | // InternalProblem.g:4869:2: rule__Real__Group__0__Impl rule__Real__Group__1 | ||
15379 | { | ||
15380 | pushFollow(FOLLOW_42); | ||
15381 | rule__Real__Group__0__Impl(); | ||
15382 | |||
15383 | state._fsp--; | ||
15384 | |||
15385 | pushFollow(FOLLOW_2); | ||
15386 | rule__Real__Group__1(); | ||
15387 | |||
15388 | state._fsp--; | ||
15389 | |||
15390 | |||
15391 | } | ||
15392 | |||
15393 | } | ||
15394 | catch (RecognitionException re) { | ||
15395 | reportError(re); | ||
15396 | recover(input,re); | ||
15397 | } | ||
15398 | finally { | ||
15399 | |||
15400 | restoreStackSize(stackSize); | ||
15401 | |||
15402 | } | ||
15403 | return ; | ||
15404 | } | ||
15405 | // $ANTLR end "rule__Real__Group__0" | ||
15406 | |||
15407 | |||
15408 | // $ANTLR start "rule__Real__Group__0__Impl" | ||
15409 | // InternalProblem.g:4876:1: rule__Real__Group__0__Impl : ( ( '-' )? ) ; | ||
15410 | public final void rule__Real__Group__0__Impl() throws RecognitionException { | ||
15411 | |||
15412 | int stackSize = keepStackSize(); | ||
15413 | |||
15414 | try { | ||
15415 | // InternalProblem.g:4880:1: ( ( ( '-' )? ) ) | ||
15416 | // InternalProblem.g:4881:1: ( ( '-' )? ) | ||
15417 | { | ||
15418 | // InternalProblem.g:4881:1: ( ( '-' )? ) | ||
15419 | // InternalProblem.g:4882:2: ( '-' )? | ||
15420 | { | ||
15421 | before(grammarAccess.getRealAccess().getHyphenMinusKeyword_0()); | ||
15422 | // InternalProblem.g:4883:2: ( '-' )? | ||
15423 | int alt56=2; | ||
15424 | int LA56_0 = input.LA(1); | ||
15425 | |||
15426 | if ( (LA56_0==23) ) { | ||
15427 | alt56=1; | ||
15428 | } | ||
15429 | switch (alt56) { | ||
15430 | case 1 : | ||
15431 | // InternalProblem.g:4883:3: '-' | ||
15432 | { | ||
15433 | match(input,23,FOLLOW_2); | ||
15434 | |||
15435 | } | ||
15436 | break; | ||
15437 | |||
15438 | } | ||
15439 | |||
15440 | after(grammarAccess.getRealAccess().getHyphenMinusKeyword_0()); | ||
15441 | |||
15442 | } | ||
15443 | |||
15444 | |||
15445 | } | ||
15446 | |||
15447 | } | ||
15448 | catch (RecognitionException re) { | ||
15449 | reportError(re); | ||
15450 | recover(input,re); | ||
15451 | } | ||
15452 | finally { | ||
15453 | |||
15454 | restoreStackSize(stackSize); | ||
15455 | |||
15456 | } | ||
15457 | return ; | ||
15458 | } | ||
15459 | // $ANTLR end "rule__Real__Group__0__Impl" | ||
15460 | |||
15461 | |||
15462 | // $ANTLR start "rule__Real__Group__1" | ||
15463 | // InternalProblem.g:4891:1: rule__Real__Group__1 : rule__Real__Group__1__Impl rule__Real__Group__2 ; | ||
15464 | public final void rule__Real__Group__1() throws RecognitionException { | ||
15465 | |||
15466 | int stackSize = keepStackSize(); | ||
15467 | |||
15468 | try { | ||
15469 | // InternalProblem.g:4895:1: ( rule__Real__Group__1__Impl rule__Real__Group__2 ) | ||
15470 | // InternalProblem.g:4896:2: rule__Real__Group__1__Impl rule__Real__Group__2 | ||
15471 | { | ||
15472 | pushFollow(FOLLOW_43); | ||
15473 | rule__Real__Group__1__Impl(); | ||
15474 | |||
15475 | state._fsp--; | ||
15476 | |||
15477 | pushFollow(FOLLOW_2); | ||
15478 | rule__Real__Group__2(); | ||
15479 | |||
15480 | state._fsp--; | ||
15481 | |||
15482 | |||
15483 | } | ||
15484 | |||
15485 | } | ||
15486 | catch (RecognitionException re) { | ||
15487 | reportError(re); | ||
15488 | recover(input,re); | ||
15489 | } | ||
15490 | finally { | ||
15491 | |||
15492 | restoreStackSize(stackSize); | ||
15493 | |||
15494 | } | ||
15495 | return ; | ||
15496 | } | ||
15497 | // $ANTLR end "rule__Real__Group__1" | ||
15498 | |||
15499 | |||
15500 | // $ANTLR start "rule__Real__Group__1__Impl" | ||
15501 | // InternalProblem.g:4903:1: rule__Real__Group__1__Impl : ( RULE_INT ) ; | ||
15502 | public final void rule__Real__Group__1__Impl() throws RecognitionException { | ||
15503 | |||
15504 | int stackSize = keepStackSize(); | ||
15505 | |||
15506 | try { | ||
15507 | // InternalProblem.g:4907:1: ( ( RULE_INT ) ) | ||
15508 | // InternalProblem.g:4908:1: ( RULE_INT ) | ||
15509 | { | ||
15510 | // InternalProblem.g:4908:1: ( RULE_INT ) | ||
15511 | // InternalProblem.g:4909:2: RULE_INT | ||
15512 | { | ||
15513 | before(grammarAccess.getRealAccess().getINTTerminalRuleCall_1()); | ||
15514 | match(input,RULE_INT,FOLLOW_2); | ||
15515 | after(grammarAccess.getRealAccess().getINTTerminalRuleCall_1()); | ||
15516 | |||
15517 | } | ||
15518 | |||
15519 | |||
15520 | } | ||
15521 | |||
15522 | } | ||
15523 | catch (RecognitionException re) { | ||
15524 | reportError(re); | ||
15525 | recover(input,re); | ||
15526 | } | ||
15527 | finally { | ||
15528 | |||
15529 | restoreStackSize(stackSize); | ||
15530 | |||
15531 | } | ||
15532 | return ; | ||
15533 | } | ||
15534 | // $ANTLR end "rule__Real__Group__1__Impl" | ||
15535 | |||
15536 | |||
15537 | // $ANTLR start "rule__Real__Group__2" | ||
15538 | // InternalProblem.g:4918:1: rule__Real__Group__2 : rule__Real__Group__2__Impl ; | ||
15539 | public final void rule__Real__Group__2() throws RecognitionException { | ||
15540 | |||
15541 | int stackSize = keepStackSize(); | ||
15542 | |||
15543 | try { | ||
15544 | // InternalProblem.g:4922:1: ( rule__Real__Group__2__Impl ) | ||
15545 | // InternalProblem.g:4923:2: rule__Real__Group__2__Impl | ||
15546 | { | ||
15547 | pushFollow(FOLLOW_2); | ||
15548 | rule__Real__Group__2__Impl(); | ||
15549 | |||
15550 | state._fsp--; | ||
15551 | |||
15552 | |||
15553 | } | ||
15554 | |||
15555 | } | ||
15556 | catch (RecognitionException re) { | ||
15557 | reportError(re); | ||
15558 | recover(input,re); | ||
15559 | } | ||
15560 | finally { | ||
15561 | |||
15562 | restoreStackSize(stackSize); | ||
15563 | |||
15564 | } | ||
15565 | return ; | ||
15566 | } | ||
15567 | // $ANTLR end "rule__Real__Group__2" | ||
15568 | |||
15569 | |||
15570 | // $ANTLR start "rule__Real__Group__2__Impl" | ||
15571 | // InternalProblem.g:4929:1: rule__Real__Group__2__Impl : ( ( rule__Real__Alternatives_2 ) ) ; | ||
15572 | public final void rule__Real__Group__2__Impl() throws RecognitionException { | ||
15573 | |||
15574 | int stackSize = keepStackSize(); | ||
15575 | |||
15576 | try { | ||
15577 | // InternalProblem.g:4933:1: ( ( ( rule__Real__Alternatives_2 ) ) ) | ||
15578 | // InternalProblem.g:4934:1: ( ( rule__Real__Alternatives_2 ) ) | ||
15579 | { | ||
15580 | // InternalProblem.g:4934:1: ( ( rule__Real__Alternatives_2 ) ) | ||
15581 | // InternalProblem.g:4935:2: ( rule__Real__Alternatives_2 ) | ||
15582 | { | ||
15583 | before(grammarAccess.getRealAccess().getAlternatives_2()); | ||
15584 | // InternalProblem.g:4936:2: ( rule__Real__Alternatives_2 ) | ||
15585 | // InternalProblem.g:4936:3: rule__Real__Alternatives_2 | ||
15586 | { | ||
15587 | pushFollow(FOLLOW_2); | ||
15588 | rule__Real__Alternatives_2(); | ||
15589 | |||
15590 | state._fsp--; | ||
15591 | |||
15592 | |||
15593 | } | ||
15594 | |||
15595 | after(grammarAccess.getRealAccess().getAlternatives_2()); | ||
15596 | |||
15597 | } | ||
15598 | |||
15599 | |||
15600 | } | ||
15601 | |||
15602 | } | ||
15603 | catch (RecognitionException re) { | ||
15604 | reportError(re); | ||
15605 | recover(input,re); | ||
15606 | } | ||
15607 | finally { | ||
15608 | |||
15609 | restoreStackSize(stackSize); | ||
15610 | |||
15611 | } | ||
15612 | return ; | ||
15613 | } | ||
15614 | // $ANTLR end "rule__Real__Group__2__Impl" | ||
15615 | |||
15616 | |||
15617 | // $ANTLR start "rule__Real__Group_2_0__0" | ||
15618 | // InternalProblem.g:4945:1: rule__Real__Group_2_0__0 : rule__Real__Group_2_0__0__Impl rule__Real__Group_2_0__1 ; | ||
15619 | public final void rule__Real__Group_2_0__0() throws RecognitionException { | ||
15620 | |||
15621 | int stackSize = keepStackSize(); | ||
15622 | |||
15623 | try { | ||
15624 | // InternalProblem.g:4949:1: ( rule__Real__Group_2_0__0__Impl rule__Real__Group_2_0__1 ) | ||
15625 | // InternalProblem.g:4950:2: rule__Real__Group_2_0__0__Impl rule__Real__Group_2_0__1 | ||
15626 | { | ||
15627 | pushFollow(FOLLOW_20); | ||
15628 | rule__Real__Group_2_0__0__Impl(); | ||
15629 | |||
15630 | state._fsp--; | ||
15631 | |||
15632 | pushFollow(FOLLOW_2); | ||
15633 | rule__Real__Group_2_0__1(); | ||
15634 | |||
15635 | state._fsp--; | ||
15636 | |||
15637 | |||
15638 | } | ||
15639 | |||
15640 | } | ||
15641 | catch (RecognitionException re) { | ||
15642 | reportError(re); | ||
15643 | recover(input,re); | ||
15644 | } | ||
15645 | finally { | ||
15646 | |||
15647 | restoreStackSize(stackSize); | ||
15648 | |||
15649 | } | ||
15650 | return ; | ||
15651 | } | ||
15652 | // $ANTLR end "rule__Real__Group_2_0__0" | ||
15653 | |||
15654 | |||
15655 | // $ANTLR start "rule__Real__Group_2_0__0__Impl" | ||
15656 | // InternalProblem.g:4957:1: rule__Real__Group_2_0__0__Impl : ( '.' ) ; | ||
15657 | public final void rule__Real__Group_2_0__0__Impl() throws RecognitionException { | ||
15658 | |||
15659 | int stackSize = keepStackSize(); | ||
15660 | |||
15661 | try { | ||
15662 | // InternalProblem.g:4961:1: ( ( '.' ) ) | ||
15663 | // InternalProblem.g:4962:1: ( '.' ) | ||
15664 | { | ||
15665 | // InternalProblem.g:4962:1: ( '.' ) | ||
15666 | // InternalProblem.g:4963:2: '.' | ||
15667 | { | ||
15668 | before(grammarAccess.getRealAccess().getFullStopKeyword_2_0_0()); | ||
15669 | match(input,12,FOLLOW_2); | ||
15670 | after(grammarAccess.getRealAccess().getFullStopKeyword_2_0_0()); | ||
15671 | |||
15672 | } | ||
15673 | |||
15674 | |||
15675 | } | ||
15676 | |||
15677 | } | ||
15678 | catch (RecognitionException re) { | ||
15679 | reportError(re); | ||
15680 | recover(input,re); | ||
15681 | } | ||
15682 | finally { | ||
15683 | |||
15684 | restoreStackSize(stackSize); | ||
15685 | |||
15686 | } | ||
15687 | return ; | ||
15688 | } | ||
15689 | // $ANTLR end "rule__Real__Group_2_0__0__Impl" | ||
15690 | |||
15691 | |||
15692 | // $ANTLR start "rule__Real__Group_2_0__1" | ||
15693 | // InternalProblem.g:4972:1: rule__Real__Group_2_0__1 : rule__Real__Group_2_0__1__Impl ; | ||
15694 | public final void rule__Real__Group_2_0__1() throws RecognitionException { | ||
15695 | |||
15696 | int stackSize = keepStackSize(); | ||
15697 | |||
15698 | try { | ||
15699 | // InternalProblem.g:4976:1: ( rule__Real__Group_2_0__1__Impl ) | ||
15700 | // InternalProblem.g:4977:2: rule__Real__Group_2_0__1__Impl | ||
15701 | { | ||
15702 | pushFollow(FOLLOW_2); | ||
15703 | rule__Real__Group_2_0__1__Impl(); | ||
15704 | |||
15705 | state._fsp--; | ||
15706 | |||
15707 | |||
15708 | } | ||
15709 | |||
15710 | } | ||
15711 | catch (RecognitionException re) { | ||
15712 | reportError(re); | ||
15713 | recover(input,re); | ||
15714 | } | ||
15715 | finally { | ||
15716 | |||
15717 | restoreStackSize(stackSize); | ||
15718 | |||
15719 | } | ||
15720 | return ; | ||
15721 | } | ||
15722 | // $ANTLR end "rule__Real__Group_2_0__1" | ||
15723 | |||
15724 | |||
15725 | // $ANTLR start "rule__Real__Group_2_0__1__Impl" | ||
15726 | // InternalProblem.g:4983:1: rule__Real__Group_2_0__1__Impl : ( RULE_INT ) ; | ||
15727 | public final void rule__Real__Group_2_0__1__Impl() throws RecognitionException { | ||
15728 | |||
15729 | int stackSize = keepStackSize(); | ||
15730 | |||
15731 | try { | ||
15732 | // InternalProblem.g:4987:1: ( ( RULE_INT ) ) | ||
15733 | // InternalProblem.g:4988:1: ( RULE_INT ) | ||
15734 | { | ||
15735 | // InternalProblem.g:4988:1: ( RULE_INT ) | ||
15736 | // InternalProblem.g:4989:2: RULE_INT | ||
15737 | { | ||
15738 | before(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_0_1()); | ||
15739 | match(input,RULE_INT,FOLLOW_2); | ||
15740 | after(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_0_1()); | ||
15741 | |||
15742 | } | ||
15743 | |||
15744 | |||
15745 | } | ||
15746 | |||
15747 | } | ||
15748 | catch (RecognitionException re) { | ||
15749 | reportError(re); | ||
15750 | recover(input,re); | ||
15751 | } | ||
15752 | finally { | ||
15753 | |||
15754 | restoreStackSize(stackSize); | ||
15755 | |||
15756 | } | ||
15757 | return ; | ||
15758 | } | ||
15759 | // $ANTLR end "rule__Real__Group_2_0__1__Impl" | ||
15760 | |||
15761 | |||
15762 | // $ANTLR start "rule__Real__Group_2_1__0" | ||
15763 | // InternalProblem.g:4999:1: rule__Real__Group_2_1__0 : rule__Real__Group_2_1__0__Impl rule__Real__Group_2_1__1 ; | ||
15764 | public final void rule__Real__Group_2_1__0() throws RecognitionException { | ||
15765 | |||
15766 | int stackSize = keepStackSize(); | ||
15767 | |||
15768 | try { | ||
15769 | // InternalProblem.g:5003:1: ( rule__Real__Group_2_1__0__Impl rule__Real__Group_2_1__1 ) | ||
15770 | // InternalProblem.g:5004:2: rule__Real__Group_2_1__0__Impl rule__Real__Group_2_1__1 | ||
15771 | { | ||
15772 | pushFollow(FOLLOW_43); | ||
15773 | rule__Real__Group_2_1__0__Impl(); | ||
15774 | |||
15775 | state._fsp--; | ||
15776 | |||
15777 | pushFollow(FOLLOW_2); | ||
15778 | rule__Real__Group_2_1__1(); | ||
15779 | |||
15780 | state._fsp--; | ||
15781 | |||
15782 | |||
15783 | } | ||
15784 | |||
15785 | } | ||
15786 | catch (RecognitionException re) { | ||
15787 | reportError(re); | ||
15788 | recover(input,re); | ||
15789 | } | ||
15790 | finally { | ||
15791 | |||
15792 | restoreStackSize(stackSize); | ||
15793 | |||
15794 | } | ||
15795 | return ; | ||
15796 | } | ||
15797 | // $ANTLR end "rule__Real__Group_2_1__0" | ||
15798 | |||
15799 | |||
15800 | // $ANTLR start "rule__Real__Group_2_1__0__Impl" | ||
15801 | // InternalProblem.g:5011:1: rule__Real__Group_2_1__0__Impl : ( ( rule__Real__Group_2_1_0__0 )? ) ; | ||
15802 | public final void rule__Real__Group_2_1__0__Impl() throws RecognitionException { | ||
15803 | |||
15804 | int stackSize = keepStackSize(); | ||
15805 | |||
15806 | try { | ||
15807 | // InternalProblem.g:5015:1: ( ( ( rule__Real__Group_2_1_0__0 )? ) ) | ||
15808 | // InternalProblem.g:5016:1: ( ( rule__Real__Group_2_1_0__0 )? ) | ||
15809 | { | ||
15810 | // InternalProblem.g:5016:1: ( ( rule__Real__Group_2_1_0__0 )? ) | ||
15811 | // InternalProblem.g:5017:2: ( rule__Real__Group_2_1_0__0 )? | ||
15812 | { | ||
15813 | before(grammarAccess.getRealAccess().getGroup_2_1_0()); | ||
15814 | // InternalProblem.g:5018:2: ( rule__Real__Group_2_1_0__0 )? | ||
15815 | int alt57=2; | ||
15816 | int LA57_0 = input.LA(1); | ||
15817 | |||
15818 | if ( (LA57_0==12) ) { | ||
15819 | alt57=1; | ||
15820 | } | ||
15821 | switch (alt57) { | ||
15822 | case 1 : | ||
15823 | // InternalProblem.g:5018:3: rule__Real__Group_2_1_0__0 | ||
15824 | { | ||
15825 | pushFollow(FOLLOW_2); | ||
15826 | rule__Real__Group_2_1_0__0(); | ||
15827 | |||
15828 | state._fsp--; | ||
15829 | |||
15830 | |||
15831 | } | ||
15832 | break; | ||
15833 | |||
15834 | } | ||
15835 | |||
15836 | after(grammarAccess.getRealAccess().getGroup_2_1_0()); | ||
15837 | |||
15838 | } | ||
15839 | |||
15840 | |||
15841 | } | ||
15842 | |||
15843 | } | ||
15844 | catch (RecognitionException re) { | ||
15845 | reportError(re); | ||
15846 | recover(input,re); | ||
15847 | } | ||
15848 | finally { | ||
15849 | |||
15850 | restoreStackSize(stackSize); | ||
15851 | |||
15852 | } | ||
15853 | return ; | ||
15854 | } | ||
15855 | // $ANTLR end "rule__Real__Group_2_1__0__Impl" | ||
15856 | |||
15857 | |||
15858 | // $ANTLR start "rule__Real__Group_2_1__1" | ||
15859 | // InternalProblem.g:5026:1: rule__Real__Group_2_1__1 : rule__Real__Group_2_1__1__Impl rule__Real__Group_2_1__2 ; | ||
15860 | public final void rule__Real__Group_2_1__1() throws RecognitionException { | ||
15861 | |||
15862 | int stackSize = keepStackSize(); | ||
15863 | |||
15864 | try { | ||
15865 | // InternalProblem.g:5030:1: ( rule__Real__Group_2_1__1__Impl rule__Real__Group_2_1__2 ) | ||
15866 | // InternalProblem.g:5031:2: rule__Real__Group_2_1__1__Impl rule__Real__Group_2_1__2 | ||
15867 | { | ||
15868 | pushFollow(FOLLOW_44); | ||
15869 | rule__Real__Group_2_1__1__Impl(); | ||
15870 | |||
15871 | state._fsp--; | ||
15872 | |||
15873 | pushFollow(FOLLOW_2); | ||
15874 | rule__Real__Group_2_1__2(); | ||
15875 | |||
15876 | state._fsp--; | ||
15877 | |||
15878 | |||
15879 | } | ||
15880 | |||
15881 | } | ||
15882 | catch (RecognitionException re) { | ||
15883 | reportError(re); | ||
15884 | recover(input,re); | ||
15885 | } | ||
15886 | finally { | ||
15887 | |||
15888 | restoreStackSize(stackSize); | ||
15889 | |||
15890 | } | ||
15891 | return ; | ||
15892 | } | ||
15893 | // $ANTLR end "rule__Real__Group_2_1__1" | ||
15894 | |||
15895 | |||
15896 | // $ANTLR start "rule__Real__Group_2_1__1__Impl" | ||
15897 | // InternalProblem.g:5038:1: rule__Real__Group_2_1__1__Impl : ( ( rule__Real__Alternatives_2_1_1 ) ) ; | ||
15898 | public final void rule__Real__Group_2_1__1__Impl() throws RecognitionException { | ||
15899 | |||
15900 | int stackSize = keepStackSize(); | ||
15901 | |||
15902 | try { | ||
15903 | // InternalProblem.g:5042:1: ( ( ( rule__Real__Alternatives_2_1_1 ) ) ) | ||
15904 | // InternalProblem.g:5043:1: ( ( rule__Real__Alternatives_2_1_1 ) ) | ||
15905 | { | ||
15906 | // InternalProblem.g:5043:1: ( ( rule__Real__Alternatives_2_1_1 ) ) | ||
15907 | // InternalProblem.g:5044:2: ( rule__Real__Alternatives_2_1_1 ) | ||
15908 | { | ||
15909 | before(grammarAccess.getRealAccess().getAlternatives_2_1_1()); | ||
15910 | // InternalProblem.g:5045:2: ( rule__Real__Alternatives_2_1_1 ) | ||
15911 | // InternalProblem.g:5045:3: rule__Real__Alternatives_2_1_1 | ||
15912 | { | ||
15913 | pushFollow(FOLLOW_2); | ||
15914 | rule__Real__Alternatives_2_1_1(); | ||
15915 | |||
15916 | state._fsp--; | ||
15917 | |||
15918 | |||
15919 | } | ||
15920 | |||
15921 | after(grammarAccess.getRealAccess().getAlternatives_2_1_1()); | ||
15922 | |||
15923 | } | ||
15924 | |||
15925 | |||
15926 | } | ||
15927 | |||
15928 | } | ||
15929 | catch (RecognitionException re) { | ||
15930 | reportError(re); | ||
15931 | recover(input,re); | ||
15932 | } | ||
15933 | finally { | ||
15934 | |||
15935 | restoreStackSize(stackSize); | ||
15936 | |||
15937 | } | ||
15938 | return ; | ||
15939 | } | ||
15940 | // $ANTLR end "rule__Real__Group_2_1__1__Impl" | ||
15941 | |||
15942 | |||
15943 | // $ANTLR start "rule__Real__Group_2_1__2" | ||
15944 | // InternalProblem.g:5053:1: rule__Real__Group_2_1__2 : rule__Real__Group_2_1__2__Impl rule__Real__Group_2_1__3 ; | ||
15945 | public final void rule__Real__Group_2_1__2() throws RecognitionException { | ||
15946 | |||
15947 | int stackSize = keepStackSize(); | ||
15948 | |||
15949 | try { | ||
15950 | // InternalProblem.g:5057:1: ( rule__Real__Group_2_1__2__Impl rule__Real__Group_2_1__3 ) | ||
15951 | // InternalProblem.g:5058:2: rule__Real__Group_2_1__2__Impl rule__Real__Group_2_1__3 | ||
15952 | { | ||
15953 | pushFollow(FOLLOW_44); | ||
15954 | rule__Real__Group_2_1__2__Impl(); | ||
15955 | |||
15956 | state._fsp--; | ||
15957 | |||
15958 | pushFollow(FOLLOW_2); | ||
15959 | rule__Real__Group_2_1__3(); | ||
15960 | |||
15961 | state._fsp--; | ||
15962 | |||
15963 | |||
15964 | } | ||
15965 | |||
15966 | } | ||
15967 | catch (RecognitionException re) { | ||
15968 | reportError(re); | ||
15969 | recover(input,re); | ||
15970 | } | ||
15971 | finally { | ||
15972 | |||
15973 | restoreStackSize(stackSize); | ||
15974 | |||
15975 | } | ||
15976 | return ; | ||
15977 | } | ||
15978 | // $ANTLR end "rule__Real__Group_2_1__2" | ||
15979 | |||
15980 | |||
15981 | // $ANTLR start "rule__Real__Group_2_1__2__Impl" | ||
15982 | // InternalProblem.g:5065:1: rule__Real__Group_2_1__2__Impl : ( ( rule__Real__Alternatives_2_1_2 )? ) ; | ||
15983 | public final void rule__Real__Group_2_1__2__Impl() throws RecognitionException { | ||
15984 | |||
15985 | int stackSize = keepStackSize(); | ||
15986 | |||
15987 | try { | ||
15988 | // InternalProblem.g:5069:1: ( ( ( rule__Real__Alternatives_2_1_2 )? ) ) | ||
15989 | // InternalProblem.g:5070:1: ( ( rule__Real__Alternatives_2_1_2 )? ) | ||
15990 | { | ||
15991 | // InternalProblem.g:5070:1: ( ( rule__Real__Alternatives_2_1_2 )? ) | ||
15992 | // InternalProblem.g:5071:2: ( rule__Real__Alternatives_2_1_2 )? | ||
15993 | { | ||
15994 | before(grammarAccess.getRealAccess().getAlternatives_2_1_2()); | ||
15995 | // InternalProblem.g:5072:2: ( rule__Real__Alternatives_2_1_2 )? | ||
15996 | int alt58=2; | ||
15997 | int LA58_0 = input.LA(1); | ||
15998 | |||
15999 | if ( ((LA58_0>=23 && LA58_0<=24)) ) { | ||
16000 | alt58=1; | ||
16001 | } | ||
16002 | switch (alt58) { | ||
16003 | case 1 : | ||
16004 | // InternalProblem.g:5072:3: rule__Real__Alternatives_2_1_2 | ||
16005 | { | ||
16006 | pushFollow(FOLLOW_2); | ||
16007 | rule__Real__Alternatives_2_1_2(); | ||
16008 | |||
16009 | state._fsp--; | ||
16010 | |||
16011 | |||
16012 | } | ||
16013 | break; | ||
16014 | |||
16015 | } | ||
16016 | |||
16017 | after(grammarAccess.getRealAccess().getAlternatives_2_1_2()); | ||
16018 | |||
16019 | } | ||
16020 | |||
16021 | |||
16022 | } | ||
16023 | |||
16024 | } | ||
16025 | catch (RecognitionException re) { | ||
16026 | reportError(re); | ||
16027 | recover(input,re); | ||
16028 | } | ||
16029 | finally { | ||
16030 | |||
16031 | restoreStackSize(stackSize); | ||
16032 | |||
16033 | } | ||
16034 | return ; | ||
16035 | } | ||
16036 | // $ANTLR end "rule__Real__Group_2_1__2__Impl" | ||
16037 | |||
16038 | |||
16039 | // $ANTLR start "rule__Real__Group_2_1__3" | ||
16040 | // InternalProblem.g:5080:1: rule__Real__Group_2_1__3 : rule__Real__Group_2_1__3__Impl ; | ||
16041 | public final void rule__Real__Group_2_1__3() throws RecognitionException { | ||
16042 | |||
16043 | int stackSize = keepStackSize(); | ||
16044 | |||
16045 | try { | ||
16046 | // InternalProblem.g:5084:1: ( rule__Real__Group_2_1__3__Impl ) | ||
16047 | // InternalProblem.g:5085:2: rule__Real__Group_2_1__3__Impl | ||
16048 | { | ||
16049 | pushFollow(FOLLOW_2); | ||
16050 | rule__Real__Group_2_1__3__Impl(); | ||
16051 | |||
16052 | state._fsp--; | ||
16053 | |||
16054 | |||
16055 | } | ||
16056 | |||
16057 | } | ||
16058 | catch (RecognitionException re) { | ||
16059 | reportError(re); | ||
16060 | recover(input,re); | ||
16061 | } | ||
16062 | finally { | ||
16063 | |||
16064 | restoreStackSize(stackSize); | ||
16065 | |||
16066 | } | ||
16067 | return ; | ||
16068 | } | ||
16069 | // $ANTLR end "rule__Real__Group_2_1__3" | ||
16070 | |||
16071 | |||
16072 | // $ANTLR start "rule__Real__Group_2_1__3__Impl" | ||
16073 | // InternalProblem.g:5091:1: rule__Real__Group_2_1__3__Impl : ( RULE_INT ) ; | ||
16074 | public final void rule__Real__Group_2_1__3__Impl() throws RecognitionException { | ||
16075 | |||
16076 | int stackSize = keepStackSize(); | ||
16077 | |||
16078 | try { | ||
16079 | // InternalProblem.g:5095:1: ( ( RULE_INT ) ) | ||
16080 | // InternalProblem.g:5096:1: ( RULE_INT ) | ||
16081 | { | ||
16082 | // InternalProblem.g:5096:1: ( RULE_INT ) | ||
16083 | // InternalProblem.g:5097:2: RULE_INT | ||
16084 | { | ||
16085 | before(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_3()); | ||
16086 | match(input,RULE_INT,FOLLOW_2); | ||
16087 | after(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_3()); | ||
16088 | |||
16089 | } | ||
16090 | |||
16091 | |||
16092 | } | ||
16093 | |||
16094 | } | ||
16095 | catch (RecognitionException re) { | ||
16096 | reportError(re); | ||
16097 | recover(input,re); | ||
16098 | } | ||
16099 | finally { | ||
16100 | |||
16101 | restoreStackSize(stackSize); | ||
16102 | |||
16103 | } | ||
16104 | return ; | ||
16105 | } | ||
16106 | // $ANTLR end "rule__Real__Group_2_1__3__Impl" | ||
16107 | |||
16108 | |||
16109 | // $ANTLR start "rule__Real__Group_2_1_0__0" | ||
16110 | // InternalProblem.g:5107:1: rule__Real__Group_2_1_0__0 : rule__Real__Group_2_1_0__0__Impl rule__Real__Group_2_1_0__1 ; | ||
16111 | public final void rule__Real__Group_2_1_0__0() throws RecognitionException { | ||
16112 | |||
16113 | int stackSize = keepStackSize(); | ||
16114 | |||
16115 | try { | ||
16116 | // InternalProblem.g:5111:1: ( rule__Real__Group_2_1_0__0__Impl rule__Real__Group_2_1_0__1 ) | ||
16117 | // InternalProblem.g:5112:2: rule__Real__Group_2_1_0__0__Impl rule__Real__Group_2_1_0__1 | ||
16118 | { | ||
16119 | pushFollow(FOLLOW_20); | ||
16120 | rule__Real__Group_2_1_0__0__Impl(); | ||
16121 | |||
16122 | state._fsp--; | ||
16123 | |||
16124 | pushFollow(FOLLOW_2); | ||
16125 | rule__Real__Group_2_1_0__1(); | ||
16126 | |||
16127 | state._fsp--; | ||
16128 | |||
16129 | |||
16130 | } | ||
16131 | |||
16132 | } | ||
16133 | catch (RecognitionException re) { | ||
16134 | reportError(re); | ||
16135 | recover(input,re); | ||
16136 | } | ||
16137 | finally { | ||
16138 | |||
16139 | restoreStackSize(stackSize); | ||
16140 | |||
16141 | } | ||
16142 | return ; | ||
16143 | } | ||
16144 | // $ANTLR end "rule__Real__Group_2_1_0__0" | ||
16145 | |||
16146 | |||
16147 | // $ANTLR start "rule__Real__Group_2_1_0__0__Impl" | ||
16148 | // InternalProblem.g:5119:1: rule__Real__Group_2_1_0__0__Impl : ( '.' ) ; | ||
16149 | public final void rule__Real__Group_2_1_0__0__Impl() throws RecognitionException { | ||
16150 | |||
16151 | int stackSize = keepStackSize(); | ||
16152 | |||
16153 | try { | ||
16154 | // InternalProblem.g:5123:1: ( ( '.' ) ) | ||
16155 | // InternalProblem.g:5124:1: ( '.' ) | ||
16156 | { | ||
16157 | // InternalProblem.g:5124:1: ( '.' ) | ||
16158 | // InternalProblem.g:5125:2: '.' | ||
16159 | { | ||
16160 | before(grammarAccess.getRealAccess().getFullStopKeyword_2_1_0_0()); | ||
16161 | match(input,12,FOLLOW_2); | ||
16162 | after(grammarAccess.getRealAccess().getFullStopKeyword_2_1_0_0()); | ||
16163 | |||
16164 | } | ||
16165 | |||
16166 | |||
16167 | } | ||
16168 | |||
16169 | } | ||
16170 | catch (RecognitionException re) { | ||
16171 | reportError(re); | ||
16172 | recover(input,re); | ||
16173 | } | ||
16174 | finally { | ||
16175 | |||
16176 | restoreStackSize(stackSize); | ||
16177 | |||
16178 | } | ||
16179 | return ; | ||
16180 | } | ||
16181 | // $ANTLR end "rule__Real__Group_2_1_0__0__Impl" | ||
16182 | |||
16183 | |||
16184 | // $ANTLR start "rule__Real__Group_2_1_0__1" | ||
16185 | // InternalProblem.g:5134:1: rule__Real__Group_2_1_0__1 : rule__Real__Group_2_1_0__1__Impl ; | ||
16186 | public final void rule__Real__Group_2_1_0__1() throws RecognitionException { | ||
16187 | |||
16188 | int stackSize = keepStackSize(); | ||
16189 | |||
16190 | try { | ||
16191 | // InternalProblem.g:5138:1: ( rule__Real__Group_2_1_0__1__Impl ) | ||
16192 | // InternalProblem.g:5139:2: rule__Real__Group_2_1_0__1__Impl | ||
16193 | { | ||
16194 | pushFollow(FOLLOW_2); | ||
16195 | rule__Real__Group_2_1_0__1__Impl(); | ||
16196 | |||
16197 | state._fsp--; | ||
16198 | |||
16199 | |||
16200 | } | ||
16201 | |||
16202 | } | ||
16203 | catch (RecognitionException re) { | ||
16204 | reportError(re); | ||
16205 | recover(input,re); | ||
16206 | } | ||
16207 | finally { | ||
16208 | |||
16209 | restoreStackSize(stackSize); | ||
16210 | |||
16211 | } | ||
16212 | return ; | ||
16213 | } | ||
16214 | // $ANTLR end "rule__Real__Group_2_1_0__1" | ||
16215 | |||
16216 | |||
16217 | // $ANTLR start "rule__Real__Group_2_1_0__1__Impl" | ||
16218 | // InternalProblem.g:5145:1: rule__Real__Group_2_1_0__1__Impl : ( RULE_INT ) ; | ||
16219 | public final void rule__Real__Group_2_1_0__1__Impl() throws RecognitionException { | ||
16220 | |||
16221 | int stackSize = keepStackSize(); | ||
16222 | |||
16223 | try { | ||
16224 | // InternalProblem.g:5149:1: ( ( RULE_INT ) ) | ||
16225 | // InternalProblem.g:5150:1: ( RULE_INT ) | ||
16226 | { | ||
16227 | // InternalProblem.g:5150:1: ( RULE_INT ) | ||
16228 | // InternalProblem.g:5151:2: RULE_INT | ||
16229 | { | ||
16230 | before(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_0_1()); | ||
16231 | match(input,RULE_INT,FOLLOW_2); | ||
16232 | after(grammarAccess.getRealAccess().getINTTerminalRuleCall_2_1_0_1()); | ||
16233 | |||
16234 | } | ||
16235 | |||
16236 | |||
16237 | } | ||
16238 | |||
16239 | } | ||
16240 | catch (RecognitionException re) { | ||
16241 | reportError(re); | ||
16242 | recover(input,re); | ||
16243 | } | ||
16244 | finally { | ||
16245 | |||
16246 | restoreStackSize(stackSize); | ||
16247 | |||
16248 | } | ||
16249 | return ; | ||
16250 | } | ||
16251 | // $ANTLR end "rule__Real__Group_2_1_0__1__Impl" | ||
16252 | |||
16253 | |||
13297 | // $ANTLR start "rule__Problem__NameAssignment_0_1" | 16254 | // $ANTLR start "rule__Problem__NameAssignment_0_1" |
13298 | // InternalProblem.g:4228:1: rule__Problem__NameAssignment_0_1 : ( ruleIdentifier ) ; | 16255 | // InternalProblem.g:5161:1: rule__Problem__NameAssignment_0_1 : ( ruleIdentifier ) ; |
13299 | public final void rule__Problem__NameAssignment_0_1() throws RecognitionException { | 16256 | public final void rule__Problem__NameAssignment_0_1() throws RecognitionException { |
13300 | 16257 | ||
13301 | int stackSize = keepStackSize(); | 16258 | int stackSize = keepStackSize(); |
13302 | 16259 | ||
13303 | try { | 16260 | try { |
13304 | // InternalProblem.g:4232:1: ( ( ruleIdentifier ) ) | 16261 | // InternalProblem.g:5165:1: ( ( ruleIdentifier ) ) |
13305 | // InternalProblem.g:4233:2: ( ruleIdentifier ) | 16262 | // InternalProblem.g:5166:2: ( ruleIdentifier ) |
13306 | { | 16263 | { |
13307 | // InternalProblem.g:4233:2: ( ruleIdentifier ) | 16264 | // InternalProblem.g:5166:2: ( ruleIdentifier ) |
13308 | // InternalProblem.g:4234:3: ruleIdentifier | 16265 | // InternalProblem.g:5167:3: ruleIdentifier |
13309 | { | 16266 | { |
13310 | before(grammarAccess.getProblemAccess().getNameIdentifierParserRuleCall_0_1_0()); | 16267 | before(grammarAccess.getProblemAccess().getNameIdentifierParserRuleCall_0_1_0()); |
13311 | pushFollow(FOLLOW_2); | 16268 | pushFollow(FOLLOW_2); |
@@ -13336,17 +16293,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13336 | 16293 | ||
13337 | 16294 | ||
13338 | // $ANTLR start "rule__Problem__StatementsAssignment_1" | 16295 | // $ANTLR start "rule__Problem__StatementsAssignment_1" |
13339 | // InternalProblem.g:4243:1: rule__Problem__StatementsAssignment_1 : ( ruleStatement ) ; | 16296 | // InternalProblem.g:5176:1: rule__Problem__StatementsAssignment_1 : ( ruleStatement ) ; |
13340 | public final void rule__Problem__StatementsAssignment_1() throws RecognitionException { | 16297 | public final void rule__Problem__StatementsAssignment_1() throws RecognitionException { |
13341 | 16298 | ||
13342 | int stackSize = keepStackSize(); | 16299 | int stackSize = keepStackSize(); |
13343 | 16300 | ||
13344 | try { | 16301 | try { |
13345 | // InternalProblem.g:4247:1: ( ( ruleStatement ) ) | 16302 | // InternalProblem.g:5180:1: ( ( ruleStatement ) ) |
13346 | // InternalProblem.g:4248:2: ( ruleStatement ) | 16303 | // InternalProblem.g:5181:2: ( ruleStatement ) |
13347 | { | 16304 | { |
13348 | // InternalProblem.g:4248:2: ( ruleStatement ) | 16305 | // InternalProblem.g:5181:2: ( ruleStatement ) |
13349 | // InternalProblem.g:4249:3: ruleStatement | 16306 | // InternalProblem.g:5182:3: ruleStatement |
13350 | { | 16307 | { |
13351 | before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_1_0()); | 16308 | before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_1_0()); |
13352 | pushFollow(FOLLOW_2); | 16309 | pushFollow(FOLLOW_2); |
@@ -13377,24 +16334,24 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13377 | 16334 | ||
13378 | 16335 | ||
13379 | // $ANTLR start "rule__ClassDeclaration__AbstractAssignment_0" | 16336 | // $ANTLR start "rule__ClassDeclaration__AbstractAssignment_0" |
13380 | // InternalProblem.g:4258:1: rule__ClassDeclaration__AbstractAssignment_0 : ( ( 'abstract' ) ) ; | 16337 | // InternalProblem.g:5191:1: rule__ClassDeclaration__AbstractAssignment_0 : ( ( 'abstract' ) ) ; |
13381 | public final void rule__ClassDeclaration__AbstractAssignment_0() throws RecognitionException { | 16338 | public final void rule__ClassDeclaration__AbstractAssignment_0() throws RecognitionException { |
13382 | 16339 | ||
13383 | int stackSize = keepStackSize(); | 16340 | int stackSize = keepStackSize(); |
13384 | 16341 | ||
13385 | try { | 16342 | try { |
13386 | // InternalProblem.g:4262:1: ( ( ( 'abstract' ) ) ) | 16343 | // InternalProblem.g:5195:1: ( ( ( 'abstract' ) ) ) |
13387 | // InternalProblem.g:4263:2: ( ( 'abstract' ) ) | 16344 | // InternalProblem.g:5196:2: ( ( 'abstract' ) ) |
13388 | { | 16345 | { |
13389 | // InternalProblem.g:4263:2: ( ( 'abstract' ) ) | 16346 | // InternalProblem.g:5196:2: ( ( 'abstract' ) ) |
13390 | // InternalProblem.g:4264:3: ( 'abstract' ) | 16347 | // InternalProblem.g:5197:3: ( 'abstract' ) |
13391 | { | 16348 | { |
13392 | before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); | 16349 | before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); |
13393 | // InternalProblem.g:4265:3: ( 'abstract' ) | 16350 | // InternalProblem.g:5198:3: ( 'abstract' ) |
13394 | // InternalProblem.g:4266:4: 'abstract' | 16351 | // InternalProblem.g:5199:4: 'abstract' |
13395 | { | 16352 | { |
13396 | before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); | 16353 | before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); |
13397 | match(input,40,FOLLOW_2); | 16354 | match(input,44,FOLLOW_2); |
13398 | after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); | 16355 | after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); |
13399 | 16356 | ||
13400 | } | 16357 | } |
@@ -13422,17 +16379,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13422 | 16379 | ||
13423 | 16380 | ||
13424 | // $ANTLR start "rule__ClassDeclaration__NameAssignment_2" | 16381 | // $ANTLR start "rule__ClassDeclaration__NameAssignment_2" |
13425 | // InternalProblem.g:4277:1: rule__ClassDeclaration__NameAssignment_2 : ( ruleIdentifier ) ; | 16382 | // InternalProblem.g:5210:1: rule__ClassDeclaration__NameAssignment_2 : ( ruleIdentifier ) ; |
13426 | public final void rule__ClassDeclaration__NameAssignment_2() throws RecognitionException { | 16383 | public final void rule__ClassDeclaration__NameAssignment_2() throws RecognitionException { |
13427 | 16384 | ||
13428 | int stackSize = keepStackSize(); | 16385 | int stackSize = keepStackSize(); |
13429 | 16386 | ||
13430 | try { | 16387 | try { |
13431 | // InternalProblem.g:4281:1: ( ( ruleIdentifier ) ) | 16388 | // InternalProblem.g:5214:1: ( ( ruleIdentifier ) ) |
13432 | // InternalProblem.g:4282:2: ( ruleIdentifier ) | 16389 | // InternalProblem.g:5215:2: ( ruleIdentifier ) |
13433 | { | 16390 | { |
13434 | // InternalProblem.g:4282:2: ( ruleIdentifier ) | 16391 | // InternalProblem.g:5215:2: ( ruleIdentifier ) |
13435 | // InternalProblem.g:4283:3: ruleIdentifier | 16392 | // InternalProblem.g:5216:3: ruleIdentifier |
13436 | { | 16393 | { |
13437 | before(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); | 16394 | before(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); |
13438 | pushFollow(FOLLOW_2); | 16395 | pushFollow(FOLLOW_2); |
@@ -13463,21 +16420,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13463 | 16420 | ||
13464 | 16421 | ||
13465 | // $ANTLR start "rule__ClassDeclaration__SuperTypesAssignment_3_1" | 16422 | // $ANTLR start "rule__ClassDeclaration__SuperTypesAssignment_3_1" |
13466 | // InternalProblem.g:4292:1: rule__ClassDeclaration__SuperTypesAssignment_3_1 : ( ( ruleQualifiedName ) ) ; | 16423 | // InternalProblem.g:5225:1: rule__ClassDeclaration__SuperTypesAssignment_3_1 : ( ( ruleQualifiedName ) ) ; |
13467 | public final void rule__ClassDeclaration__SuperTypesAssignment_3_1() throws RecognitionException { | 16424 | public final void rule__ClassDeclaration__SuperTypesAssignment_3_1() throws RecognitionException { |
13468 | 16425 | ||
13469 | int stackSize = keepStackSize(); | 16426 | int stackSize = keepStackSize(); |
13470 | 16427 | ||
13471 | try { | 16428 | try { |
13472 | // InternalProblem.g:4296:1: ( ( ( ruleQualifiedName ) ) ) | 16429 | // InternalProblem.g:5229:1: ( ( ( ruleQualifiedName ) ) ) |
13473 | // InternalProblem.g:4297:2: ( ( ruleQualifiedName ) ) | 16430 | // InternalProblem.g:5230:2: ( ( ruleQualifiedName ) ) |
13474 | { | 16431 | { |
13475 | // InternalProblem.g:4297:2: ( ( ruleQualifiedName ) ) | 16432 | // InternalProblem.g:5230:2: ( ( ruleQualifiedName ) ) |
13476 | // InternalProblem.g:4298:3: ( ruleQualifiedName ) | 16433 | // InternalProblem.g:5231:3: ( ruleQualifiedName ) |
13477 | { | 16434 | { |
13478 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_1_0()); | 16435 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_1_0()); |
13479 | // InternalProblem.g:4299:3: ( ruleQualifiedName ) | 16436 | // InternalProblem.g:5232:3: ( ruleQualifiedName ) |
13480 | // InternalProblem.g:4300:4: ruleQualifiedName | 16437 | // InternalProblem.g:5233:4: ruleQualifiedName |
13481 | { | 16438 | { |
13482 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1()); | 16439 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1()); |
13483 | pushFollow(FOLLOW_2); | 16440 | pushFollow(FOLLOW_2); |
@@ -13512,21 +16469,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13512 | 16469 | ||
13513 | 16470 | ||
13514 | // $ANTLR start "rule__ClassDeclaration__SuperTypesAssignment_3_2_1" | 16471 | // $ANTLR start "rule__ClassDeclaration__SuperTypesAssignment_3_2_1" |
13515 | // InternalProblem.g:4311:1: rule__ClassDeclaration__SuperTypesAssignment_3_2_1 : ( ( ruleQualifiedName ) ) ; | 16472 | // InternalProblem.g:5244:1: rule__ClassDeclaration__SuperTypesAssignment_3_2_1 : ( ( ruleQualifiedName ) ) ; |
13516 | public final void rule__ClassDeclaration__SuperTypesAssignment_3_2_1() throws RecognitionException { | 16473 | public final void rule__ClassDeclaration__SuperTypesAssignment_3_2_1() throws RecognitionException { |
13517 | 16474 | ||
13518 | int stackSize = keepStackSize(); | 16475 | int stackSize = keepStackSize(); |
13519 | 16476 | ||
13520 | try { | 16477 | try { |
13521 | // InternalProblem.g:4315:1: ( ( ( ruleQualifiedName ) ) ) | 16478 | // InternalProblem.g:5248:1: ( ( ( ruleQualifiedName ) ) ) |
13522 | // InternalProblem.g:4316:2: ( ( ruleQualifiedName ) ) | 16479 | // InternalProblem.g:5249:2: ( ( ruleQualifiedName ) ) |
13523 | { | 16480 | { |
13524 | // InternalProblem.g:4316:2: ( ( ruleQualifiedName ) ) | 16481 | // InternalProblem.g:5249:2: ( ( ruleQualifiedName ) ) |
13525 | // InternalProblem.g:4317:3: ( ruleQualifiedName ) | 16482 | // InternalProblem.g:5250:3: ( ruleQualifiedName ) |
13526 | { | 16483 | { |
13527 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_2_1_0()); | 16484 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_2_1_0()); |
13528 | // InternalProblem.g:4318:3: ( ruleQualifiedName ) | 16485 | // InternalProblem.g:5251:3: ( ruleQualifiedName ) |
13529 | // InternalProblem.g:4319:4: ruleQualifiedName | 16486 | // InternalProblem.g:5252:4: ruleQualifiedName |
13530 | { | 16487 | { |
13531 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1()); | 16488 | before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1()); |
13532 | pushFollow(FOLLOW_2); | 16489 | pushFollow(FOLLOW_2); |
@@ -13561,17 +16518,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13561 | 16518 | ||
13562 | 16519 | ||
13563 | // $ANTLR start "rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0" | 16520 | // $ANTLR start "rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0" |
13564 | // InternalProblem.g:4330:1: rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 : ( ruleReferenceDeclaration ) ; | 16521 | // InternalProblem.g:5263:1: rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 : ( ruleReferenceDeclaration ) ; |
13565 | public final void rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0() throws RecognitionException { | 16522 | public final void rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0() throws RecognitionException { |
13566 | 16523 | ||
13567 | int stackSize = keepStackSize(); | 16524 | int stackSize = keepStackSize(); |
13568 | 16525 | ||
13569 | try { | 16526 | try { |
13570 | // InternalProblem.g:4334:1: ( ( ruleReferenceDeclaration ) ) | 16527 | // InternalProblem.g:5267:1: ( ( ruleReferenceDeclaration ) ) |
13571 | // InternalProblem.g:4335:2: ( ruleReferenceDeclaration ) | 16528 | // InternalProblem.g:5268:2: ( ruleReferenceDeclaration ) |
13572 | { | 16529 | { |
13573 | // InternalProblem.g:4335:2: ( ruleReferenceDeclaration ) | 16530 | // InternalProblem.g:5268:2: ( ruleReferenceDeclaration ) |
13574 | // InternalProblem.g:4336:3: ruleReferenceDeclaration | 16531 | // InternalProblem.g:5269:3: ruleReferenceDeclaration |
13575 | { | 16532 | { |
13576 | before(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); | 16533 | before(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); |
13577 | pushFollow(FOLLOW_2); | 16534 | pushFollow(FOLLOW_2); |
@@ -13602,17 +16559,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13602 | 16559 | ||
13603 | 16560 | ||
13604 | // $ANTLR start "rule__EnumDeclaration__NameAssignment_1" | 16561 | // $ANTLR start "rule__EnumDeclaration__NameAssignment_1" |
13605 | // InternalProblem.g:4345:1: rule__EnumDeclaration__NameAssignment_1 : ( ruleIdentifier ) ; | 16562 | // InternalProblem.g:5278:1: rule__EnumDeclaration__NameAssignment_1 : ( ruleIdentifier ) ; |
13606 | public final void rule__EnumDeclaration__NameAssignment_1() throws RecognitionException { | 16563 | public final void rule__EnumDeclaration__NameAssignment_1() throws RecognitionException { |
13607 | 16564 | ||
13608 | int stackSize = keepStackSize(); | 16565 | int stackSize = keepStackSize(); |
13609 | 16566 | ||
13610 | try { | 16567 | try { |
13611 | // InternalProblem.g:4349:1: ( ( ruleIdentifier ) ) | 16568 | // InternalProblem.g:5282:1: ( ( ruleIdentifier ) ) |
13612 | // InternalProblem.g:4350:2: ( ruleIdentifier ) | 16569 | // InternalProblem.g:5283:2: ( ruleIdentifier ) |
13613 | { | 16570 | { |
13614 | // InternalProblem.g:4350:2: ( ruleIdentifier ) | 16571 | // InternalProblem.g:5283:2: ( ruleIdentifier ) |
13615 | // InternalProblem.g:4351:3: ruleIdentifier | 16572 | // InternalProblem.g:5284:3: ruleIdentifier |
13616 | { | 16573 | { |
13617 | before(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); | 16574 | before(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); |
13618 | pushFollow(FOLLOW_2); | 16575 | pushFollow(FOLLOW_2); |
@@ -13643,17 +16600,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13643 | 16600 | ||
13644 | 16601 | ||
13645 | // $ANTLR start "rule__EnumDeclaration__LiteralsAssignment_2_0_1_0" | 16602 | // $ANTLR start "rule__EnumDeclaration__LiteralsAssignment_2_0_1_0" |
13646 | // InternalProblem.g:4360:1: rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 : ( ruleEnumLiteral ) ; | 16603 | // InternalProblem.g:5293:1: rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 : ( ruleEnumLiteral ) ; |
13647 | public final void rule__EnumDeclaration__LiteralsAssignment_2_0_1_0() throws RecognitionException { | 16604 | public final void rule__EnumDeclaration__LiteralsAssignment_2_0_1_0() throws RecognitionException { |
13648 | 16605 | ||
13649 | int stackSize = keepStackSize(); | 16606 | int stackSize = keepStackSize(); |
13650 | 16607 | ||
13651 | try { | 16608 | try { |
13652 | // InternalProblem.g:4364:1: ( ( ruleEnumLiteral ) ) | 16609 | // InternalProblem.g:5297:1: ( ( ruleEnumLiteral ) ) |
13653 | // InternalProblem.g:4365:2: ( ruleEnumLiteral ) | 16610 | // InternalProblem.g:5298:2: ( ruleEnumLiteral ) |
13654 | { | 16611 | { |
13655 | // InternalProblem.g:4365:2: ( ruleEnumLiteral ) | 16612 | // InternalProblem.g:5298:2: ( ruleEnumLiteral ) |
13656 | // InternalProblem.g:4366:3: ruleEnumLiteral | 16613 | // InternalProblem.g:5299:3: ruleEnumLiteral |
13657 | { | 16614 | { |
13658 | before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); | 16615 | before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); |
13659 | pushFollow(FOLLOW_2); | 16616 | pushFollow(FOLLOW_2); |
@@ -13684,17 +16641,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13684 | 16641 | ||
13685 | 16642 | ||
13686 | // $ANTLR start "rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1" | 16643 | // $ANTLR start "rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1" |
13687 | // InternalProblem.g:4375:1: rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 : ( ruleEnumLiteral ) ; | 16644 | // InternalProblem.g:5308:1: rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 : ( ruleEnumLiteral ) ; |
13688 | public final void rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1() throws RecognitionException { | 16645 | public final void rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1() throws RecognitionException { |
13689 | 16646 | ||
13690 | int stackSize = keepStackSize(); | 16647 | int stackSize = keepStackSize(); |
13691 | 16648 | ||
13692 | try { | 16649 | try { |
13693 | // InternalProblem.g:4379:1: ( ( ruleEnumLiteral ) ) | 16650 | // InternalProblem.g:5312:1: ( ( ruleEnumLiteral ) ) |
13694 | // InternalProblem.g:4380:2: ( ruleEnumLiteral ) | 16651 | // InternalProblem.g:5313:2: ( ruleEnumLiteral ) |
13695 | { | 16652 | { |
13696 | // InternalProblem.g:4380:2: ( ruleEnumLiteral ) | 16653 | // InternalProblem.g:5313:2: ( ruleEnumLiteral ) |
13697 | // InternalProblem.g:4381:3: ruleEnumLiteral | 16654 | // InternalProblem.g:5314:3: ruleEnumLiteral |
13698 | { | 16655 | { |
13699 | before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); | 16656 | before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); |
13700 | pushFollow(FOLLOW_2); | 16657 | pushFollow(FOLLOW_2); |
@@ -13725,17 +16682,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13725 | 16682 | ||
13726 | 16683 | ||
13727 | // $ANTLR start "rule__EnumLiteral__NameAssignment" | 16684 | // $ANTLR start "rule__EnumLiteral__NameAssignment" |
13728 | // InternalProblem.g:4390:1: rule__EnumLiteral__NameAssignment : ( ruleQuotedOrUnquotedId ) ; | 16685 | // InternalProblem.g:5323:1: rule__EnumLiteral__NameAssignment : ( ruleQuotedOrUnquotedId ) ; |
13729 | public final void rule__EnumLiteral__NameAssignment() throws RecognitionException { | 16686 | public final void rule__EnumLiteral__NameAssignment() throws RecognitionException { |
13730 | 16687 | ||
13731 | int stackSize = keepStackSize(); | 16688 | int stackSize = keepStackSize(); |
13732 | 16689 | ||
13733 | try { | 16690 | try { |
13734 | // InternalProblem.g:4394:1: ( ( ruleQuotedOrUnquotedId ) ) | 16691 | // InternalProblem.g:5327:1: ( ( ruleQuotedOrUnquotedId ) ) |
13735 | // InternalProblem.g:4395:2: ( ruleQuotedOrUnquotedId ) | 16692 | // InternalProblem.g:5328:2: ( ruleQuotedOrUnquotedId ) |
13736 | { | 16693 | { |
13737 | // InternalProblem.g:4395:2: ( ruleQuotedOrUnquotedId ) | 16694 | // InternalProblem.g:5328:2: ( ruleQuotedOrUnquotedId ) |
13738 | // InternalProblem.g:4396:3: ruleQuotedOrUnquotedId | 16695 | // InternalProblem.g:5329:3: ruleQuotedOrUnquotedId |
13739 | { | 16696 | { |
13740 | before(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0()); | 16697 | before(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0()); |
13741 | pushFollow(FOLLOW_2); | 16698 | pushFollow(FOLLOW_2); |
@@ -13766,24 +16723,24 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13766 | 16723 | ||
13767 | 16724 | ||
13768 | // $ANTLR start "rule__ReferenceDeclaration__ContainmentAssignment_0_0" | 16725 | // $ANTLR start "rule__ReferenceDeclaration__ContainmentAssignment_0_0" |
13769 | // InternalProblem.g:4405:1: rule__ReferenceDeclaration__ContainmentAssignment_0_0 : ( ( 'contains' ) ) ; | 16726 | // InternalProblem.g:5338:1: rule__ReferenceDeclaration__ContainmentAssignment_0_0 : ( ( 'contains' ) ) ; |
13770 | public final void rule__ReferenceDeclaration__ContainmentAssignment_0_0() throws RecognitionException { | 16727 | public final void rule__ReferenceDeclaration__ContainmentAssignment_0_0() throws RecognitionException { |
13771 | 16728 | ||
13772 | int stackSize = keepStackSize(); | 16729 | int stackSize = keepStackSize(); |
13773 | 16730 | ||
13774 | try { | 16731 | try { |
13775 | // InternalProblem.g:4409:1: ( ( ( 'contains' ) ) ) | 16732 | // InternalProblem.g:5342:1: ( ( ( 'contains' ) ) ) |
13776 | // InternalProblem.g:4410:2: ( ( 'contains' ) ) | 16733 | // InternalProblem.g:5343:2: ( ( 'contains' ) ) |
13777 | { | 16734 | { |
13778 | // InternalProblem.g:4410:2: ( ( 'contains' ) ) | 16735 | // InternalProblem.g:5343:2: ( ( 'contains' ) ) |
13779 | // InternalProblem.g:4411:3: ( 'contains' ) | 16736 | // InternalProblem.g:5344:3: ( 'contains' ) |
13780 | { | 16737 | { |
13781 | before(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); | 16738 | before(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); |
13782 | // InternalProblem.g:4412:3: ( 'contains' ) | 16739 | // InternalProblem.g:5345:3: ( 'contains' ) |
13783 | // InternalProblem.g:4413:4: 'contains' | 16740 | // InternalProblem.g:5346:4: 'contains' |
13784 | { | 16741 | { |
13785 | before(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); | 16742 | before(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); |
13786 | match(input,41,FOLLOW_2); | 16743 | match(input,45,FOLLOW_2); |
13787 | after(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); | 16744 | after(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); |
13788 | 16745 | ||
13789 | } | 16746 | } |
@@ -13811,21 +16768,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13811 | 16768 | ||
13812 | 16769 | ||
13813 | // $ANTLR start "rule__ReferenceDeclaration__ReferenceTypeAssignment_1" | 16770 | // $ANTLR start "rule__ReferenceDeclaration__ReferenceTypeAssignment_1" |
13814 | // InternalProblem.g:4424:1: rule__ReferenceDeclaration__ReferenceTypeAssignment_1 : ( ( ruleQualifiedName ) ) ; | 16771 | // InternalProblem.g:5357:1: rule__ReferenceDeclaration__ReferenceTypeAssignment_1 : ( ( ruleQualifiedName ) ) ; |
13815 | public final void rule__ReferenceDeclaration__ReferenceTypeAssignment_1() throws RecognitionException { | 16772 | public final void rule__ReferenceDeclaration__ReferenceTypeAssignment_1() throws RecognitionException { |
13816 | 16773 | ||
13817 | int stackSize = keepStackSize(); | 16774 | int stackSize = keepStackSize(); |
13818 | 16775 | ||
13819 | try { | 16776 | try { |
13820 | // InternalProblem.g:4428:1: ( ( ( ruleQualifiedName ) ) ) | 16777 | // InternalProblem.g:5361:1: ( ( ( ruleQualifiedName ) ) ) |
13821 | // InternalProblem.g:4429:2: ( ( ruleQualifiedName ) ) | 16778 | // InternalProblem.g:5362:2: ( ( ruleQualifiedName ) ) |
13822 | { | 16779 | { |
13823 | // InternalProblem.g:4429:2: ( ( ruleQualifiedName ) ) | 16780 | // InternalProblem.g:5362:2: ( ( ruleQualifiedName ) ) |
13824 | // InternalProblem.g:4430:3: ( ruleQualifiedName ) | 16781 | // InternalProblem.g:5363:3: ( ruleQualifiedName ) |
13825 | { | 16782 | { |
13826 | before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationCrossReference_1_0()); | 16783 | before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationCrossReference_1_0()); |
13827 | // InternalProblem.g:4431:3: ( ruleQualifiedName ) | 16784 | // InternalProblem.g:5364:3: ( ruleQualifiedName ) |
13828 | // InternalProblem.g:4432:4: ruleQualifiedName | 16785 | // InternalProblem.g:5365:4: ruleQualifiedName |
13829 | { | 16786 | { |
13830 | before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1()); | 16787 | before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1()); |
13831 | pushFollow(FOLLOW_2); | 16788 | pushFollow(FOLLOW_2); |
@@ -13860,17 +16817,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13860 | 16817 | ||
13861 | 16818 | ||
13862 | // $ANTLR start "rule__ReferenceDeclaration__MultiplicityAssignment_2_1" | 16819 | // $ANTLR start "rule__ReferenceDeclaration__MultiplicityAssignment_2_1" |
13863 | // InternalProblem.g:4443:1: rule__ReferenceDeclaration__MultiplicityAssignment_2_1 : ( ruleMultiplicity ) ; | 16820 | // InternalProblem.g:5376:1: rule__ReferenceDeclaration__MultiplicityAssignment_2_1 : ( ruleMultiplicity ) ; |
13864 | public final void rule__ReferenceDeclaration__MultiplicityAssignment_2_1() throws RecognitionException { | 16821 | public final void rule__ReferenceDeclaration__MultiplicityAssignment_2_1() throws RecognitionException { |
13865 | 16822 | ||
13866 | int stackSize = keepStackSize(); | 16823 | int stackSize = keepStackSize(); |
13867 | 16824 | ||
13868 | try { | 16825 | try { |
13869 | // InternalProblem.g:4447:1: ( ( ruleMultiplicity ) ) | 16826 | // InternalProblem.g:5380:1: ( ( ruleMultiplicity ) ) |
13870 | // InternalProblem.g:4448:2: ( ruleMultiplicity ) | 16827 | // InternalProblem.g:5381:2: ( ruleMultiplicity ) |
13871 | { | 16828 | { |
13872 | // InternalProblem.g:4448:2: ( ruleMultiplicity ) | 16829 | // InternalProblem.g:5381:2: ( ruleMultiplicity ) |
13873 | // InternalProblem.g:4449:3: ruleMultiplicity | 16830 | // InternalProblem.g:5382:3: ruleMultiplicity |
13874 | { | 16831 | { |
13875 | before(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); | 16832 | before(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); |
13876 | pushFollow(FOLLOW_2); | 16833 | pushFollow(FOLLOW_2); |
@@ -13901,17 +16858,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13901 | 16858 | ||
13902 | 16859 | ||
13903 | // $ANTLR start "rule__ReferenceDeclaration__NameAssignment_3" | 16860 | // $ANTLR start "rule__ReferenceDeclaration__NameAssignment_3" |
13904 | // InternalProblem.g:4458:1: rule__ReferenceDeclaration__NameAssignment_3 : ( ruleIdentifier ) ; | 16861 | // InternalProblem.g:5391:1: rule__ReferenceDeclaration__NameAssignment_3 : ( ruleIdentifier ) ; |
13905 | public final void rule__ReferenceDeclaration__NameAssignment_3() throws RecognitionException { | 16862 | public final void rule__ReferenceDeclaration__NameAssignment_3() throws RecognitionException { |
13906 | 16863 | ||
13907 | int stackSize = keepStackSize(); | 16864 | int stackSize = keepStackSize(); |
13908 | 16865 | ||
13909 | try { | 16866 | try { |
13910 | // InternalProblem.g:4462:1: ( ( ruleIdentifier ) ) | 16867 | // InternalProblem.g:5395:1: ( ( ruleIdentifier ) ) |
13911 | // InternalProblem.g:4463:2: ( ruleIdentifier ) | 16868 | // InternalProblem.g:5396:2: ( ruleIdentifier ) |
13912 | { | 16869 | { |
13913 | // InternalProblem.g:4463:2: ( ruleIdentifier ) | 16870 | // InternalProblem.g:5396:2: ( ruleIdentifier ) |
13914 | // InternalProblem.g:4464:3: ruleIdentifier | 16871 | // InternalProblem.g:5397:3: ruleIdentifier |
13915 | { | 16872 | { |
13916 | before(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); | 16873 | before(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); |
13917 | pushFollow(FOLLOW_2); | 16874 | pushFollow(FOLLOW_2); |
@@ -13942,21 +16899,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13942 | 16899 | ||
13943 | 16900 | ||
13944 | // $ANTLR start "rule__ReferenceDeclaration__OppositeAssignment_4_1" | 16901 | // $ANTLR start "rule__ReferenceDeclaration__OppositeAssignment_4_1" |
13945 | // InternalProblem.g:4473:1: rule__ReferenceDeclaration__OppositeAssignment_4_1 : ( ( ruleQualifiedName ) ) ; | 16902 | // InternalProblem.g:5406:1: rule__ReferenceDeclaration__OppositeAssignment_4_1 : ( ( ruleQualifiedName ) ) ; |
13946 | public final void rule__ReferenceDeclaration__OppositeAssignment_4_1() throws RecognitionException { | 16903 | public final void rule__ReferenceDeclaration__OppositeAssignment_4_1() throws RecognitionException { |
13947 | 16904 | ||
13948 | int stackSize = keepStackSize(); | 16905 | int stackSize = keepStackSize(); |
13949 | 16906 | ||
13950 | try { | 16907 | try { |
13951 | // InternalProblem.g:4477:1: ( ( ( ruleQualifiedName ) ) ) | 16908 | // InternalProblem.g:5410:1: ( ( ( ruleQualifiedName ) ) ) |
13952 | // InternalProblem.g:4478:2: ( ( ruleQualifiedName ) ) | 16909 | // InternalProblem.g:5411:2: ( ( ruleQualifiedName ) ) |
13953 | { | 16910 | { |
13954 | // InternalProblem.g:4478:2: ( ( ruleQualifiedName ) ) | 16911 | // InternalProblem.g:5411:2: ( ( ruleQualifiedName ) ) |
13955 | // InternalProblem.g:4479:3: ( ruleQualifiedName ) | 16912 | // InternalProblem.g:5412:3: ( ruleQualifiedName ) |
13956 | { | 16913 | { |
13957 | before(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationCrossReference_4_1_0()); | 16914 | before(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationCrossReference_4_1_0()); |
13958 | // InternalProblem.g:4480:3: ( ruleQualifiedName ) | 16915 | // InternalProblem.g:5413:3: ( ruleQualifiedName ) |
13959 | // InternalProblem.g:4481:4: ruleQualifiedName | 16916 | // InternalProblem.g:5414:4: ruleQualifiedName |
13960 | { | 16917 | { |
13961 | before(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1()); | 16918 | before(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1()); |
13962 | pushFollow(FOLLOW_2); | 16919 | pushFollow(FOLLOW_2); |
@@ -13991,24 +16948,24 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
13991 | 16948 | ||
13992 | 16949 | ||
13993 | // $ANTLR start "rule__PredicateDefinition__ErrorAssignment_0_0_0" | 16950 | // $ANTLR start "rule__PredicateDefinition__ErrorAssignment_0_0_0" |
13994 | // InternalProblem.g:4492:1: rule__PredicateDefinition__ErrorAssignment_0_0_0 : ( ( 'error' ) ) ; | 16951 | // InternalProblem.g:5425:1: rule__PredicateDefinition__ErrorAssignment_0_0_0 : ( ( 'error' ) ) ; |
13995 | public final void rule__PredicateDefinition__ErrorAssignment_0_0_0() throws RecognitionException { | 16952 | public final void rule__PredicateDefinition__ErrorAssignment_0_0_0() throws RecognitionException { |
13996 | 16953 | ||
13997 | int stackSize = keepStackSize(); | 16954 | int stackSize = keepStackSize(); |
13998 | 16955 | ||
13999 | try { | 16956 | try { |
14000 | // InternalProblem.g:4496:1: ( ( ( 'error' ) ) ) | 16957 | // InternalProblem.g:5429:1: ( ( ( 'error' ) ) ) |
14001 | // InternalProblem.g:4497:2: ( ( 'error' ) ) | 16958 | // InternalProblem.g:5430:2: ( ( 'error' ) ) |
14002 | { | 16959 | { |
14003 | // InternalProblem.g:4497:2: ( ( 'error' ) ) | 16960 | // InternalProblem.g:5430:2: ( ( 'error' ) ) |
14004 | // InternalProblem.g:4498:3: ( 'error' ) | 16961 | // InternalProblem.g:5431:3: ( 'error' ) |
14005 | { | 16962 | { |
14006 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); | 16963 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); |
14007 | // InternalProblem.g:4499:3: ( 'error' ) | 16964 | // InternalProblem.g:5432:3: ( 'error' ) |
14008 | // InternalProblem.g:4500:4: 'error' | 16965 | // InternalProblem.g:5433:4: 'error' |
14009 | { | 16966 | { |
14010 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); | 16967 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); |
14011 | match(input,42,FOLLOW_2); | 16968 | match(input,46,FOLLOW_2); |
14012 | after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); | 16969 | after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); |
14013 | 16970 | ||
14014 | } | 16971 | } |
@@ -14036,17 +16993,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14036 | 16993 | ||
14037 | 16994 | ||
14038 | // $ANTLR start "rule__PredicateDefinition__NameAssignment_1" | 16995 | // $ANTLR start "rule__PredicateDefinition__NameAssignment_1" |
14039 | // InternalProblem.g:4511:1: rule__PredicateDefinition__NameAssignment_1 : ( ruleIdentifier ) ; | 16996 | // InternalProblem.g:5444:1: rule__PredicateDefinition__NameAssignment_1 : ( ruleIdentifier ) ; |
14040 | public final void rule__PredicateDefinition__NameAssignment_1() throws RecognitionException { | 16997 | public final void rule__PredicateDefinition__NameAssignment_1() throws RecognitionException { |
14041 | 16998 | ||
14042 | int stackSize = keepStackSize(); | 16999 | int stackSize = keepStackSize(); |
14043 | 17000 | ||
14044 | try { | 17001 | try { |
14045 | // InternalProblem.g:4515:1: ( ( ruleIdentifier ) ) | 17002 | // InternalProblem.g:5448:1: ( ( ruleIdentifier ) ) |
14046 | // InternalProblem.g:4516:2: ( ruleIdentifier ) | 17003 | // InternalProblem.g:5449:2: ( ruleIdentifier ) |
14047 | { | 17004 | { |
14048 | // InternalProblem.g:4516:2: ( ruleIdentifier ) | 17005 | // InternalProblem.g:5449:2: ( ruleIdentifier ) |
14049 | // InternalProblem.g:4517:3: ruleIdentifier | 17006 | // InternalProblem.g:5450:3: ruleIdentifier |
14050 | { | 17007 | { |
14051 | before(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); | 17008 | before(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); |
14052 | pushFollow(FOLLOW_2); | 17009 | pushFollow(FOLLOW_2); |
@@ -14077,17 +17034,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14077 | 17034 | ||
14078 | 17035 | ||
14079 | // $ANTLR start "rule__PredicateDefinition__ParametersAssignment_3_0" | 17036 | // $ANTLR start "rule__PredicateDefinition__ParametersAssignment_3_0" |
14080 | // InternalProblem.g:4526:1: rule__PredicateDefinition__ParametersAssignment_3_0 : ( ruleParameter ) ; | 17037 | // InternalProblem.g:5459:1: rule__PredicateDefinition__ParametersAssignment_3_0 : ( ruleParameter ) ; |
14081 | public final void rule__PredicateDefinition__ParametersAssignment_3_0() throws RecognitionException { | 17038 | public final void rule__PredicateDefinition__ParametersAssignment_3_0() throws RecognitionException { |
14082 | 17039 | ||
14083 | int stackSize = keepStackSize(); | 17040 | int stackSize = keepStackSize(); |
14084 | 17041 | ||
14085 | try { | 17042 | try { |
14086 | // InternalProblem.g:4530:1: ( ( ruleParameter ) ) | 17043 | // InternalProblem.g:5463:1: ( ( ruleParameter ) ) |
14087 | // InternalProblem.g:4531:2: ( ruleParameter ) | 17044 | // InternalProblem.g:5464:2: ( ruleParameter ) |
14088 | { | 17045 | { |
14089 | // InternalProblem.g:4531:2: ( ruleParameter ) | 17046 | // InternalProblem.g:5464:2: ( ruleParameter ) |
14090 | // InternalProblem.g:4532:3: ruleParameter | 17047 | // InternalProblem.g:5465:3: ruleParameter |
14091 | { | 17048 | { |
14092 | before(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); | 17049 | before(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); |
14093 | pushFollow(FOLLOW_2); | 17050 | pushFollow(FOLLOW_2); |
@@ -14118,17 +17075,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14118 | 17075 | ||
14119 | 17076 | ||
14120 | // $ANTLR start "rule__PredicateDefinition__ParametersAssignment_3_1_1" | 17077 | // $ANTLR start "rule__PredicateDefinition__ParametersAssignment_3_1_1" |
14121 | // InternalProblem.g:4541:1: rule__PredicateDefinition__ParametersAssignment_3_1_1 : ( ruleParameter ) ; | 17078 | // InternalProblem.g:5474:1: rule__PredicateDefinition__ParametersAssignment_3_1_1 : ( ruleParameter ) ; |
14122 | public final void rule__PredicateDefinition__ParametersAssignment_3_1_1() throws RecognitionException { | 17079 | public final void rule__PredicateDefinition__ParametersAssignment_3_1_1() throws RecognitionException { |
14123 | 17080 | ||
14124 | int stackSize = keepStackSize(); | 17081 | int stackSize = keepStackSize(); |
14125 | 17082 | ||
14126 | try { | 17083 | try { |
14127 | // InternalProblem.g:4545:1: ( ( ruleParameter ) ) | 17084 | // InternalProblem.g:5478:1: ( ( ruleParameter ) ) |
14128 | // InternalProblem.g:4546:2: ( ruleParameter ) | 17085 | // InternalProblem.g:5479:2: ( ruleParameter ) |
14129 | { | 17086 | { |
14130 | // InternalProblem.g:4546:2: ( ruleParameter ) | 17087 | // InternalProblem.g:5479:2: ( ruleParameter ) |
14131 | // InternalProblem.g:4547:3: ruleParameter | 17088 | // InternalProblem.g:5480:3: ruleParameter |
14132 | { | 17089 | { |
14133 | before(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); | 17090 | before(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); |
14134 | pushFollow(FOLLOW_2); | 17091 | pushFollow(FOLLOW_2); |
@@ -14159,17 +17116,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14159 | 17116 | ||
14160 | 17117 | ||
14161 | // $ANTLR start "rule__PredicateDefinition__BodiesAssignment_5_1" | 17118 | // $ANTLR start "rule__PredicateDefinition__BodiesAssignment_5_1" |
14162 | // InternalProblem.g:4556:1: rule__PredicateDefinition__BodiesAssignment_5_1 : ( ruleConjunction ) ; | 17119 | // InternalProblem.g:5489:1: rule__PredicateDefinition__BodiesAssignment_5_1 : ( ruleConjunction ) ; |
14163 | public final void rule__PredicateDefinition__BodiesAssignment_5_1() throws RecognitionException { | 17120 | public final void rule__PredicateDefinition__BodiesAssignment_5_1() throws RecognitionException { |
14164 | 17121 | ||
14165 | int stackSize = keepStackSize(); | 17122 | int stackSize = keepStackSize(); |
14166 | 17123 | ||
14167 | try { | 17124 | try { |
14168 | // InternalProblem.g:4560:1: ( ( ruleConjunction ) ) | 17125 | // InternalProblem.g:5493:1: ( ( ruleConjunction ) ) |
14169 | // InternalProblem.g:4561:2: ( ruleConjunction ) | 17126 | // InternalProblem.g:5494:2: ( ruleConjunction ) |
14170 | { | 17127 | { |
14171 | // InternalProblem.g:4561:2: ( ruleConjunction ) | 17128 | // InternalProblem.g:5494:2: ( ruleConjunction ) |
14172 | // InternalProblem.g:4562:3: ruleConjunction | 17129 | // InternalProblem.g:5495:3: ruleConjunction |
14173 | { | 17130 | { |
14174 | before(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); | 17131 | before(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); |
14175 | pushFollow(FOLLOW_2); | 17132 | pushFollow(FOLLOW_2); |
@@ -14200,17 +17157,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14200 | 17157 | ||
14201 | 17158 | ||
14202 | // $ANTLR start "rule__PredicateDefinition__BodiesAssignment_5_2_1" | 17159 | // $ANTLR start "rule__PredicateDefinition__BodiesAssignment_5_2_1" |
14203 | // InternalProblem.g:4571:1: rule__PredicateDefinition__BodiesAssignment_5_2_1 : ( ruleConjunction ) ; | 17160 | // InternalProblem.g:5504:1: rule__PredicateDefinition__BodiesAssignment_5_2_1 : ( ruleConjunction ) ; |
14204 | public final void rule__PredicateDefinition__BodiesAssignment_5_2_1() throws RecognitionException { | 17161 | public final void rule__PredicateDefinition__BodiesAssignment_5_2_1() throws RecognitionException { |
14205 | 17162 | ||
14206 | int stackSize = keepStackSize(); | 17163 | int stackSize = keepStackSize(); |
14207 | 17164 | ||
14208 | try { | 17165 | try { |
14209 | // InternalProblem.g:4575:1: ( ( ruleConjunction ) ) | 17166 | // InternalProblem.g:5508:1: ( ( ruleConjunction ) ) |
14210 | // InternalProblem.g:4576:2: ( ruleConjunction ) | 17167 | // InternalProblem.g:5509:2: ( ruleConjunction ) |
14211 | { | 17168 | { |
14212 | // InternalProblem.g:4576:2: ( ruleConjunction ) | 17169 | // InternalProblem.g:5509:2: ( ruleConjunction ) |
14213 | // InternalProblem.g:4577:3: ruleConjunction | 17170 | // InternalProblem.g:5510:3: ruleConjunction |
14214 | { | 17171 | { |
14215 | before(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); | 17172 | before(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); |
14216 | pushFollow(FOLLOW_2); | 17173 | pushFollow(FOLLOW_2); |
@@ -14241,21 +17198,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14241 | 17198 | ||
14242 | 17199 | ||
14243 | // $ANTLR start "rule__Parameter__ParameterTypeAssignment_0" | 17200 | // $ANTLR start "rule__Parameter__ParameterTypeAssignment_0" |
14244 | // InternalProblem.g:4586:1: rule__Parameter__ParameterTypeAssignment_0 : ( ( ruleQualifiedName ) ) ; | 17201 | // InternalProblem.g:5519:1: rule__Parameter__ParameterTypeAssignment_0 : ( ( ruleQualifiedName ) ) ; |
14245 | public final void rule__Parameter__ParameterTypeAssignment_0() throws RecognitionException { | 17202 | public final void rule__Parameter__ParameterTypeAssignment_0() throws RecognitionException { |
14246 | 17203 | ||
14247 | int stackSize = keepStackSize(); | 17204 | int stackSize = keepStackSize(); |
14248 | 17205 | ||
14249 | try { | 17206 | try { |
14250 | // InternalProblem.g:4590:1: ( ( ( ruleQualifiedName ) ) ) | 17207 | // InternalProblem.g:5523:1: ( ( ( ruleQualifiedName ) ) ) |
14251 | // InternalProblem.g:4591:2: ( ( ruleQualifiedName ) ) | 17208 | // InternalProblem.g:5524:2: ( ( ruleQualifiedName ) ) |
14252 | { | 17209 | { |
14253 | // InternalProblem.g:4591:2: ( ( ruleQualifiedName ) ) | 17210 | // InternalProblem.g:5524:2: ( ( ruleQualifiedName ) ) |
14254 | // InternalProblem.g:4592:3: ( ruleQualifiedName ) | 17211 | // InternalProblem.g:5525:3: ( ruleQualifiedName ) |
14255 | { | 17212 | { |
14256 | before(grammarAccess.getParameterAccess().getParameterTypeRelationCrossReference_0_0()); | 17213 | before(grammarAccess.getParameterAccess().getParameterTypeRelationCrossReference_0_0()); |
14257 | // InternalProblem.g:4593:3: ( ruleQualifiedName ) | 17214 | // InternalProblem.g:5526:3: ( ruleQualifiedName ) |
14258 | // InternalProblem.g:4594:4: ruleQualifiedName | 17215 | // InternalProblem.g:5527:4: ruleQualifiedName |
14259 | { | 17216 | { |
14260 | before(grammarAccess.getParameterAccess().getParameterTypeRelationQualifiedNameParserRuleCall_0_0_1()); | 17217 | before(grammarAccess.getParameterAccess().getParameterTypeRelationQualifiedNameParserRuleCall_0_0_1()); |
14261 | pushFollow(FOLLOW_2); | 17218 | pushFollow(FOLLOW_2); |
@@ -14290,17 +17247,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14290 | 17247 | ||
14291 | 17248 | ||
14292 | // $ANTLR start "rule__Parameter__NameAssignment_1" | 17249 | // $ANTLR start "rule__Parameter__NameAssignment_1" |
14293 | // InternalProblem.g:4605:1: rule__Parameter__NameAssignment_1 : ( ruleIdentifier ) ; | 17250 | // InternalProblem.g:5538:1: rule__Parameter__NameAssignment_1 : ( ruleIdentifier ) ; |
14294 | public final void rule__Parameter__NameAssignment_1() throws RecognitionException { | 17251 | public final void rule__Parameter__NameAssignment_1() throws RecognitionException { |
14295 | 17252 | ||
14296 | int stackSize = keepStackSize(); | 17253 | int stackSize = keepStackSize(); |
14297 | 17254 | ||
14298 | try { | 17255 | try { |
14299 | // InternalProblem.g:4609:1: ( ( ruleIdentifier ) ) | 17256 | // InternalProblem.g:5542:1: ( ( ruleIdentifier ) ) |
14300 | // InternalProblem.g:4610:2: ( ruleIdentifier ) | 17257 | // InternalProblem.g:5543:2: ( ruleIdentifier ) |
14301 | { | 17258 | { |
14302 | // InternalProblem.g:4610:2: ( ruleIdentifier ) | 17259 | // InternalProblem.g:5543:2: ( ruleIdentifier ) |
14303 | // InternalProblem.g:4611:3: ruleIdentifier | 17260 | // InternalProblem.g:5544:3: ruleIdentifier |
14304 | { | 17261 | { |
14305 | before(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); | 17262 | before(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); |
14306 | pushFollow(FOLLOW_2); | 17263 | pushFollow(FOLLOW_2); |
@@ -14331,17 +17288,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14331 | 17288 | ||
14332 | 17289 | ||
14333 | // $ANTLR start "rule__Conjunction__LiteralsAssignment_0" | 17290 | // $ANTLR start "rule__Conjunction__LiteralsAssignment_0" |
14334 | // InternalProblem.g:4620:1: rule__Conjunction__LiteralsAssignment_0 : ( ruleLiteral ) ; | 17291 | // InternalProblem.g:5553:1: rule__Conjunction__LiteralsAssignment_0 : ( ruleLiteral ) ; |
14335 | public final void rule__Conjunction__LiteralsAssignment_0() throws RecognitionException { | 17292 | public final void rule__Conjunction__LiteralsAssignment_0() throws RecognitionException { |
14336 | 17293 | ||
14337 | int stackSize = keepStackSize(); | 17294 | int stackSize = keepStackSize(); |
14338 | 17295 | ||
14339 | try { | 17296 | try { |
14340 | // InternalProblem.g:4624:1: ( ( ruleLiteral ) ) | 17297 | // InternalProblem.g:5557:1: ( ( ruleLiteral ) ) |
14341 | // InternalProblem.g:4625:2: ( ruleLiteral ) | 17298 | // InternalProblem.g:5558:2: ( ruleLiteral ) |
14342 | { | 17299 | { |
14343 | // InternalProblem.g:4625:2: ( ruleLiteral ) | 17300 | // InternalProblem.g:5558:2: ( ruleLiteral ) |
14344 | // InternalProblem.g:4626:3: ruleLiteral | 17301 | // InternalProblem.g:5559:3: ruleLiteral |
14345 | { | 17302 | { |
14346 | before(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); | 17303 | before(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); |
14347 | pushFollow(FOLLOW_2); | 17304 | pushFollow(FOLLOW_2); |
@@ -14372,17 +17329,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14372 | 17329 | ||
14373 | 17330 | ||
14374 | // $ANTLR start "rule__Conjunction__LiteralsAssignment_1_1" | 17331 | // $ANTLR start "rule__Conjunction__LiteralsAssignment_1_1" |
14375 | // InternalProblem.g:4635:1: rule__Conjunction__LiteralsAssignment_1_1 : ( ruleLiteral ) ; | 17332 | // InternalProblem.g:5568:1: rule__Conjunction__LiteralsAssignment_1_1 : ( ruleLiteral ) ; |
14376 | public final void rule__Conjunction__LiteralsAssignment_1_1() throws RecognitionException { | 17333 | public final void rule__Conjunction__LiteralsAssignment_1_1() throws RecognitionException { |
14377 | 17334 | ||
14378 | int stackSize = keepStackSize(); | 17335 | int stackSize = keepStackSize(); |
14379 | 17336 | ||
14380 | try { | 17337 | try { |
14381 | // InternalProblem.g:4639:1: ( ( ruleLiteral ) ) | 17338 | // InternalProblem.g:5572:1: ( ( ruleLiteral ) ) |
14382 | // InternalProblem.g:4640:2: ( ruleLiteral ) | 17339 | // InternalProblem.g:5573:2: ( ruleLiteral ) |
14383 | { | 17340 | { |
14384 | // InternalProblem.g:4640:2: ( ruleLiteral ) | 17341 | // InternalProblem.g:5573:2: ( ruleLiteral ) |
14385 | // InternalProblem.g:4641:3: ruleLiteral | 17342 | // InternalProblem.g:5574:3: ruleLiteral |
14386 | { | 17343 | { |
14387 | before(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); | 17344 | before(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); |
14388 | pushFollow(FOLLOW_2); | 17345 | pushFollow(FOLLOW_2); |
@@ -14413,17 +17370,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14413 | 17370 | ||
14414 | 17371 | ||
14415 | // $ANTLR start "rule__NegativeLiteral__AtomAssignment_1" | 17372 | // $ANTLR start "rule__NegativeLiteral__AtomAssignment_1" |
14416 | // InternalProblem.g:4650:1: rule__NegativeLiteral__AtomAssignment_1 : ( ruleAtom ) ; | 17373 | // InternalProblem.g:5583:1: rule__NegativeLiteral__AtomAssignment_1 : ( ruleAtom ) ; |
14417 | public final void rule__NegativeLiteral__AtomAssignment_1() throws RecognitionException { | 17374 | public final void rule__NegativeLiteral__AtomAssignment_1() throws RecognitionException { |
14418 | 17375 | ||
14419 | int stackSize = keepStackSize(); | 17376 | int stackSize = keepStackSize(); |
14420 | 17377 | ||
14421 | try { | 17378 | try { |
14422 | // InternalProblem.g:4654:1: ( ( ruleAtom ) ) | 17379 | // InternalProblem.g:5587:1: ( ( ruleAtom ) ) |
14423 | // InternalProblem.g:4655:2: ( ruleAtom ) | 17380 | // InternalProblem.g:5588:2: ( ruleAtom ) |
14424 | { | 17381 | { |
14425 | // InternalProblem.g:4655:2: ( ruleAtom ) | 17382 | // InternalProblem.g:5588:2: ( ruleAtom ) |
14426 | // InternalProblem.g:4656:3: ruleAtom | 17383 | // InternalProblem.g:5589:3: ruleAtom |
14427 | { | 17384 | { |
14428 | before(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); | 17385 | before(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); |
14429 | pushFollow(FOLLOW_2); | 17386 | pushFollow(FOLLOW_2); |
@@ -14454,21 +17411,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14454 | 17411 | ||
14455 | 17412 | ||
14456 | // $ANTLR start "rule__Atom__RelationAssignment_0" | 17413 | // $ANTLR start "rule__Atom__RelationAssignment_0" |
14457 | // InternalProblem.g:4665:1: rule__Atom__RelationAssignment_0 : ( ( ruleQualifiedName ) ) ; | 17414 | // InternalProblem.g:5598:1: rule__Atom__RelationAssignment_0 : ( ( ruleQualifiedName ) ) ; |
14458 | public final void rule__Atom__RelationAssignment_0() throws RecognitionException { | 17415 | public final void rule__Atom__RelationAssignment_0() throws RecognitionException { |
14459 | 17416 | ||
14460 | int stackSize = keepStackSize(); | 17417 | int stackSize = keepStackSize(); |
14461 | 17418 | ||
14462 | try { | 17419 | try { |
14463 | // InternalProblem.g:4669:1: ( ( ( ruleQualifiedName ) ) ) | 17420 | // InternalProblem.g:5602:1: ( ( ( ruleQualifiedName ) ) ) |
14464 | // InternalProblem.g:4670:2: ( ( ruleQualifiedName ) ) | 17421 | // InternalProblem.g:5603:2: ( ( ruleQualifiedName ) ) |
14465 | { | 17422 | { |
14466 | // InternalProblem.g:4670:2: ( ( ruleQualifiedName ) ) | 17423 | // InternalProblem.g:5603:2: ( ( ruleQualifiedName ) ) |
14467 | // InternalProblem.g:4671:3: ( ruleQualifiedName ) | 17424 | // InternalProblem.g:5604:3: ( ruleQualifiedName ) |
14468 | { | 17425 | { |
14469 | before(grammarAccess.getAtomAccess().getRelationRelationCrossReference_0_0()); | 17426 | before(grammarAccess.getAtomAccess().getRelationRelationCrossReference_0_0()); |
14470 | // InternalProblem.g:4672:3: ( ruleQualifiedName ) | 17427 | // InternalProblem.g:5605:3: ( ruleQualifiedName ) |
14471 | // InternalProblem.g:4673:4: ruleQualifiedName | 17428 | // InternalProblem.g:5606:4: ruleQualifiedName |
14472 | { | 17429 | { |
14473 | before(grammarAccess.getAtomAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_1()); | 17430 | before(grammarAccess.getAtomAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_1()); |
14474 | pushFollow(FOLLOW_2); | 17431 | pushFollow(FOLLOW_2); |
@@ -14503,24 +17460,24 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14503 | 17460 | ||
14504 | 17461 | ||
14505 | // $ANTLR start "rule__Atom__TransitiveClosureAssignment_1" | 17462 | // $ANTLR start "rule__Atom__TransitiveClosureAssignment_1" |
14506 | // InternalProblem.g:4684:1: rule__Atom__TransitiveClosureAssignment_1 : ( ( '+' ) ) ; | 17463 | // InternalProblem.g:5617:1: rule__Atom__TransitiveClosureAssignment_1 : ( ( '+' ) ) ; |
14507 | public final void rule__Atom__TransitiveClosureAssignment_1() throws RecognitionException { | 17464 | public final void rule__Atom__TransitiveClosureAssignment_1() throws RecognitionException { |
14508 | 17465 | ||
14509 | int stackSize = keepStackSize(); | 17466 | int stackSize = keepStackSize(); |
14510 | 17467 | ||
14511 | try { | 17468 | try { |
14512 | // InternalProblem.g:4688:1: ( ( ( '+' ) ) ) | 17469 | // InternalProblem.g:5621:1: ( ( ( '+' ) ) ) |
14513 | // InternalProblem.g:4689:2: ( ( '+' ) ) | 17470 | // InternalProblem.g:5622:2: ( ( '+' ) ) |
14514 | { | 17471 | { |
14515 | // InternalProblem.g:4689:2: ( ( '+' ) ) | 17472 | // InternalProblem.g:5622:2: ( ( '+' ) ) |
14516 | // InternalProblem.g:4690:3: ( '+' ) | 17473 | // InternalProblem.g:5623:3: ( '+' ) |
14517 | { | 17474 | { |
14518 | before(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); | 17475 | before(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); |
14519 | // InternalProblem.g:4691:3: ( '+' ) | 17476 | // InternalProblem.g:5624:3: ( '+' ) |
14520 | // InternalProblem.g:4692:4: '+' | 17477 | // InternalProblem.g:5625:4: '+' |
14521 | { | 17478 | { |
14522 | before(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); | 17479 | before(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); |
14523 | match(input,43,FOLLOW_2); | 17480 | match(input,24,FOLLOW_2); |
14524 | after(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); | 17481 | after(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); |
14525 | 17482 | ||
14526 | } | 17483 | } |
@@ -14548,17 +17505,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14548 | 17505 | ||
14549 | 17506 | ||
14550 | // $ANTLR start "rule__Atom__ArgumentsAssignment_3_0" | 17507 | // $ANTLR start "rule__Atom__ArgumentsAssignment_3_0" |
14551 | // InternalProblem.g:4703:1: rule__Atom__ArgumentsAssignment_3_0 : ( ruleArgument ) ; | 17508 | // InternalProblem.g:5636:1: rule__Atom__ArgumentsAssignment_3_0 : ( ruleArgument ) ; |
14552 | public final void rule__Atom__ArgumentsAssignment_3_0() throws RecognitionException { | 17509 | public final void rule__Atom__ArgumentsAssignment_3_0() throws RecognitionException { |
14553 | 17510 | ||
14554 | int stackSize = keepStackSize(); | 17511 | int stackSize = keepStackSize(); |
14555 | 17512 | ||
14556 | try { | 17513 | try { |
14557 | // InternalProblem.g:4707:1: ( ( ruleArgument ) ) | 17514 | // InternalProblem.g:5640:1: ( ( ruleArgument ) ) |
14558 | // InternalProblem.g:4708:2: ( ruleArgument ) | 17515 | // InternalProblem.g:5641:2: ( ruleArgument ) |
14559 | { | 17516 | { |
14560 | // InternalProblem.g:4708:2: ( ruleArgument ) | 17517 | // InternalProblem.g:5641:2: ( ruleArgument ) |
14561 | // InternalProblem.g:4709:3: ruleArgument | 17518 | // InternalProblem.g:5642:3: ruleArgument |
14562 | { | 17519 | { |
14563 | before(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); | 17520 | before(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); |
14564 | pushFollow(FOLLOW_2); | 17521 | pushFollow(FOLLOW_2); |
@@ -14589,17 +17546,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14589 | 17546 | ||
14590 | 17547 | ||
14591 | // $ANTLR start "rule__Atom__ArgumentsAssignment_3_1_1" | 17548 | // $ANTLR start "rule__Atom__ArgumentsAssignment_3_1_1" |
14592 | // InternalProblem.g:4718:1: rule__Atom__ArgumentsAssignment_3_1_1 : ( ruleArgument ) ; | 17549 | // InternalProblem.g:5651:1: rule__Atom__ArgumentsAssignment_3_1_1 : ( ruleArgument ) ; |
14593 | public final void rule__Atom__ArgumentsAssignment_3_1_1() throws RecognitionException { | 17550 | public final void rule__Atom__ArgumentsAssignment_3_1_1() throws RecognitionException { |
14594 | 17551 | ||
14595 | int stackSize = keepStackSize(); | 17552 | int stackSize = keepStackSize(); |
14596 | 17553 | ||
14597 | try { | 17554 | try { |
14598 | // InternalProblem.g:4722:1: ( ( ruleArgument ) ) | 17555 | // InternalProblem.g:5655:1: ( ( ruleArgument ) ) |
14599 | // InternalProblem.g:4723:2: ( ruleArgument ) | 17556 | // InternalProblem.g:5656:2: ( ruleArgument ) |
14600 | { | 17557 | { |
14601 | // InternalProblem.g:4723:2: ( ruleArgument ) | 17558 | // InternalProblem.g:5656:2: ( ruleArgument ) |
14602 | // InternalProblem.g:4724:3: ruleArgument | 17559 | // InternalProblem.g:5657:3: ruleArgument |
14603 | { | 17560 | { |
14604 | before(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); | 17561 | before(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); |
14605 | pushFollow(FOLLOW_2); | 17562 | pushFollow(FOLLOW_2); |
@@ -14629,34 +17586,75 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14629 | // $ANTLR end "rule__Atom__ArgumentsAssignment_3_1_1" | 17586 | // $ANTLR end "rule__Atom__ArgumentsAssignment_3_1_1" |
14630 | 17587 | ||
14631 | 17588 | ||
14632 | // $ANTLR start "rule__Argument__VariableOrNodeAssignment" | 17589 | // $ANTLR start "rule__VariableOrNodeArgument__VariableOrNodeAssignment" |
14633 | // InternalProblem.g:4733:1: rule__Argument__VariableOrNodeAssignment : ( ( ruleQualifiedName ) ) ; | 17590 | // InternalProblem.g:5666:1: rule__VariableOrNodeArgument__VariableOrNodeAssignment : ( ( ruleQualifiedName ) ) ; |
14634 | public final void rule__Argument__VariableOrNodeAssignment() throws RecognitionException { | 17591 | public final void rule__VariableOrNodeArgument__VariableOrNodeAssignment() throws RecognitionException { |
14635 | 17592 | ||
14636 | int stackSize = keepStackSize(); | 17593 | int stackSize = keepStackSize(); |
14637 | 17594 | ||
14638 | try { | 17595 | try { |
14639 | // InternalProblem.g:4737:1: ( ( ( ruleQualifiedName ) ) ) | 17596 | // InternalProblem.g:5670:1: ( ( ( ruleQualifiedName ) ) ) |
14640 | // InternalProblem.g:4738:2: ( ( ruleQualifiedName ) ) | 17597 | // InternalProblem.g:5671:2: ( ( ruleQualifiedName ) ) |
14641 | { | 17598 | { |
14642 | // InternalProblem.g:4738:2: ( ( ruleQualifiedName ) ) | 17599 | // InternalProblem.g:5671:2: ( ( ruleQualifiedName ) ) |
14643 | // InternalProblem.g:4739:3: ( ruleQualifiedName ) | 17600 | // InternalProblem.g:5672:3: ( ruleQualifiedName ) |
14644 | { | 17601 | { |
14645 | before(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); | 17602 | before(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); |
14646 | // InternalProblem.g:4740:3: ( ruleQualifiedName ) | 17603 | // InternalProblem.g:5673:3: ( ruleQualifiedName ) |
14647 | // InternalProblem.g:4741:4: ruleQualifiedName | 17604 | // InternalProblem.g:5674:4: ruleQualifiedName |
14648 | { | 17605 | { |
14649 | before(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); | 17606 | before(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); |
14650 | pushFollow(FOLLOW_2); | 17607 | pushFollow(FOLLOW_2); |
14651 | ruleQualifiedName(); | 17608 | ruleQualifiedName(); |
14652 | 17609 | ||
14653 | state._fsp--; | 17610 | state._fsp--; |
14654 | 17611 | ||
14655 | after(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); | 17612 | after(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); |
17613 | |||
17614 | } | ||
17615 | |||
17616 | after(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); | ||
14656 | 17617 | ||
14657 | } | 17618 | } |
14658 | 17619 | ||
14659 | after(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); | 17620 | |
17621 | } | ||
17622 | |||
17623 | } | ||
17624 | catch (RecognitionException re) { | ||
17625 | reportError(re); | ||
17626 | recover(input,re); | ||
17627 | } | ||
17628 | finally { | ||
17629 | |||
17630 | restoreStackSize(stackSize); | ||
17631 | |||
17632 | } | ||
17633 | return ; | ||
17634 | } | ||
17635 | // $ANTLR end "rule__VariableOrNodeArgument__VariableOrNodeAssignment" | ||
17636 | |||
17637 | |||
17638 | // $ANTLR start "rule__ConstantArgument__ConstantAssignment" | ||
17639 | // InternalProblem.g:5685:1: rule__ConstantArgument__ConstantAssignment : ( ruleConstant ) ; | ||
17640 | public final void rule__ConstantArgument__ConstantAssignment() throws RecognitionException { | ||
17641 | |||
17642 | int stackSize = keepStackSize(); | ||
17643 | |||
17644 | try { | ||
17645 | // InternalProblem.g:5689:1: ( ( ruleConstant ) ) | ||
17646 | // InternalProblem.g:5690:2: ( ruleConstant ) | ||
17647 | { | ||
17648 | // InternalProblem.g:5690:2: ( ruleConstant ) | ||
17649 | // InternalProblem.g:5691:3: ruleConstant | ||
17650 | { | ||
17651 | before(grammarAccess.getConstantArgumentAccess().getConstantConstantParserRuleCall_0()); | ||
17652 | pushFollow(FOLLOW_2); | ||
17653 | ruleConstant(); | ||
17654 | |||
17655 | state._fsp--; | ||
17656 | |||
17657 | after(grammarAccess.getConstantArgumentAccess().getConstantConstantParserRuleCall_0()); | ||
14660 | 17658 | ||
14661 | } | 17659 | } |
14662 | 17660 | ||
@@ -14675,25 +17673,25 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14675 | } | 17673 | } |
14676 | return ; | 17674 | return ; |
14677 | } | 17675 | } |
14678 | // $ANTLR end "rule__Argument__VariableOrNodeAssignment" | 17676 | // $ANTLR end "rule__ConstantArgument__ConstantAssignment" |
14679 | 17677 | ||
14680 | 17678 | ||
14681 | // $ANTLR start "rule__Assertion__RelationAssignment_0_0_0" | 17679 | // $ANTLR start "rule__Assertion__RelationAssignment_0_0_0" |
14682 | // InternalProblem.g:4752:1: rule__Assertion__RelationAssignment_0_0_0 : ( ( ruleQualifiedName ) ) ; | 17680 | // InternalProblem.g:5700:1: rule__Assertion__RelationAssignment_0_0_0 : ( ( ruleQualifiedName ) ) ; |
14683 | public final void rule__Assertion__RelationAssignment_0_0_0() throws RecognitionException { | 17681 | public final void rule__Assertion__RelationAssignment_0_0_0() throws RecognitionException { |
14684 | 17682 | ||
14685 | int stackSize = keepStackSize(); | 17683 | int stackSize = keepStackSize(); |
14686 | 17684 | ||
14687 | try { | 17685 | try { |
14688 | // InternalProblem.g:4756:1: ( ( ( ruleQualifiedName ) ) ) | 17686 | // InternalProblem.g:5704:1: ( ( ( ruleQualifiedName ) ) ) |
14689 | // InternalProblem.g:4757:2: ( ( ruleQualifiedName ) ) | 17687 | // InternalProblem.g:5705:2: ( ( ruleQualifiedName ) ) |
14690 | { | 17688 | { |
14691 | // InternalProblem.g:4757:2: ( ( ruleQualifiedName ) ) | 17689 | // InternalProblem.g:5705:2: ( ( ruleQualifiedName ) ) |
14692 | // InternalProblem.g:4758:3: ( ruleQualifiedName ) | 17690 | // InternalProblem.g:5706:3: ( ruleQualifiedName ) |
14693 | { | 17691 | { |
14694 | before(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_0_0_0()); | 17692 | before(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_0_0_0()); |
14695 | // InternalProblem.g:4759:3: ( ruleQualifiedName ) | 17693 | // InternalProblem.g:5707:3: ( ruleQualifiedName ) |
14696 | // InternalProblem.g:4760:4: ruleQualifiedName | 17694 | // InternalProblem.g:5708:4: ruleQualifiedName |
14697 | { | 17695 | { |
14698 | before(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1()); | 17696 | before(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1()); |
14699 | pushFollow(FOLLOW_2); | 17697 | pushFollow(FOLLOW_2); |
@@ -14728,33 +17726,25 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14728 | 17726 | ||
14729 | 17727 | ||
14730 | // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_0_2_0" | 17728 | // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_0_2_0" |
14731 | // InternalProblem.g:4771:1: rule__Assertion__ArgumentsAssignment_0_0_2_0 : ( ( ruleQualifiedName ) ) ; | 17729 | // InternalProblem.g:5719:1: rule__Assertion__ArgumentsAssignment_0_0_2_0 : ( ruleAssertionArgument ) ; |
14732 | public final void rule__Assertion__ArgumentsAssignment_0_0_2_0() throws RecognitionException { | 17730 | public final void rule__Assertion__ArgumentsAssignment_0_0_2_0() throws RecognitionException { |
14733 | 17731 | ||
14734 | int stackSize = keepStackSize(); | 17732 | int stackSize = keepStackSize(); |
14735 | 17733 | ||
14736 | try { | 17734 | try { |
14737 | // InternalProblem.g:4775:1: ( ( ( ruleQualifiedName ) ) ) | 17735 | // InternalProblem.g:5723:1: ( ( ruleAssertionArgument ) ) |
14738 | // InternalProblem.g:4776:2: ( ( ruleQualifiedName ) ) | 17736 | // InternalProblem.g:5724:2: ( ruleAssertionArgument ) |
14739 | { | 17737 | { |
14740 | // InternalProblem.g:4776:2: ( ( ruleQualifiedName ) ) | 17738 | // InternalProblem.g:5724:2: ( ruleAssertionArgument ) |
14741 | // InternalProblem.g:4777:3: ( ruleQualifiedName ) | 17739 | // InternalProblem.g:5725:3: ruleAssertionArgument |
14742 | { | 17740 | { |
14743 | before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); | 17741 | before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0()); |
14744 | // InternalProblem.g:4778:3: ( ruleQualifiedName ) | ||
14745 | // InternalProblem.g:4779:4: ruleQualifiedName | ||
14746 | { | ||
14747 | before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1()); | ||
14748 | pushFollow(FOLLOW_2); | 17742 | pushFollow(FOLLOW_2); |
14749 | ruleQualifiedName(); | 17743 | ruleAssertionArgument(); |
14750 | 17744 | ||
14751 | state._fsp--; | 17745 | state._fsp--; |
14752 | 17746 | ||
14753 | after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1()); | 17747 | after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0()); |
14754 | |||
14755 | } | ||
14756 | |||
14757 | after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); | ||
14758 | 17748 | ||
14759 | } | 17749 | } |
14760 | 17750 | ||
@@ -14777,33 +17767,25 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14777 | 17767 | ||
14778 | 17768 | ||
14779 | // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_0_2_1_1" | 17769 | // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_0_2_1_1" |
14780 | // InternalProblem.g:4790:1: rule__Assertion__ArgumentsAssignment_0_0_2_1_1 : ( ( ruleQualifiedName ) ) ; | 17770 | // InternalProblem.g:5734:1: rule__Assertion__ArgumentsAssignment_0_0_2_1_1 : ( ruleAssertionArgument ) ; |
14781 | public final void rule__Assertion__ArgumentsAssignment_0_0_2_1_1() throws RecognitionException { | 17771 | public final void rule__Assertion__ArgumentsAssignment_0_0_2_1_1() throws RecognitionException { |
14782 | 17772 | ||
14783 | int stackSize = keepStackSize(); | 17773 | int stackSize = keepStackSize(); |
14784 | 17774 | ||
14785 | try { | 17775 | try { |
14786 | // InternalProblem.g:4794:1: ( ( ( ruleQualifiedName ) ) ) | 17776 | // InternalProblem.g:5738:1: ( ( ruleAssertionArgument ) ) |
14787 | // InternalProblem.g:4795:2: ( ( ruleQualifiedName ) ) | 17777 | // InternalProblem.g:5739:2: ( ruleAssertionArgument ) |
14788 | { | 17778 | { |
14789 | // InternalProblem.g:4795:2: ( ( ruleQualifiedName ) ) | 17779 | // InternalProblem.g:5739:2: ( ruleAssertionArgument ) |
14790 | // InternalProblem.g:4796:3: ( ruleQualifiedName ) | 17780 | // InternalProblem.g:5740:3: ruleAssertionArgument |
14791 | { | 17781 | { |
14792 | before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); | 17782 | before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0()); |
14793 | // InternalProblem.g:4797:3: ( ruleQualifiedName ) | ||
14794 | // InternalProblem.g:4798:4: ruleQualifiedName | ||
14795 | { | ||
14796 | before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1()); | ||
14797 | pushFollow(FOLLOW_2); | 17783 | pushFollow(FOLLOW_2); |
14798 | ruleQualifiedName(); | 17784 | ruleAssertionArgument(); |
14799 | 17785 | ||
14800 | state._fsp--; | 17786 | state._fsp--; |
14801 | 17787 | ||
14802 | after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1()); | 17788 | after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0()); |
14803 | |||
14804 | } | ||
14805 | |||
14806 | after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); | ||
14807 | 17789 | ||
14808 | } | 17790 | } |
14809 | 17791 | ||
@@ -14826,17 +17808,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14826 | 17808 | ||
14827 | 17809 | ||
14828 | // $ANTLR start "rule__Assertion__ValueAssignment_0_0_5" | 17810 | // $ANTLR start "rule__Assertion__ValueAssignment_0_0_5" |
14829 | // InternalProblem.g:4809:1: rule__Assertion__ValueAssignment_0_0_5 : ( ruleLogicValue ) ; | 17811 | // InternalProblem.g:5749:1: rule__Assertion__ValueAssignment_0_0_5 : ( ruleLogicValue ) ; |
14830 | public final void rule__Assertion__ValueAssignment_0_0_5() throws RecognitionException { | 17812 | public final void rule__Assertion__ValueAssignment_0_0_5() throws RecognitionException { |
14831 | 17813 | ||
14832 | int stackSize = keepStackSize(); | 17814 | int stackSize = keepStackSize(); |
14833 | 17815 | ||
14834 | try { | 17816 | try { |
14835 | // InternalProblem.g:4813:1: ( ( ruleLogicValue ) ) | 17817 | // InternalProblem.g:5753:1: ( ( ruleLogicValue ) ) |
14836 | // InternalProblem.g:4814:2: ( ruleLogicValue ) | 17818 | // InternalProblem.g:5754:2: ( ruleLogicValue ) |
14837 | { | 17819 | { |
14838 | // InternalProblem.g:4814:2: ( ruleLogicValue ) | 17820 | // InternalProblem.g:5754:2: ( ruleLogicValue ) |
14839 | // InternalProblem.g:4815:3: ruleLogicValue | 17821 | // InternalProblem.g:5755:3: ruleLogicValue |
14840 | { | 17822 | { |
14841 | before(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); | 17823 | before(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); |
14842 | pushFollow(FOLLOW_2); | 17824 | pushFollow(FOLLOW_2); |
@@ -14867,17 +17849,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14867 | 17849 | ||
14868 | 17850 | ||
14869 | // $ANTLR start "rule__Assertion__ValueAssignment_0_1_0" | 17851 | // $ANTLR start "rule__Assertion__ValueAssignment_0_1_0" |
14870 | // InternalProblem.g:4824:1: rule__Assertion__ValueAssignment_0_1_0 : ( ruleShortLogicValue ) ; | 17852 | // InternalProblem.g:5764:1: rule__Assertion__ValueAssignment_0_1_0 : ( ruleShortLogicValue ) ; |
14871 | public final void rule__Assertion__ValueAssignment_0_1_0() throws RecognitionException { | 17853 | public final void rule__Assertion__ValueAssignment_0_1_0() throws RecognitionException { |
14872 | 17854 | ||
14873 | int stackSize = keepStackSize(); | 17855 | int stackSize = keepStackSize(); |
14874 | 17856 | ||
14875 | try { | 17857 | try { |
14876 | // InternalProblem.g:4828:1: ( ( ruleShortLogicValue ) ) | 17858 | // InternalProblem.g:5768:1: ( ( ruleShortLogicValue ) ) |
14877 | // InternalProblem.g:4829:2: ( ruleShortLogicValue ) | 17859 | // InternalProblem.g:5769:2: ( ruleShortLogicValue ) |
14878 | { | 17860 | { |
14879 | // InternalProblem.g:4829:2: ( ruleShortLogicValue ) | 17861 | // InternalProblem.g:5769:2: ( ruleShortLogicValue ) |
14880 | // InternalProblem.g:4830:3: ruleShortLogicValue | 17862 | // InternalProblem.g:5770:3: ruleShortLogicValue |
14881 | { | 17863 | { |
14882 | before(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); | 17864 | before(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); |
14883 | pushFollow(FOLLOW_2); | 17865 | pushFollow(FOLLOW_2); |
@@ -14908,21 +17890,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14908 | 17890 | ||
14909 | 17891 | ||
14910 | // $ANTLR start "rule__Assertion__RelationAssignment_0_1_1" | 17892 | // $ANTLR start "rule__Assertion__RelationAssignment_0_1_1" |
14911 | // InternalProblem.g:4839:1: rule__Assertion__RelationAssignment_0_1_1 : ( ( ruleQualifiedName ) ) ; | 17893 | // InternalProblem.g:5779:1: rule__Assertion__RelationAssignment_0_1_1 : ( ( ruleQualifiedName ) ) ; |
14912 | public final void rule__Assertion__RelationAssignment_0_1_1() throws RecognitionException { | 17894 | public final void rule__Assertion__RelationAssignment_0_1_1() throws RecognitionException { |
14913 | 17895 | ||
14914 | int stackSize = keepStackSize(); | 17896 | int stackSize = keepStackSize(); |
14915 | 17897 | ||
14916 | try { | 17898 | try { |
14917 | // InternalProblem.g:4843:1: ( ( ( ruleQualifiedName ) ) ) | 17899 | // InternalProblem.g:5783:1: ( ( ( ruleQualifiedName ) ) ) |
14918 | // InternalProblem.g:4844:2: ( ( ruleQualifiedName ) ) | 17900 | // InternalProblem.g:5784:2: ( ( ruleQualifiedName ) ) |
14919 | { | 17901 | { |
14920 | // InternalProblem.g:4844:2: ( ( ruleQualifiedName ) ) | 17902 | // InternalProblem.g:5784:2: ( ( ruleQualifiedName ) ) |
14921 | // InternalProblem.g:4845:3: ( ruleQualifiedName ) | 17903 | // InternalProblem.g:5785:3: ( ruleQualifiedName ) |
14922 | { | 17904 | { |
14923 | before(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_1_1_0()); | 17905 | before(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_1_1_0()); |
14924 | // InternalProblem.g:4846:3: ( ruleQualifiedName ) | 17906 | // InternalProblem.g:5786:3: ( ruleQualifiedName ) |
14925 | // InternalProblem.g:4847:4: ruleQualifiedName | 17907 | // InternalProblem.g:5787:4: ruleQualifiedName |
14926 | { | 17908 | { |
14927 | before(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1()); | 17909 | before(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1()); |
14928 | pushFollow(FOLLOW_2); | 17910 | pushFollow(FOLLOW_2); |
@@ -14957,33 +17939,115 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
14957 | 17939 | ||
14958 | 17940 | ||
14959 | // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_1_3_0" | 17941 | // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_1_3_0" |
14960 | // InternalProblem.g:4858:1: rule__Assertion__ArgumentsAssignment_0_1_3_0 : ( ( ruleQualifiedName ) ) ; | 17942 | // InternalProblem.g:5798:1: rule__Assertion__ArgumentsAssignment_0_1_3_0 : ( ruleAssertionArgument ) ; |
14961 | public final void rule__Assertion__ArgumentsAssignment_0_1_3_0() throws RecognitionException { | 17943 | public final void rule__Assertion__ArgumentsAssignment_0_1_3_0() throws RecognitionException { |
14962 | 17944 | ||
14963 | int stackSize = keepStackSize(); | 17945 | int stackSize = keepStackSize(); |
14964 | 17946 | ||
14965 | try { | 17947 | try { |
14966 | // InternalProblem.g:4862:1: ( ( ( ruleQualifiedName ) ) ) | 17948 | // InternalProblem.g:5802:1: ( ( ruleAssertionArgument ) ) |
14967 | // InternalProblem.g:4863:2: ( ( ruleQualifiedName ) ) | 17949 | // InternalProblem.g:5803:2: ( ruleAssertionArgument ) |
17950 | { | ||
17951 | // InternalProblem.g:5803:2: ( ruleAssertionArgument ) | ||
17952 | // InternalProblem.g:5804:3: ruleAssertionArgument | ||
17953 | { | ||
17954 | before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0()); | ||
17955 | pushFollow(FOLLOW_2); | ||
17956 | ruleAssertionArgument(); | ||
17957 | |||
17958 | state._fsp--; | ||
17959 | |||
17960 | after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0()); | ||
17961 | |||
17962 | } | ||
17963 | |||
17964 | |||
17965 | } | ||
17966 | |||
17967 | } | ||
17968 | catch (RecognitionException re) { | ||
17969 | reportError(re); | ||
17970 | recover(input,re); | ||
17971 | } | ||
17972 | finally { | ||
17973 | |||
17974 | restoreStackSize(stackSize); | ||
17975 | |||
17976 | } | ||
17977 | return ; | ||
17978 | } | ||
17979 | // $ANTLR end "rule__Assertion__ArgumentsAssignment_0_1_3_0" | ||
17980 | |||
17981 | |||
17982 | // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_1_3_1_1" | ||
17983 | // InternalProblem.g:5813:1: rule__Assertion__ArgumentsAssignment_0_1_3_1_1 : ( ruleAssertionArgument ) ; | ||
17984 | public final void rule__Assertion__ArgumentsAssignment_0_1_3_1_1() throws RecognitionException { | ||
17985 | |||
17986 | int stackSize = keepStackSize(); | ||
17987 | |||
17988 | try { | ||
17989 | // InternalProblem.g:5817:1: ( ( ruleAssertionArgument ) ) | ||
17990 | // InternalProblem.g:5818:2: ( ruleAssertionArgument ) | ||
17991 | { | ||
17992 | // InternalProblem.g:5818:2: ( ruleAssertionArgument ) | ||
17993 | // InternalProblem.g:5819:3: ruleAssertionArgument | ||
17994 | { | ||
17995 | before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0()); | ||
17996 | pushFollow(FOLLOW_2); | ||
17997 | ruleAssertionArgument(); | ||
17998 | |||
17999 | state._fsp--; | ||
18000 | |||
18001 | after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0()); | ||
18002 | |||
18003 | } | ||
18004 | |||
18005 | |||
18006 | } | ||
18007 | |||
18008 | } | ||
18009 | catch (RecognitionException re) { | ||
18010 | reportError(re); | ||
18011 | recover(input,re); | ||
18012 | } | ||
18013 | finally { | ||
18014 | |||
18015 | restoreStackSize(stackSize); | ||
18016 | |||
18017 | } | ||
18018 | return ; | ||
18019 | } | ||
18020 | // $ANTLR end "rule__Assertion__ArgumentsAssignment_0_1_3_1_1" | ||
18021 | |||
18022 | |||
18023 | // $ANTLR start "rule__NodeAssertionArgument__NodeAssignment" | ||
18024 | // InternalProblem.g:5828:1: rule__NodeAssertionArgument__NodeAssignment : ( ( ruleQualifiedName ) ) ; | ||
18025 | public final void rule__NodeAssertionArgument__NodeAssignment() throws RecognitionException { | ||
18026 | |||
18027 | int stackSize = keepStackSize(); | ||
18028 | |||
18029 | try { | ||
18030 | // InternalProblem.g:5832:1: ( ( ( ruleQualifiedName ) ) ) | ||
18031 | // InternalProblem.g:5833:2: ( ( ruleQualifiedName ) ) | ||
14968 | { | 18032 | { |
14969 | // InternalProblem.g:4863:2: ( ( ruleQualifiedName ) ) | 18033 | // InternalProblem.g:5833:2: ( ( ruleQualifiedName ) ) |
14970 | // InternalProblem.g:4864:3: ( ruleQualifiedName ) | 18034 | // InternalProblem.g:5834:3: ( ruleQualifiedName ) |
14971 | { | 18035 | { |
14972 | before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); | 18036 | before(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeCrossReference_0()); |
14973 | // InternalProblem.g:4865:3: ( ruleQualifiedName ) | 18037 | // InternalProblem.g:5835:3: ( ruleQualifiedName ) |
14974 | // InternalProblem.g:4866:4: ruleQualifiedName | 18038 | // InternalProblem.g:5836:4: ruleQualifiedName |
14975 | { | 18039 | { |
14976 | before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1()); | 18040 | before(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeQualifiedNameParserRuleCall_0_1()); |
14977 | pushFollow(FOLLOW_2); | 18041 | pushFollow(FOLLOW_2); |
14978 | ruleQualifiedName(); | 18042 | ruleQualifiedName(); |
14979 | 18043 | ||
14980 | state._fsp--; | 18044 | state._fsp--; |
14981 | 18045 | ||
14982 | after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1()); | 18046 | after(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeQualifiedNameParserRuleCall_0_1()); |
14983 | 18047 | ||
14984 | } | 18048 | } |
14985 | 18049 | ||
14986 | after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); | 18050 | after(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeCrossReference_0()); |
14987 | 18051 | ||
14988 | } | 18052 | } |
14989 | 18053 | ||
@@ -15002,37 +18066,78 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15002 | } | 18066 | } |
15003 | return ; | 18067 | return ; |
15004 | } | 18068 | } |
15005 | // $ANTLR end "rule__Assertion__ArgumentsAssignment_0_1_3_0" | 18069 | // $ANTLR end "rule__NodeAssertionArgument__NodeAssignment" |
15006 | 18070 | ||
15007 | 18071 | ||
15008 | // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_1_3_1_1" | 18072 | // $ANTLR start "rule__ConstantAssertionArgument__ConstantAssignment" |
15009 | // InternalProblem.g:4877:1: rule__Assertion__ArgumentsAssignment_0_1_3_1_1 : ( ( ruleQualifiedName ) ) ; | 18073 | // InternalProblem.g:5847:1: rule__ConstantAssertionArgument__ConstantAssignment : ( ruleConstant ) ; |
15010 | public final void rule__Assertion__ArgumentsAssignment_0_1_3_1_1() throws RecognitionException { | 18074 | public final void rule__ConstantAssertionArgument__ConstantAssignment() throws RecognitionException { |
15011 | 18075 | ||
15012 | int stackSize = keepStackSize(); | 18076 | int stackSize = keepStackSize(); |
15013 | 18077 | ||
15014 | try { | 18078 | try { |
15015 | // InternalProblem.g:4881:1: ( ( ( ruleQualifiedName ) ) ) | 18079 | // InternalProblem.g:5851:1: ( ( ruleConstant ) ) |
15016 | // InternalProblem.g:4882:2: ( ( ruleQualifiedName ) ) | 18080 | // InternalProblem.g:5852:2: ( ruleConstant ) |
15017 | { | 18081 | { |
15018 | // InternalProblem.g:4882:2: ( ( ruleQualifiedName ) ) | 18082 | // InternalProblem.g:5852:2: ( ruleConstant ) |
15019 | // InternalProblem.g:4883:3: ( ruleQualifiedName ) | 18083 | // InternalProblem.g:5853:3: ruleConstant |
15020 | { | 18084 | { |
15021 | before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); | 18085 | before(grammarAccess.getConstantAssertionArgumentAccess().getConstantConstantParserRuleCall_0()); |
15022 | // InternalProblem.g:4884:3: ( ruleQualifiedName ) | 18086 | pushFollow(FOLLOW_2); |
15023 | // InternalProblem.g:4885:4: ruleQualifiedName | 18087 | ruleConstant(); |
18088 | |||
18089 | state._fsp--; | ||
18090 | |||
18091 | after(grammarAccess.getConstantAssertionArgumentAccess().getConstantConstantParserRuleCall_0()); | ||
18092 | |||
18093 | } | ||
18094 | |||
18095 | |||
18096 | } | ||
18097 | |||
18098 | } | ||
18099 | catch (RecognitionException re) { | ||
18100 | reportError(re); | ||
18101 | recover(input,re); | ||
18102 | } | ||
18103 | finally { | ||
18104 | |||
18105 | restoreStackSize(stackSize); | ||
18106 | |||
18107 | } | ||
18108 | return ; | ||
18109 | } | ||
18110 | // $ANTLR end "rule__ConstantAssertionArgument__ConstantAssignment" | ||
18111 | |||
18112 | |||
18113 | // $ANTLR start "rule__NodeValueAssertion__NodeAssignment_0" | ||
18114 | // InternalProblem.g:5862:1: rule__NodeValueAssertion__NodeAssignment_0 : ( ( ruleQualifiedName ) ) ; | ||
18115 | public final void rule__NodeValueAssertion__NodeAssignment_0() throws RecognitionException { | ||
18116 | |||
18117 | int stackSize = keepStackSize(); | ||
18118 | |||
18119 | try { | ||
18120 | // InternalProblem.g:5866:1: ( ( ( ruleQualifiedName ) ) ) | ||
18121 | // InternalProblem.g:5867:2: ( ( ruleQualifiedName ) ) | ||
18122 | { | ||
18123 | // InternalProblem.g:5867:2: ( ( ruleQualifiedName ) ) | ||
18124 | // InternalProblem.g:5868:3: ( ruleQualifiedName ) | ||
15024 | { | 18125 | { |
15025 | before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1()); | 18126 | before(grammarAccess.getNodeValueAssertionAccess().getNodeNodeCrossReference_0_0()); |
18127 | // InternalProblem.g:5869:3: ( ruleQualifiedName ) | ||
18128 | // InternalProblem.g:5870:4: ruleQualifiedName | ||
18129 | { | ||
18130 | before(grammarAccess.getNodeValueAssertionAccess().getNodeNodeQualifiedNameParserRuleCall_0_0_1()); | ||
15026 | pushFollow(FOLLOW_2); | 18131 | pushFollow(FOLLOW_2); |
15027 | ruleQualifiedName(); | 18132 | ruleQualifiedName(); |
15028 | 18133 | ||
15029 | state._fsp--; | 18134 | state._fsp--; |
15030 | 18135 | ||
15031 | after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1()); | 18136 | after(grammarAccess.getNodeValueAssertionAccess().getNodeNodeQualifiedNameParserRuleCall_0_0_1()); |
15032 | 18137 | ||
15033 | } | 18138 | } |
15034 | 18139 | ||
15035 | after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); | 18140 | after(grammarAccess.getNodeValueAssertionAccess().getNodeNodeCrossReference_0_0()); |
15036 | 18141 | ||
15037 | } | 18142 | } |
15038 | 18143 | ||
@@ -15051,21 +18156,181 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15051 | } | 18156 | } |
15052 | return ; | 18157 | return ; |
15053 | } | 18158 | } |
15054 | // $ANTLR end "rule__Assertion__ArgumentsAssignment_0_1_3_1_1" | 18159 | // $ANTLR end "rule__NodeValueAssertion__NodeAssignment_0" |
18160 | |||
18161 | |||
18162 | // $ANTLR start "rule__NodeValueAssertion__ValueAssignment_2" | ||
18163 | // InternalProblem.g:5881:1: rule__NodeValueAssertion__ValueAssignment_2 : ( ruleConstant ) ; | ||
18164 | public final void rule__NodeValueAssertion__ValueAssignment_2() throws RecognitionException { | ||
18165 | |||
18166 | int stackSize = keepStackSize(); | ||
18167 | |||
18168 | try { | ||
18169 | // InternalProblem.g:5885:1: ( ( ruleConstant ) ) | ||
18170 | // InternalProblem.g:5886:2: ( ruleConstant ) | ||
18171 | { | ||
18172 | // InternalProblem.g:5886:2: ( ruleConstant ) | ||
18173 | // InternalProblem.g:5887:3: ruleConstant | ||
18174 | { | ||
18175 | before(grammarAccess.getNodeValueAssertionAccess().getValueConstantParserRuleCall_2_0()); | ||
18176 | pushFollow(FOLLOW_2); | ||
18177 | ruleConstant(); | ||
18178 | |||
18179 | state._fsp--; | ||
18180 | |||
18181 | after(grammarAccess.getNodeValueAssertionAccess().getValueConstantParserRuleCall_2_0()); | ||
18182 | |||
18183 | } | ||
18184 | |||
18185 | |||
18186 | } | ||
18187 | |||
18188 | } | ||
18189 | catch (RecognitionException re) { | ||
18190 | reportError(re); | ||
18191 | recover(input,re); | ||
18192 | } | ||
18193 | finally { | ||
18194 | |||
18195 | restoreStackSize(stackSize); | ||
18196 | |||
18197 | } | ||
18198 | return ; | ||
18199 | } | ||
18200 | // $ANTLR end "rule__NodeValueAssertion__ValueAssignment_2" | ||
18201 | |||
18202 | |||
18203 | // $ANTLR start "rule__IntConstant__IntValueAssignment" | ||
18204 | // InternalProblem.g:5896:1: rule__IntConstant__IntValueAssignment : ( ruleInteger ) ; | ||
18205 | public final void rule__IntConstant__IntValueAssignment() throws RecognitionException { | ||
18206 | |||
18207 | int stackSize = keepStackSize(); | ||
18208 | |||
18209 | try { | ||
18210 | // InternalProblem.g:5900:1: ( ( ruleInteger ) ) | ||
18211 | // InternalProblem.g:5901:2: ( ruleInteger ) | ||
18212 | { | ||
18213 | // InternalProblem.g:5901:2: ( ruleInteger ) | ||
18214 | // InternalProblem.g:5902:3: ruleInteger | ||
18215 | { | ||
18216 | before(grammarAccess.getIntConstantAccess().getIntValueIntegerParserRuleCall_0()); | ||
18217 | pushFollow(FOLLOW_2); | ||
18218 | ruleInteger(); | ||
18219 | |||
18220 | state._fsp--; | ||
18221 | |||
18222 | after(grammarAccess.getIntConstantAccess().getIntValueIntegerParserRuleCall_0()); | ||
18223 | |||
18224 | } | ||
18225 | |||
18226 | |||
18227 | } | ||
18228 | |||
18229 | } | ||
18230 | catch (RecognitionException re) { | ||
18231 | reportError(re); | ||
18232 | recover(input,re); | ||
18233 | } | ||
18234 | finally { | ||
18235 | |||
18236 | restoreStackSize(stackSize); | ||
18237 | |||
18238 | } | ||
18239 | return ; | ||
18240 | } | ||
18241 | // $ANTLR end "rule__IntConstant__IntValueAssignment" | ||
18242 | |||
18243 | |||
18244 | // $ANTLR start "rule__RealConstant__RealValueAssignment" | ||
18245 | // InternalProblem.g:5911:1: rule__RealConstant__RealValueAssignment : ( ruleReal ) ; | ||
18246 | public final void rule__RealConstant__RealValueAssignment() throws RecognitionException { | ||
18247 | |||
18248 | int stackSize = keepStackSize(); | ||
18249 | |||
18250 | try { | ||
18251 | // InternalProblem.g:5915:1: ( ( ruleReal ) ) | ||
18252 | // InternalProblem.g:5916:2: ( ruleReal ) | ||
18253 | { | ||
18254 | // InternalProblem.g:5916:2: ( ruleReal ) | ||
18255 | // InternalProblem.g:5917:3: ruleReal | ||
18256 | { | ||
18257 | before(grammarAccess.getRealConstantAccess().getRealValueRealParserRuleCall_0()); | ||
18258 | pushFollow(FOLLOW_2); | ||
18259 | ruleReal(); | ||
18260 | |||
18261 | state._fsp--; | ||
18262 | |||
18263 | after(grammarAccess.getRealConstantAccess().getRealValueRealParserRuleCall_0()); | ||
18264 | |||
18265 | } | ||
18266 | |||
18267 | |||
18268 | } | ||
18269 | |||
18270 | } | ||
18271 | catch (RecognitionException re) { | ||
18272 | reportError(re); | ||
18273 | recover(input,re); | ||
18274 | } | ||
18275 | finally { | ||
18276 | |||
18277 | restoreStackSize(stackSize); | ||
18278 | |||
18279 | } | ||
18280 | return ; | ||
18281 | } | ||
18282 | // $ANTLR end "rule__RealConstant__RealValueAssignment" | ||
18283 | |||
18284 | |||
18285 | // $ANTLR start "rule__StringConstant__StringValueAssignment" | ||
18286 | // InternalProblem.g:5926:1: rule__StringConstant__StringValueAssignment : ( RULE_STRING ) ; | ||
18287 | public final void rule__StringConstant__StringValueAssignment() throws RecognitionException { | ||
18288 | |||
18289 | int stackSize = keepStackSize(); | ||
18290 | |||
18291 | try { | ||
18292 | // InternalProblem.g:5930:1: ( ( RULE_STRING ) ) | ||
18293 | // InternalProblem.g:5931:2: ( RULE_STRING ) | ||
18294 | { | ||
18295 | // InternalProblem.g:5931:2: ( RULE_STRING ) | ||
18296 | // InternalProblem.g:5932:3: RULE_STRING | ||
18297 | { | ||
18298 | before(grammarAccess.getStringConstantAccess().getStringValueSTRINGTerminalRuleCall_0()); | ||
18299 | match(input,RULE_STRING,FOLLOW_2); | ||
18300 | after(grammarAccess.getStringConstantAccess().getStringValueSTRINGTerminalRuleCall_0()); | ||
18301 | |||
18302 | } | ||
18303 | |||
18304 | |||
18305 | } | ||
18306 | |||
18307 | } | ||
18308 | catch (RecognitionException re) { | ||
18309 | reportError(re); | ||
18310 | recover(input,re); | ||
18311 | } | ||
18312 | finally { | ||
18313 | |||
18314 | restoreStackSize(stackSize); | ||
18315 | |||
18316 | } | ||
18317 | return ; | ||
18318 | } | ||
18319 | // $ANTLR end "rule__StringConstant__StringValueAssignment" | ||
15055 | 18320 | ||
15056 | 18321 | ||
15057 | // $ANTLR start "rule__ScopeDeclaration__TypeScopesAssignment_1" | 18322 | // $ANTLR start "rule__ScopeDeclaration__TypeScopesAssignment_1" |
15058 | // InternalProblem.g:4896:1: rule__ScopeDeclaration__TypeScopesAssignment_1 : ( ruleTypeScope ) ; | 18323 | // InternalProblem.g:5941:1: rule__ScopeDeclaration__TypeScopesAssignment_1 : ( ruleTypeScope ) ; |
15059 | public final void rule__ScopeDeclaration__TypeScopesAssignment_1() throws RecognitionException { | 18324 | public final void rule__ScopeDeclaration__TypeScopesAssignment_1() throws RecognitionException { |
15060 | 18325 | ||
15061 | int stackSize = keepStackSize(); | 18326 | int stackSize = keepStackSize(); |
15062 | 18327 | ||
15063 | try { | 18328 | try { |
15064 | // InternalProblem.g:4900:1: ( ( ruleTypeScope ) ) | 18329 | // InternalProblem.g:5945:1: ( ( ruleTypeScope ) ) |
15065 | // InternalProblem.g:4901:2: ( ruleTypeScope ) | 18330 | // InternalProblem.g:5946:2: ( ruleTypeScope ) |
15066 | { | 18331 | { |
15067 | // InternalProblem.g:4901:2: ( ruleTypeScope ) | 18332 | // InternalProblem.g:5946:2: ( ruleTypeScope ) |
15068 | // InternalProblem.g:4902:3: ruleTypeScope | 18333 | // InternalProblem.g:5947:3: ruleTypeScope |
15069 | { | 18334 | { |
15070 | before(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); | 18335 | before(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); |
15071 | pushFollow(FOLLOW_2); | 18336 | pushFollow(FOLLOW_2); |
@@ -15096,17 +18361,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15096 | 18361 | ||
15097 | 18362 | ||
15098 | // $ANTLR start "rule__ScopeDeclaration__TypeScopesAssignment_2_1" | 18363 | // $ANTLR start "rule__ScopeDeclaration__TypeScopesAssignment_2_1" |
15099 | // InternalProblem.g:4911:1: rule__ScopeDeclaration__TypeScopesAssignment_2_1 : ( ruleTypeScope ) ; | 18364 | // InternalProblem.g:5956:1: rule__ScopeDeclaration__TypeScopesAssignment_2_1 : ( ruleTypeScope ) ; |
15100 | public final void rule__ScopeDeclaration__TypeScopesAssignment_2_1() throws RecognitionException { | 18365 | public final void rule__ScopeDeclaration__TypeScopesAssignment_2_1() throws RecognitionException { |
15101 | 18366 | ||
15102 | int stackSize = keepStackSize(); | 18367 | int stackSize = keepStackSize(); |
15103 | 18368 | ||
15104 | try { | 18369 | try { |
15105 | // InternalProblem.g:4915:1: ( ( ruleTypeScope ) ) | 18370 | // InternalProblem.g:5960:1: ( ( ruleTypeScope ) ) |
15106 | // InternalProblem.g:4916:2: ( ruleTypeScope ) | 18371 | // InternalProblem.g:5961:2: ( ruleTypeScope ) |
15107 | { | 18372 | { |
15108 | // InternalProblem.g:4916:2: ( ruleTypeScope ) | 18373 | // InternalProblem.g:5961:2: ( ruleTypeScope ) |
15109 | // InternalProblem.g:4917:3: ruleTypeScope | 18374 | // InternalProblem.g:5962:3: ruleTypeScope |
15110 | { | 18375 | { |
15111 | before(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); | 18376 | before(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); |
15112 | pushFollow(FOLLOW_2); | 18377 | pushFollow(FOLLOW_2); |
@@ -15137,21 +18402,21 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15137 | 18402 | ||
15138 | 18403 | ||
15139 | // $ANTLR start "rule__TypeScope__TargetTypeAssignment_0" | 18404 | // $ANTLR start "rule__TypeScope__TargetTypeAssignment_0" |
15140 | // InternalProblem.g:4926:1: rule__TypeScope__TargetTypeAssignment_0 : ( ( RULE_ID ) ) ; | 18405 | // InternalProblem.g:5971:1: rule__TypeScope__TargetTypeAssignment_0 : ( ( RULE_ID ) ) ; |
15141 | public final void rule__TypeScope__TargetTypeAssignment_0() throws RecognitionException { | 18406 | public final void rule__TypeScope__TargetTypeAssignment_0() throws RecognitionException { |
15142 | 18407 | ||
15143 | int stackSize = keepStackSize(); | 18408 | int stackSize = keepStackSize(); |
15144 | 18409 | ||
15145 | try { | 18410 | try { |
15146 | // InternalProblem.g:4930:1: ( ( ( RULE_ID ) ) ) | 18411 | // InternalProblem.g:5975:1: ( ( ( RULE_ID ) ) ) |
15147 | // InternalProblem.g:4931:2: ( ( RULE_ID ) ) | 18412 | // InternalProblem.g:5976:2: ( ( RULE_ID ) ) |
15148 | { | 18413 | { |
15149 | // InternalProblem.g:4931:2: ( ( RULE_ID ) ) | 18414 | // InternalProblem.g:5976:2: ( ( RULE_ID ) ) |
15150 | // InternalProblem.g:4932:3: ( RULE_ID ) | 18415 | // InternalProblem.g:5977:3: ( RULE_ID ) |
15151 | { | 18416 | { |
15152 | before(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); | 18417 | before(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); |
15153 | // InternalProblem.g:4933:3: ( RULE_ID ) | 18418 | // InternalProblem.g:5978:3: ( RULE_ID ) |
15154 | // InternalProblem.g:4934:4: RULE_ID | 18419 | // InternalProblem.g:5979:4: RULE_ID |
15155 | { | 18420 | { |
15156 | before(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1()); | 18421 | before(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1()); |
15157 | match(input,RULE_ID,FOLLOW_2); | 18422 | match(input,RULE_ID,FOLLOW_2); |
@@ -15182,24 +18447,24 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15182 | 18447 | ||
15183 | 18448 | ||
15184 | // $ANTLR start "rule__TypeScope__IncrementAssignment_1_0" | 18449 | // $ANTLR start "rule__TypeScope__IncrementAssignment_1_0" |
15185 | // InternalProblem.g:4945:1: rule__TypeScope__IncrementAssignment_1_0 : ( ( '+=' ) ) ; | 18450 | // InternalProblem.g:5990:1: rule__TypeScope__IncrementAssignment_1_0 : ( ( '+=' ) ) ; |
15186 | public final void rule__TypeScope__IncrementAssignment_1_0() throws RecognitionException { | 18451 | public final void rule__TypeScope__IncrementAssignment_1_0() throws RecognitionException { |
15187 | 18452 | ||
15188 | int stackSize = keepStackSize(); | 18453 | int stackSize = keepStackSize(); |
15189 | 18454 | ||
15190 | try { | 18455 | try { |
15191 | // InternalProblem.g:4949:1: ( ( ( '+=' ) ) ) | 18456 | // InternalProblem.g:5994:1: ( ( ( '+=' ) ) ) |
15192 | // InternalProblem.g:4950:2: ( ( '+=' ) ) | 18457 | // InternalProblem.g:5995:2: ( ( '+=' ) ) |
15193 | { | 18458 | { |
15194 | // InternalProblem.g:4950:2: ( ( '+=' ) ) | 18459 | // InternalProblem.g:5995:2: ( ( '+=' ) ) |
15195 | // InternalProblem.g:4951:3: ( '+=' ) | 18460 | // InternalProblem.g:5996:3: ( '+=' ) |
15196 | { | 18461 | { |
15197 | before(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); | 18462 | before(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); |
15198 | // InternalProblem.g:4952:3: ( '+=' ) | 18463 | // InternalProblem.g:5997:3: ( '+=' ) |
15199 | // InternalProblem.g:4953:4: '+=' | 18464 | // InternalProblem.g:5998:4: '+=' |
15200 | { | 18465 | { |
15201 | before(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); | 18466 | before(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); |
15202 | match(input,44,FOLLOW_2); | 18467 | match(input,47,FOLLOW_2); |
15203 | after(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); | 18468 | after(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); |
15204 | 18469 | ||
15205 | } | 18470 | } |
@@ -15227,17 +18492,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15227 | 18492 | ||
15228 | 18493 | ||
15229 | // $ANTLR start "rule__TypeScope__MultiplicityAssignment_2" | 18494 | // $ANTLR start "rule__TypeScope__MultiplicityAssignment_2" |
15230 | // InternalProblem.g:4964:1: rule__TypeScope__MultiplicityAssignment_2 : ( ruleDefiniteMultiplicity ) ; | 18495 | // InternalProblem.g:6009:1: rule__TypeScope__MultiplicityAssignment_2 : ( ruleDefiniteMultiplicity ) ; |
15231 | public final void rule__TypeScope__MultiplicityAssignment_2() throws RecognitionException { | 18496 | public final void rule__TypeScope__MultiplicityAssignment_2() throws RecognitionException { |
15232 | 18497 | ||
15233 | int stackSize = keepStackSize(); | 18498 | int stackSize = keepStackSize(); |
15234 | 18499 | ||
15235 | try { | 18500 | try { |
15236 | // InternalProblem.g:4968:1: ( ( ruleDefiniteMultiplicity ) ) | 18501 | // InternalProblem.g:6013:1: ( ( ruleDefiniteMultiplicity ) ) |
15237 | // InternalProblem.g:4969:2: ( ruleDefiniteMultiplicity ) | 18502 | // InternalProblem.g:6014:2: ( ruleDefiniteMultiplicity ) |
15238 | { | 18503 | { |
15239 | // InternalProblem.g:4969:2: ( ruleDefiniteMultiplicity ) | 18504 | // InternalProblem.g:6014:2: ( ruleDefiniteMultiplicity ) |
15240 | // InternalProblem.g:4970:3: ruleDefiniteMultiplicity | 18505 | // InternalProblem.g:6015:3: ruleDefiniteMultiplicity |
15241 | { | 18506 | { |
15242 | before(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); | 18507 | before(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); |
15243 | pushFollow(FOLLOW_2); | 18508 | pushFollow(FOLLOW_2); |
@@ -15268,17 +18533,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15268 | 18533 | ||
15269 | 18534 | ||
15270 | // $ANTLR start "rule__RangeMultiplicity__LowerBoundAssignment_0" | 18535 | // $ANTLR start "rule__RangeMultiplicity__LowerBoundAssignment_0" |
15271 | // InternalProblem.g:4979:1: rule__RangeMultiplicity__LowerBoundAssignment_0 : ( RULE_INT ) ; | 18536 | // InternalProblem.g:6024:1: rule__RangeMultiplicity__LowerBoundAssignment_0 : ( RULE_INT ) ; |
15272 | public final void rule__RangeMultiplicity__LowerBoundAssignment_0() throws RecognitionException { | 18537 | public final void rule__RangeMultiplicity__LowerBoundAssignment_0() throws RecognitionException { |
15273 | 18538 | ||
15274 | int stackSize = keepStackSize(); | 18539 | int stackSize = keepStackSize(); |
15275 | 18540 | ||
15276 | try { | 18541 | try { |
15277 | // InternalProblem.g:4983:1: ( ( RULE_INT ) ) | 18542 | // InternalProblem.g:6028:1: ( ( RULE_INT ) ) |
15278 | // InternalProblem.g:4984:2: ( RULE_INT ) | 18543 | // InternalProblem.g:6029:2: ( RULE_INT ) |
15279 | { | 18544 | { |
15280 | // InternalProblem.g:4984:2: ( RULE_INT ) | 18545 | // InternalProblem.g:6029:2: ( RULE_INT ) |
15281 | // InternalProblem.g:4985:3: RULE_INT | 18546 | // InternalProblem.g:6030:3: RULE_INT |
15282 | { | 18547 | { |
15283 | before(grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); | 18548 | before(grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); |
15284 | match(input,RULE_INT,FOLLOW_2); | 18549 | match(input,RULE_INT,FOLLOW_2); |
@@ -15305,17 +18570,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15305 | 18570 | ||
15306 | 18571 | ||
15307 | // $ANTLR start "rule__RangeMultiplicity__UpperBoundAssignment_2" | 18572 | // $ANTLR start "rule__RangeMultiplicity__UpperBoundAssignment_2" |
15308 | // InternalProblem.g:4994:1: rule__RangeMultiplicity__UpperBoundAssignment_2 : ( ruleUpperBound ) ; | 18573 | // InternalProblem.g:6039:1: rule__RangeMultiplicity__UpperBoundAssignment_2 : ( ruleUpperBound ) ; |
15309 | public final void rule__RangeMultiplicity__UpperBoundAssignment_2() throws RecognitionException { | 18574 | public final void rule__RangeMultiplicity__UpperBoundAssignment_2() throws RecognitionException { |
15310 | 18575 | ||
15311 | int stackSize = keepStackSize(); | 18576 | int stackSize = keepStackSize(); |
15312 | 18577 | ||
15313 | try { | 18578 | try { |
15314 | // InternalProblem.g:4998:1: ( ( ruleUpperBound ) ) | 18579 | // InternalProblem.g:6043:1: ( ( ruleUpperBound ) ) |
15315 | // InternalProblem.g:4999:2: ( ruleUpperBound ) | 18580 | // InternalProblem.g:6044:2: ( ruleUpperBound ) |
15316 | { | 18581 | { |
15317 | // InternalProblem.g:4999:2: ( ruleUpperBound ) | 18582 | // InternalProblem.g:6044:2: ( ruleUpperBound ) |
15318 | // InternalProblem.g:5000:3: ruleUpperBound | 18583 | // InternalProblem.g:6045:3: ruleUpperBound |
15319 | { | 18584 | { |
15320 | before(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); | 18585 | before(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); |
15321 | pushFollow(FOLLOW_2); | 18586 | pushFollow(FOLLOW_2); |
@@ -15346,17 +18611,17 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15346 | 18611 | ||
15347 | 18612 | ||
15348 | // $ANTLR start "rule__ExactMultiplicity__ExactValueAssignment" | 18613 | // $ANTLR start "rule__ExactMultiplicity__ExactValueAssignment" |
15349 | // InternalProblem.g:5009:1: rule__ExactMultiplicity__ExactValueAssignment : ( RULE_INT ) ; | 18614 | // InternalProblem.g:6054:1: rule__ExactMultiplicity__ExactValueAssignment : ( RULE_INT ) ; |
15350 | public final void rule__ExactMultiplicity__ExactValueAssignment() throws RecognitionException { | 18615 | public final void rule__ExactMultiplicity__ExactValueAssignment() throws RecognitionException { |
15351 | 18616 | ||
15352 | int stackSize = keepStackSize(); | 18617 | int stackSize = keepStackSize(); |
15353 | 18618 | ||
15354 | try { | 18619 | try { |
15355 | // InternalProblem.g:5013:1: ( ( RULE_INT ) ) | 18620 | // InternalProblem.g:6058:1: ( ( RULE_INT ) ) |
15356 | // InternalProblem.g:5014:2: ( RULE_INT ) | 18621 | // InternalProblem.g:6059:2: ( RULE_INT ) |
15357 | { | 18622 | { |
15358 | // InternalProblem.g:5014:2: ( RULE_INT ) | 18623 | // InternalProblem.g:6059:2: ( RULE_INT ) |
15359 | // InternalProblem.g:5015:3: RULE_INT | 18624 | // InternalProblem.g:6060:3: RULE_INT |
15360 | { | 18625 | { |
15361 | before(grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0()); | 18626 | before(grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0()); |
15362 | match(input,RULE_INT,FOLLOW_2); | 18627 | match(input,RULE_INT,FOLLOW_2); |
@@ -15384,46 +18649,34 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15384 | // Delegated rules | 18649 | // Delegated rules |
15385 | 18650 | ||
15386 | 18651 | ||
15387 | protected DFA8 dfa8 = new DFA8(this); | 18652 | protected DFA1 dfa1 = new DFA1(this); |
15388 | static final String dfa_1s = "\41\uffff"; | 18653 | protected DFA9 dfa9 = new DFA9(this); |
15389 | static final String dfa_2s = "\1\5\4\41\1\uffff\2\5\4\15\1\14\4\41\2\5\1\uffff\10\15\1\5\4\15"; | 18654 | static final String dfa_1s = "\24\uffff"; |
15390 | static final String dfa_3s = "\1\27\1\41\3\47\1\uffff\1\42\1\24\1\42\3\47\1\44\1\41\3\47\2\24\1\uffff\1\42\6\47\1\42\1\24\1\42\3\47"; | 18655 | static final String dfa_2s = "\1\5\3\uffff\6\45\3\uffff\1\5\6\45"; |
15391 | static final String dfa_4s = "\5\uffff\1\2\15\uffff\1\1\15\uffff"; | 18656 | static final String dfa_3s = "\1\56\3\uffff\1\50\5\53\3\uffff\1\26\5\53\1\50"; |
15392 | static final String dfa_5s = "\41\uffff}>"; | 18657 | static final String dfa_4s = "\1\uffff\1\1\1\2\1\3\6\uffff\1\4\1\6\1\5\7\uffff"; |
18658 | static final String dfa_5s = "\24\uffff}>"; | ||
15393 | static final String[] dfa_6s = { | 18659 | static final String[] dfa_6s = { |
15394 | "\1\1\1\2\14\uffff\1\3\1\4\1\uffff\2\5", | 18660 | "\1\4\1\5\11\uffff\1\3\2\uffff\1\6\1\7\1\10\1\11\3\uffff\2\12\1\uffff\1\1\3\uffff\1\2\7\uffff\1\13\2\uffff\1\1\1\uffff\1\3", |
15395 | "\1\6", | 18661 | "", |
15396 | "\1\6\5\uffff\1\7", | 18662 | "", |
15397 | "\1\6\5\uffff\1\7", | 18663 | "", |
15398 | "\1\6\5\uffff\1\7", | 18664 | "\1\12\2\uffff\1\14", |
18665 | "\1\12\2\uffff\1\14\2\uffff\1\15", | ||
18666 | "\1\12\2\uffff\1\14\2\uffff\1\15", | ||
18667 | "\1\12\2\uffff\1\14\2\uffff\1\15", | ||
18668 | "\1\12\2\uffff\1\14\2\uffff\1\15", | ||
18669 | "\1\12\2\uffff\1\14\2\uffff\1\15", | ||
15399 | "", | 18670 | "", |
15400 | "\1\10\1\11\14\uffff\1\12\1\13\15\uffff\1\14", | ||
15401 | "\1\15\1\16\14\uffff\1\17\1\20", | ||
15402 | "\1\21\24\uffff\1\14", | ||
15403 | "\1\21\24\uffff\1\14\4\uffff\1\22", | ||
15404 | "\1\21\24\uffff\1\14\4\uffff\1\22", | ||
15405 | "\1\21\24\uffff\1\14\4\uffff\1\22", | ||
15406 | "\1\5\27\uffff\1\23", | ||
15407 | "\1\6", | ||
15408 | "\1\6\5\uffff\1\7", | ||
15409 | "\1\6\5\uffff\1\7", | ||
15410 | "\1\6\5\uffff\1\7", | ||
15411 | "\1\24\1\25\14\uffff\1\26\1\27", | ||
15412 | "\1\33\1\30\14\uffff\1\31\1\32", | ||
15413 | "", | 18671 | "", |
15414 | "\1\21\24\uffff\1\14", | 18672 | "", |
15415 | "\1\21\24\uffff\1\14\4\uffff\1\34", | 18673 | "\1\23\1\16\14\uffff\1\17\1\20\1\21\1\22", |
15416 | "\1\21\24\uffff\1\14\4\uffff\1\34", | 18674 | "\1\12\2\uffff\1\14\2\uffff\1\15", |
15417 | "\1\21\24\uffff\1\14\4\uffff\1\34", | 18675 | "\1\12\2\uffff\1\14\2\uffff\1\15", |
15418 | "\1\21\24\uffff\1\14\4\uffff\1\22", | 18676 | "\1\12\2\uffff\1\14\2\uffff\1\15", |
15419 | "\1\21\24\uffff\1\14\4\uffff\1\22", | 18677 | "\1\12\2\uffff\1\14\2\uffff\1\15", |
15420 | "\1\21\24\uffff\1\14\4\uffff\1\22", | 18678 | "\1\12\2\uffff\1\14\2\uffff\1\15", |
15421 | "\1\21\24\uffff\1\14", | 18679 | "\1\12\2\uffff\1\14" |
15422 | "\1\35\1\36\14\uffff\1\37\1\40", | ||
15423 | "\1\21\24\uffff\1\14", | ||
15424 | "\1\21\24\uffff\1\14\4\uffff\1\34", | ||
15425 | "\1\21\24\uffff\1\14\4\uffff\1\34", | ||
15426 | "\1\21\24\uffff\1\14\4\uffff\1\34" | ||
15427 | }; | 18680 | }; |
15428 | 18681 | ||
15429 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); | 18682 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); |
@@ -15433,11 +18686,11 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15433 | static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); | 18686 | static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); |
15434 | static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); | 18687 | static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); |
15435 | 18688 | ||
15436 | class DFA8 extends DFA { | 18689 | class DFA1 extends DFA { |
15437 | 18690 | ||
15438 | public DFA8(BaseRecognizer recognizer) { | 18691 | public DFA1(BaseRecognizer recognizer) { |
15439 | this.recognizer = recognizer; | 18692 | this.recognizer = recognizer; |
15440 | this.decisionNumber = 8; | 18693 | this.decisionNumber = 1; |
15441 | this.eot = dfa_1; | 18694 | this.eot = dfa_1; |
15442 | this.eof = dfa_1; | 18695 | this.eof = dfa_1; |
15443 | this.min = dfa_2; | 18696 | this.min = dfa_2; |
@@ -15447,49 +18700,151 @@ public class InternalProblemParser extends AbstractInternalContentAssistParser { | |||
15447 | this.transition = dfa_6; | 18700 | this.transition = dfa_6; |
15448 | } | 18701 | } |
15449 | public String getDescription() { | 18702 | public String getDescription() { |
15450 | return "874:1: rule__Assertion__Alternatives_0 : ( ( ( rule__Assertion__Group_0_0__0 ) ) | ( ( rule__Assertion__Group_0_1__0 ) ) );"; | 18703 | return "1033:1: rule__Statement__Alternatives : ( ( ruleClassDeclaration ) | ( ruleEnumDeclaration ) | ( rulePredicateDefinition ) | ( ruleAssertion ) | ( ruleNodeValueAssertion ) | ( ruleScopeDeclaration ) );"; |
18704 | } | ||
18705 | } | ||
18706 | static final String dfa_7s = "\101\uffff"; | ||
18707 | static final String dfa_8s = "\1\5\6\45\1\uffff\1\4\1\5\6\15\1\4\1\14\1\15\1\14\6\45\1\4\1\5\3\4\1\uffff\6\15\1\4\1\14\10\15\2\4\1\15\1\5\3\4\7\15\2\4\1\15"; | ||
18708 | static final String dfa_9s = "\1\33\1\45\5\53\1\uffff\1\46\1\26\1\46\5\53\1\4\2\46\1\50\1\45\5\53\1\27\1\26\1\4\2\30\1\uffff\1\46\5\53\1\4\3\46\5\53\1\46\2\4\1\46\1\26\1\4\2\30\5\53\2\46\2\4\1\46"; | ||
18709 | static final String dfa_10s = "\7\uffff\1\2\27\uffff\1\1\41\uffff"; | ||
18710 | static final String dfa_11s = "\101\uffff}>"; | ||
18711 | static final String[] dfa_12s = { | ||
18712 | "\1\1\1\2\14\uffff\1\3\1\4\1\5\1\6\3\uffff\2\7", | ||
18713 | "\1\10", | ||
18714 | "\1\10\5\uffff\1\11", | ||
18715 | "\1\10\5\uffff\1\11", | ||
18716 | "\1\10\5\uffff\1\11", | ||
18717 | "\1\10\5\uffff\1\11", | ||
18718 | "\1\10\5\uffff\1\11", | ||
18719 | "", | ||
18720 | "\1\21\1\12\1\13\1\22\13\uffff\1\14\1\15\1\16\1\17\1\20\16\uffff\1\23", | ||
18721 | "\1\24\1\25\14\uffff\1\26\1\27\1\30\1\31", | ||
18722 | "\1\32\30\uffff\1\23", | ||
18723 | "\1\32\30\uffff\1\23\4\uffff\1\33", | ||
18724 | "\1\32\30\uffff\1\23\4\uffff\1\33", | ||
18725 | "\1\32\30\uffff\1\23\4\uffff\1\33", | ||
18726 | "\1\32\30\uffff\1\23\4\uffff\1\33", | ||
18727 | "\1\32\30\uffff\1\23\4\uffff\1\33", | ||
18728 | "\1\21", | ||
18729 | "\1\34\1\32\7\uffff\1\35\1\36\17\uffff\1\23", | ||
18730 | "\1\32\30\uffff\1\23", | ||
18731 | "\1\7\33\uffff\1\37", | ||
18732 | "\1\10", | ||
18733 | "\1\10\5\uffff\1\11", | ||
18734 | "\1\10\5\uffff\1\11", | ||
18735 | "\1\10\5\uffff\1\11", | ||
18736 | "\1\10\5\uffff\1\11", | ||
18737 | "\1\10\5\uffff\1\11", | ||
18738 | "\1\47\1\40\1\41\1\50\13\uffff\1\42\1\43\1\44\1\45\1\46", | ||
18739 | "\1\51\1\52\14\uffff\1\53\1\54\1\55\1\56", | ||
18740 | "\1\57", | ||
18741 | "\1\62\22\uffff\1\60\1\61", | ||
18742 | "\1\62\22\uffff\1\60\1\61", | ||
18743 | "", | ||
18744 | "\1\32\30\uffff\1\23", | ||
18745 | "\1\32\30\uffff\1\23\4\uffff\1\63", | ||
18746 | "\1\32\30\uffff\1\23\4\uffff\1\63", | ||
18747 | "\1\32\30\uffff\1\23\4\uffff\1\63", | ||
18748 | "\1\32\30\uffff\1\23\4\uffff\1\63", | ||
18749 | "\1\32\30\uffff\1\23\4\uffff\1\63", | ||
18750 | "\1\47", | ||
18751 | "\1\64\1\32\7\uffff\1\65\1\66\17\uffff\1\23", | ||
18752 | "\1\32\30\uffff\1\23", | ||
18753 | "\1\32\30\uffff\1\23", | ||
18754 | "\1\32\30\uffff\1\23\4\uffff\1\33", | ||
18755 | "\1\32\30\uffff\1\23\4\uffff\1\33", | ||
18756 | "\1\32\30\uffff\1\23\4\uffff\1\33", | ||
18757 | "\1\32\30\uffff\1\23\4\uffff\1\33", | ||
18758 | "\1\32\30\uffff\1\23\4\uffff\1\33", | ||
18759 | "\1\32\7\uffff\1\35\1\36\17\uffff\1\23", | ||
18760 | "\1\62", | ||
18761 | "\1\62", | ||
18762 | "\1\32\30\uffff\1\23", | ||
18763 | "\1\74\1\67\14\uffff\1\70\1\71\1\72\1\73", | ||
18764 | "\1\75", | ||
18765 | "\1\100\22\uffff\1\76\1\77", | ||
18766 | "\1\100\22\uffff\1\76\1\77", | ||
18767 | "\1\32\30\uffff\1\23\4\uffff\1\63", | ||
18768 | "\1\32\30\uffff\1\23\4\uffff\1\63", | ||
18769 | "\1\32\30\uffff\1\23\4\uffff\1\63", | ||
18770 | "\1\32\30\uffff\1\23\4\uffff\1\63", | ||
18771 | "\1\32\30\uffff\1\23\4\uffff\1\63", | ||
18772 | "\1\32\30\uffff\1\23", | ||
18773 | "\1\32\7\uffff\1\65\1\66\17\uffff\1\23", | ||
18774 | "\1\100", | ||
18775 | "\1\100", | ||
18776 | "\1\32\30\uffff\1\23" | ||
18777 | }; | ||
18778 | |||
18779 | static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); | ||
18780 | static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s); | ||
18781 | static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); | ||
18782 | static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s); | ||
18783 | static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); | ||
18784 | static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s); | ||
18785 | |||
18786 | class DFA9 extends DFA { | ||
18787 | |||
18788 | public DFA9(BaseRecognizer recognizer) { | ||
18789 | this.recognizer = recognizer; | ||
18790 | this.decisionNumber = 9; | ||
18791 | this.eot = dfa_7; | ||
18792 | this.eof = dfa_7; | ||
18793 | this.min = dfa_8; | ||
18794 | this.max = dfa_9; | ||
18795 | this.accept = dfa_10; | ||
18796 | this.special = dfa_11; | ||
18797 | this.transition = dfa_12; | ||
18798 | } | ||
18799 | public String getDescription() { | ||
18800 | return "1225:1: rule__Assertion__Alternatives_0 : ( ( ( rule__Assertion__Group_0_0__0 ) ) | ( ( rule__Assertion__Group_0_1__0 ) ) );"; | ||
15451 | } | 18801 | } |
15452 | } | 18802 | } |
15453 | 18803 | ||
15454 | 18804 | ||
15455 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); | 18805 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); |
15456 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); | 18806 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); |
15457 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000052022D90060L}); | 18807 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x000052022C790060L}); |
15458 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000052022D90062L}); | 18808 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x000052022C790062L}); |
15459 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000180060L}); | 18809 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000780060L}); |
15460 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000001000L}); | 18810 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000001000L}); |
15461 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000010002000000L}); | 18811 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000100020000000L}); |
15462 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x000000000C001000L}); | 18812 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x00000000C0001000L}); |
15463 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000002000L}); | 18813 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000002000L}); |
15464 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000002002L}); | 18814 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000002002L}); |
15465 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000020010188060L}); | 18815 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000200100788060L}); |
15466 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000020000188062L}); | 18816 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000200000788062L}); |
15467 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000004000L}); | 18817 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000004000L}); |
15468 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000008001000L}); | 18818 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000080001000L}); |
15469 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000010180060L}); | 18819 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000100780060L}); |
15470 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000006000L}); | 18820 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000006000L}); |
15471 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000020000188060L}); | 18821 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000200000788060L}); |
15472 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000040180060L}); | 18822 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000400780060L}); |
15473 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000100000000L}); | 18823 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000001000000000L}); |
15474 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000010L}); | 18824 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000010L}); |
15475 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000080000000L}); | 18825 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000800000000L}); |
15476 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000200000000L}); | 18826 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000002000000000L}); |
15477 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000400180060L}); | 18827 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000004000780060L}); |
15478 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000800001000L}); | 18828 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000008000001000L}); |
15479 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000010000L}); | 18829 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000010000L}); |
15480 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000580060L}); | 18830 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000004780060L}); |
15481 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000004002L}); | 18831 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000004002L}); |
15482 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000080200000000L}); | 18832 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000002001000000L}); |
15483 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000001000000000L}); | 18833 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000004000F800F0L}); |
15484 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000000380000L}); | 18834 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000000F800F0L}); |
15485 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000D80060L}); | 18835 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000010000000000L}); |
15486 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000000040L}); | 18836 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000002180000L}); |
15487 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000000003000L}); | 18837 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x000000000C780060L}); |
15488 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000100000020000L}); | 18838 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000040L}); |
15489 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000004000000000L}); | 18839 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000003000L}); |
15490 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000040010L}); | 18840 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000800000020000L}); |
15491 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000008000000000L}); | 18841 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000040000000000L}); |
15492 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000008000000002L}); | 18842 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000040010L}); |
15493 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000020L}); | 18843 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000080000000000L}); |
18844 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000080000000002L}); | ||
18845 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000020L}); | ||
18846 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000800010L}); | ||
18847 | public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000601000L}); | ||
18848 | public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000001800010L}); | ||
15494 | 18849 | ||
15495 | } \ No newline at end of file | 18850 | } \ No newline at end of file |