diff --git a/ba/doc/conformance.md b/ba/doc/conformance.md index b3c95ed058..be778fc016 100644 --- a/ba/doc/conformance.md +++ b/ba/doc/conformance.md @@ -60,7 +60,7 @@ The review itself was a source and test-artifact audit. No Maven tests, simulato | D.3: behavior specification | Variables, grouped states, state kinds, named/prioritized and multiple-source transitions, execute conditions, and dispatch/external conditions. State and transition legality checks have dedicated tests. | Partial. Internal conditions (G01), complete external-condition expressions (G02), naming and otherwise-transition rules (V01 and V02), and complete-state mode binding (G14) were absent and are now implemented; multiple subprogram final states are rejected unconditionally, and several consistency obligations lack demonstrated enforcement. | | D.4: thread dispatch | Dispatch conjunction/disjunction, `stop`, bare timeout, timeout with a duration, and an unparenthesized frozen-port list. Selected timeout/stop checks exist. | Partial. Required frozen-list parentheses were missing (G03) and timeout reset ports absent (G04), both since fixed. Full protocol/trigger compatibility and core-property consistency are not demonstrated. | | D.5: component interactions | Port send/dequeue/freeze, count/fresh/updated, shared-data lock/unlock syntax, and subprogram-call syntax/model classes. | Partial. `updated` was absent (G07), internal events were represented incorrectly (G10), and outgoing ports were accepted for the three input-freeze status values, all since fixed; call-signature and remaining communication direction/category checks need additional coverage. Input/output timing consistency is not established. | -| D.6: action language | Assignment/`any`, sequences and sets, blocks, conditionals, explicit-type loops, timed actions and processor bindings. Conflicting assignments in action sets and static minimum/maximum computation-time checks exist. | Partial. Type conformance is disabled outright, so no assignment, send, dequeue, range, or parameter type mismatch is reported (G18). Optional loop classifiers are missing; loop-variable assignment rejection was not enforced by the existing covering-test expectation (G16, since fixed, though the dequeue form is still open as [#3205](https://github.com/osate/osate2/issues/3205)); action-timeout catch and combination rules are now checked (V03), while resource-release and signature obligations remain incomplete or unverified. | +| D.6: action language | Assignment/`any`, sequences and sets, blocks, conditionals, loops with a written or an omitted iterator classifier, timed actions and processor bindings. Conflicting assignments in action sets and static minimum/maximum computation-time checks exist. | Partial. Type conformance is disabled outright, so no assignment, send, dequeue, range, or parameter type mismatch is reported (G18). Optional loop classifiers were missing (G09) and are now implemented; loop-variable assignment rejection was not enforced by the existing covering-test expectation (G16, since fixed, though the dequeue form is still open as [#3205](https://github.com/osate/osate2/issues/3205)); action-timeout catch and combination rules are now checked (V03), while resource-release and signature obligations remain incomplete or unverified. | | D.7: expressions | Boolean/numeric/string syntax, arithmetic/relational/logical operators, property references, indexing, and operator applicability checks per operand data representation. | Partial, with semantic preservation defects. Operand consistency between the two operands is not checked, only applicability of the operator to the first one (G18). Short-circuit logical operators, including in external conditions, and `updated` are now supported (#3166, #3169, and G07, since fixed), and value-expression precedence, association, admissible forms, and grouping now follow the document (G13, since fixed); numeric translation differs from the document, unary plus remains accepted as an extension but now produces a compatibility warning (G06), and initialization analysis is not demonstrated. | | D.8: synchronization | `Behavior_Properties::Subprogram_Call_Protocol` declares HSER/LSER/ASER and defaults to HSER, matching the supplied document. A client/server example exists. | Property definition conforms. Enforcement of the two LSER/ASER legality rules and execution of the protocols are not established. | @@ -80,7 +80,7 @@ All ten categories appear in [BehaviorAnnexConformanceTest](../../ba/org.osate.b | G06 | D.7 `unary_adding_operator` contains only minus. | `UnaryExpression` explicitly accepts plus. **Addressed by [#3170](https://github.com/osate/osate2/issues/3170) with a deliberate compatibility policy:** the declarative validator reports a warning on the unary `+` token while the grammar and strict-model translation continue to accept and preserve the extension. `UnaryPlus.aadl` has an exact validated-diagnostics golden, and the active expectation asserts the warning code, message, severity, and location. | Deliberate warned extension rather than strict grammar rejection. | | G07 | D.5 port-service table and D.7 `value_variable` include `p'updated`. | `ReferenceExpression` and `UnindexedReferenceExpression` permit only count/fresh suffixes. `PortUpdated.aadl` records a syntax error. | Source-confirmed missing operation. **Addressed by [#3171](https://github.com/osate/osate2/issues/3171):** both rules gained the suffix, the strict model a `PortUpdatedValue` beside `PortCountValue` and `PortFreshValue`, and the type rules the universal Boolean those two already establish, so the value carries no data classifier and applies to a data-less event port. The generated sequencers emit it, so it round-trips. **The follow-up direction gap is addressed by [#3217](https://github.com/osate/osate2/issues/3217):** the validator reports `count`, `fresh`, and `updated` on an outgoing port and accepts incoming and bidirectional ports, which are frozen on input. This deliberately enforces the semantics of the three D.5 definitions; neither the D.5 nor the D.7 legality rules states the restriction, and the diagnostic says so. | | G08 | D.7 component-element property references include `self`. | The translator now recognizes the text `self`, so the old expected “not found” diagnosis is stale. However, the strict golden for `SelfPropertyReference.aadl` contains `ClassifierFeaturePropertyReference.component : BehaviorVariableHolder element=`. The source returns an empty holder before recording the owner against the complete prefix reference. | Partial syntactic/name recognition, still a source-confirmed translation gap. **Step 1 made it visible:** with the validator registered the fixture reports `resolved behavior annex holder has no element`, so the finding is now asserted rather than hidden behind an empty golden. **Addressed by [#3172](https://github.com/osate/osate2/issues/3172):** the resolver records the containing classifier against the complete prefix reference, so `self#Priority` becomes a `ClassifierPropertyReference` on that classifier, and its property name resolves to the classifier's own association. No holder can carry a classifier, so a bare `self` remains an unresolved holder in the positions that need a value, where D.7 does not admit it. | -| G09 | D.6 `for` and `forall` make `: data_unique_component_classifier_reference` optional. | `ForStatement` requires the colon and classifier. Both optional-classifier fixtures record syntax errors. | Source-confirmed missing syntax; inferred iterator types also need semantic support. | +| G09 | D.6 `for` and `forall` make `: data_unique_component_classifier_reference` optional. | `ForStatement` requires the colon and classifier. Both optional-classifier fixtures record syntax errors. | Source-confirmed missing syntax; inferred iterator types also need semantic support. **Addressed by [#3173](https://github.com/osate/osate2/issues/3173):** the grammar makes the colon and classifier optional, and the iterator then takes the type the D.6 semantics give it: an integer range makes it a universal integer, which no data classifier denotes and which the type holder of an iterator now reports the way a port count value already did, while a port or a data component supplies the classifier of its own elements, which for a Data Model array is the array's base type. Translation resolves the omitted classifier from the iterated values, the way it resolves every other name in the annex, so the strict model carries the iterator's type and no reader has to infer it: `getClassifier`, the type holder, the data representation, and the resolver's own data-element lookup through an iterator all read the one field. The integer range is the exception, having no classifier to resolve, so its universal integer comes from the loop, exactly as a port count value's does. An instance-context resolution was considered and rejected: the answer does not vary with the component that asks, because the properties and the prototype constraint below are read from classifiers and the checker is handed the annex's own owner in every path. The check that the iterator has a resolved data classifier could no longer tell an omitted classifier from a written one of another category, so the requirement that a written classifier be a data classifier moved to the declarative validator, which reports it on the reference as written. What is still outstanding is the part the standard makes instance-dependent, and it is pre-existing: the same lookup already types the iterated values of a loop whose classifier is written, so making the classifier optional inherits it rather than introducing it, and resolving it at translation rather than on demand does not change it. `Data_Representation` and `Base_Type` are looked up on the data classifier of the iterated element, so an association on the element itself is not consulted, contained or not. Iterated values typed by a prototype resolve to the prototype's constraining classifier: a legal model that declares `buffer : data element_type [3]` under `element_type : data Base_Types::Integer` and binds `element_type => data Base_Types::Float` on one subcomponent and `Base_Types::Integer` on another validates with no diagnostic, and the iterator is typed `Base_Types::Integer` for both, because a prototype bound on a subcomponent is not reachable from the classifier the checker is given. Closing that needs an instance-context resolution, not a different declarative container. | | G10 | D.5–D.6 allow internal ports as assignment targets and internal-event send actions. | The internal-action diagnostics golden is now empty, but its strict golden maps the event-data target to `DataSubcomponentHolder [EventDataSource]` and the event send to `SubprogramCallAction` with an `EventSource` proxy. `createHolder` has no internal-feature specialization and falls back to a data-subcomponent holder. | Source-confirmed incorrect representation; acceptance is not correct internal-event support. Step 1 confirmed that on `master` the fixture is accepted with zero diagnostics even with the validator registered, so `internalPortActionsAreAcceptedByTheStandard` was left skipped with that reason recorded: it would have passed for the wrong reason, and closing #3174 needed a strict-model assertion. That expectation is active now that the representation is correct. **Addressed by [#3198](https://github.com/osate/osate2/pull/3198):** `InternalPortHolder`, `EventSourceHolder`, `EventDataSourceHolder`, and `InternalPortSendAction` were added. Running the checkers over the fixture on that branch also showed that this row understated the defect: with the validator registered, the resolver rejected the legal actions with `getClassifier : EventDataSourceImpl is not supported yet`. | Current output evidence is in [expected/diagnostics](../../ba/org.osate.ba.tests/expected/diagnostics) and [expected/resolved-model](../../ba/org.osate.ba.tests/expected/resolved-model), using filenames beginning `org.osate.ba.tests_models_characterization_conformance_`. diff --git a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt index 03e102dc7d..e69de29bb2 100644 --- a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt +++ b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt @@ -1,6 +0,0 @@ -error | linking | 17 | 15 | 1 | Couldn't resolve reference to BehaviorState 'i'. -error | linking | 17 | 6 | 5 | Couldn't resolve reference to BehaviorState 'value'. -error | syntax | 16 | 12 | 2 | mismatched input 'in' expecting ':' -error | syntax | 17 | 12 | 2 | mismatched input ':=' expecting '-[' -error | syntax | 17 | 6 | 5 | mismatched input 'value' expecting '}' -error | syntax | 18 | 5 | 1 | mismatched input '}' expecting '-[' diff --git a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt index cf0f971ed4..e69de29bb2 100644 --- a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt +++ b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt @@ -1,6 +0,0 @@ -error | linking | 17 | 15 | 1 | Couldn't resolve reference to BehaviorState 'i'. -error | linking | 17 | 6 | 5 | Couldn't resolve reference to BehaviorState 'value'. -error | syntax | 16 | 15 | 2 | mismatched input 'in' expecting ':' -error | syntax | 17 | 12 | 2 | mismatched input ':=' expecting '-[' -error | syntax | 17 | 6 | 5 | mismatched input 'value' expecting '}' -error | syntax | 18 | 5 | 1 | mismatched input '}' expecting '-[' diff --git a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3173_Issue3173.txt b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3173_Issue3173.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt new file mode 100644 index 0000000000..23b149231c --- /dev/null +++ b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt @@ -0,0 +1,2 @@ +error | semantic | 49 | 29 | 6 | 'helper' is not a data classifier: a for or forall iterator can only name a data component classifier +error | semantic | 54 | 33 | 11 | 'helper.impl' is not a data classifier: a for or forall iterator can only name a data component classifier diff --git a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt index 03e102dc7d..e69de29bb2 100644 --- a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt +++ b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt @@ -1,6 +0,0 @@ -error | linking | 17 | 15 | 1 | Couldn't resolve reference to BehaviorState 'i'. -error | linking | 17 | 6 | 5 | Couldn't resolve reference to BehaviorState 'value'. -error | syntax | 16 | 12 | 2 | mismatched input 'in' expecting ':' -error | syntax | 17 | 12 | 2 | mismatched input ':=' expecting '-[' -error | syntax | 17 | 6 | 5 | mismatched input 'value' expecting '}' -error | syntax | 18 | 5 | 1 | mismatched input '}' expecting '-[' diff --git a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt index cf0f971ed4..e69de29bb2 100644 --- a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt +++ b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt @@ -1,6 +0,0 @@ -error | linking | 17 | 15 | 1 | Couldn't resolve reference to BehaviorState 'i'. -error | linking | 17 | 6 | 5 | Couldn't resolve reference to BehaviorState 'value'. -error | syntax | 16 | 15 | 2 | mismatched input 'in' expecting ':' -error | syntax | 17 | 12 | 2 | mismatched input ':=' expecting '-[' -error | syntax | 17 | 6 | 5 | mismatched input 'value' expecting '}' -error | syntax | 18 | 5 | 1 | mismatched input '}' expecting '-[' diff --git a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3173_Issue3173.txt b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3173_Issue3173.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt index 97e33840e5..f1a3cd2e83 100644 --- a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt @@ -1,13 +1,20 @@ annex[0] owner=OptionalForClassifier::operation - (BehaviorActionBlock, , 352, 25) + (AssignmentAction, , 383, 10) + (BehaviorActionBlock, , 352, 52) (BehaviorAnnex, behavior_specification, 216, 189) + (BehaviorIntegerLiteral, , 368, 1) + (BehaviorIntegerLiteral, , 373, 1) (BehaviorState, finish, 294, 6) (BehaviorState, start, 269, 5) (BehaviorStateGroup, , 269, 21) (BehaviorStateGroup, , 294, 20) - (BehaviorTransition, , 332, 45) - (BehaviorTransition, , 383, 8) - (BehaviorTransition, , 392, 13) + (BehaviorTransition, , 332, 73) (BehaviorVariable, value, 229, 5) (BehaviorVariableGroup, , 229, 27) - (ForStatement, , 358, 19) + (ElementValues, , 368, 6) + (ForStatement, , 358, 41) + (Reference, , 383, 5) + (Reference, , 392, 1) + (ReferenceExpression, , 392, 1) + (ReferenceSegment, i, 392, 1) + (ReferenceSegment, value, 383, 5) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt index c4a3cde125..0953b29d65 100644 --- a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt @@ -1,13 +1,20 @@ annex[0] owner=OptionalForallClassifier::operation - (BehaviorActionBlock, , 355, 28) + (AssignmentAction, , 389, 10) + (BehaviorActionBlock, , 355, 55) (BehaviorAnnex, behavior_specification, 219, 192) + (BehaviorIntegerLiteral, , 374, 1) + (BehaviorIntegerLiteral, , 379, 1) (BehaviorState, finish, 297, 6) (BehaviorState, start, 272, 5) (BehaviorStateGroup, , 272, 21) (BehaviorStateGroup, , 297, 20) - (BehaviorTransition, , 335, 48) - (BehaviorTransition, , 389, 8) - (BehaviorTransition, , 398, 13) + (BehaviorTransition, , 335, 76) (BehaviorVariable, value, 232, 5) (BehaviorVariableGroup, , 232, 27) - (ForStatement, , 361, 22) + (ElementValues, , 374, 6) + (ForStatement, , 361, 44) + (Reference, , 389, 5) + (Reference, , 398, 1) + (ReferenceExpression, , 398, 1) + (ReferenceSegment, i, 398, 1) + (ReferenceSegment, value, 389, 5) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3173_Issue3173.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3173_Issue3173.txt new file mode 100644 index 0000000000..27a91d73ed --- /dev/null +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3173_Issue3173.txt @@ -0,0 +1,113 @@ +annex[0] owner=Issue3173::worker.i + (AssignmentAction, , 3431, 21) + (AssignmentAction, , 3595, 22) + (AssignmentAction, , 3758, 23) + (AssignmentAction, , 3922, 24) + (AssignmentAction, , 4099, 33) + (AssignmentAction, , 4300, 22) + (BehaviorActionBlock, , 3370, 114) + (BehaviorActionBlock, , 3530, 119) + (BehaviorActionBlock, , 3693, 120) + (BehaviorActionBlock, , 3857, 121) + (BehaviorActionBlock, , 4035, 129) + (BehaviorActionBlock, , 4216, 138) + (BehaviorAnnex, behavior_specification, 3139, 1216) + (BehaviorIntegerLiteral, , 3401, 1) + (BehaviorIntegerLiteral, , 3406, 1) + (BehaviorIntegerLiteral, , 3565, 1) + (BehaviorIntegerLiteral, , 3570, 1) + (BehaviorIntegerLiteral, , 4270, 1) + (BehaviorIntegerLiteral, , 4275, 1) + (BehaviorState, done, 3279, 4) + (BehaviorState, start, 3244, 5) + (BehaviorStateGroup, , 3244, 22) + (BehaviorStateGroup, , 3279, 28) + (BehaviorTransition, array_loop, 3827, 152) + (BehaviorTransition, data_model_array_forall, 3992, 173) + (BehaviorTransition, queue_loop, 3663, 151) + (BehaviorTransition, range_forall, 3498, 152) + (BehaviorTransition, range_loop, 3340, 145) + (BehaviorTransition, written_classifier, 4178, 177) + (BehaviorVariable, pairs, 3202, 5) + (BehaviorVariable, total, 3161, 5) + (BehaviorVariableGroup, , 3161, 28) + (BehaviorVariableGroup, , 3202, 14) + (BinaryExpression, , 3440, 12) + (BinaryExpression, , 3604, 13) + (BinaryExpression, , 3767, 14) + (BinaryExpression, , 3931, 15) + (BinaryExpression, , 4108, 24) + (BinaryExpression, , 4309, 13) + (ElementValues, , 3401, 6) + (ElementValues, , 3565, 6) + (ElementValues, , 3726, 8) + (ElementValues, , 3891, 7) + (ElementValues, , 4070, 5) + (ElementValues, , 4270, 6) + (ForStatement, , 3388, 82) + (ForStatement, , 3548, 87) + (ForStatement, , 3711, 88) + (ForStatement, , 3875, 89) + (ForStatement, , 4053, 97) + (ForStatement, , 4234, 106) + (Reference, , 3431, 5) + (Reference, , 3440, 4) + (Reference, , 3447, 5) + (Reference, , 3595, 5) + (Reference, , 3604, 5) + (Reference, , 3612, 5) + (Reference, , 3726, 8) + (Reference, , 3758, 5) + (Reference, , 3767, 6) + (Reference, , 3776, 5) + (Reference, , 3891, 7) + (Reference, , 3922, 5) + (Reference, , 3931, 7) + (Reference, , 3941, 5) + (Reference, , 4070, 5) + (Reference, , 4099, 5) + (Reference, , 4108, 10) + (Reference, , 4121, 11) + (Reference, , 4300, 5) + (Reference, , 4309, 5) + (Reference, , 4317, 5) + (ReferenceExpression, , 3440, 4) + (ReferenceExpression, , 3447, 5) + (ReferenceExpression, , 3604, 5) + (ReferenceExpression, , 3612, 5) + (ReferenceExpression, , 3726, 8) + (ReferenceExpression, , 3767, 6) + (ReferenceExpression, , 3776, 5) + (ReferenceExpression, , 3891, 7) + (ReferenceExpression, , 3931, 7) + (ReferenceExpression, , 3941, 5) + (ReferenceExpression, , 4070, 5) + (ReferenceExpression, , 4108, 10) + (ReferenceExpression, , 4121, 11) + (ReferenceExpression, , 4309, 5) + (ReferenceExpression, , 4317, 5) + (ReferenceSegment, element, 3931, 7) + (ReferenceSegment, entry, 4108, 5) + (ReferenceSegment, entry, 4121, 5) + (ReferenceSegment, history, 3891, 7) + (ReferenceSegment, left, 4114, 4) + (ReferenceSegment, other, 3604, 5) + (ReferenceSegment, pairs, 4070, 5) + (ReferenceSegment, readings, 3726, 8) + (ReferenceSegment, right, 4127, 5) + (ReferenceSegment, sample, 3767, 6) + (ReferenceSegment, step, 3440, 4) + (ReferenceSegment, total, 3431, 5) + (ReferenceSegment, total, 3447, 5) + (ReferenceSegment, total, 3595, 5) + (ReferenceSegment, total, 3612, 5) + (ReferenceSegment, total, 3758, 5) + (ReferenceSegment, total, 3776, 5) + (ReferenceSegment, total, 3922, 5) + (ReferenceSegment, total, 3941, 5) + (ReferenceSegment, total, 4099, 5) + (ReferenceSegment, total, 4300, 5) + (ReferenceSegment, total, 4317, 5) + (ReferenceSegment, typed, 4309, 5) + (ReferenceTail, , 4113, 5) + (ReferenceTail, , 4126, 6) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt new file mode 100644 index 0000000000..2f28841e48 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt @@ -0,0 +1,40 @@ +annex[0] owner=NonDataIteratorClassifier::worker.i + (AssignmentAction, , 2716, 21) + (AssignmentAction, , 2911, 22) + (BehaviorActionBlock, , 2646, 123) + (BehaviorActionBlock, , 2832, 133) + (BehaviorAnnex, behavior_specification, 2433, 533) + (BehaviorIntegerLiteral, , 2686, 1) + (BehaviorIntegerLiteral, , 2691, 1) + (BehaviorIntegerLiteral, , 2881, 1) + (BehaviorIntegerLiteral, , 2886, 1) + (BehaviorState, done, 2546, 4) + (BehaviorState, start, 2511, 5) + (BehaviorStateGroup, , 2511, 22) + (BehaviorStateGroup, , 2546, 28) + (BehaviorTransition, written_thread_implementation, 2783, 183) + (BehaviorTransition, written_thread_type, 2607, 163) + (BehaviorVariable, total, 2455, 5) + (BehaviorVariableGroup, , 2455, 28) + (BinaryExpression, , 2725, 12) + (BinaryExpression, , 2920, 13) + (ElementValues, , 2686, 6) + (ElementValues, , 2881, 6) + (ForStatement, , 2664, 91) + (ForStatement, , 2850, 101) + (Reference, , 2716, 5) + (Reference, , 2725, 4) + (Reference, , 2732, 5) + (Reference, , 2911, 5) + (Reference, , 2920, 5) + (Reference, , 2928, 5) + (ReferenceExpression, , 2725, 4) + (ReferenceExpression, , 2732, 5) + (ReferenceExpression, , 2920, 5) + (ReferenceExpression, , 2928, 5) + (ReferenceSegment, other, 2920, 5) + (ReferenceSegment, step, 2725, 4) + (ReferenceSegment, total, 2716, 5) + (ReferenceSegment, total, 2732, 5) + (ReferenceSegment, total, 2911, 5) + (ReferenceSegment, total, 2928, 5) diff --git a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt index 83493a1176..5efa997db7 100644 --- a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt +++ b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_characterization_conformance_OptionalForClassifier.txt @@ -4,9 +4,17 @@ annex[0] owner=OptionalForClassifier::operation states[0] : BehaviorState name=start states[1] : BehaviorState name=finish transitions[0] : BehaviorTransition - transitions[1] : BehaviorTransition - transitions[2] : BehaviorTransition actions[0] : BehaviorActionBlock content : ForOrForAllStatement - behaviorActions : BehaviorActionBlock + behaviorActions : AssignmentAction + target : BehaviorVariableHolder element=value [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : IterativeVariableHolder element=i [IterativeVariable] + iteratedValues : IntegerRange + lowerIntegerValue : BehaviorIntegerLiteral + upperIntegerValue : BehaviorIntegerLiteral iterativeVariable : IterativeVariable name=i diff --git a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt index b3e1bd5d72..e2fa2a2a7c 100644 --- a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt +++ b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_characterization_conformance_OptionalForallClassifier.txt @@ -4,9 +4,17 @@ annex[0] owner=OptionalForallClassifier::operation states[0] : BehaviorState name=start states[1] : BehaviorState name=finish transitions[0] : BehaviorTransition - transitions[1] : BehaviorTransition - transitions[2] : BehaviorTransition actions[0] : BehaviorActionBlock content : ForOrForAllStatement - behaviorActions : BehaviorActionBlock + behaviorActions : AssignmentAction + target : BehaviorVariableHolder element=value [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : IterativeVariableHolder element=i [IterativeVariable] + iteratedValues : IntegerRange + lowerIntegerValue : BehaviorIntegerLiteral + upperIntegerValue : BehaviorIntegerLiteral iterativeVariable : IterativeVariable name=i diff --git a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3173_Issue3173.txt b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3173_Issue3173.txt new file mode 100644 index 0000000000..dc89c3b5b6 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3173_Issue3173.txt @@ -0,0 +1,114 @@ +annex[0] owner=Issue3173::worker.i + parsedAnnexSubclause : BehaviorAnnex name=behavior_specification + variables[0] : BehaviorVariable name=total + variables[1] : BehaviorVariable name=pairs + states[0] : BehaviorState name=start + states[1] : BehaviorState name=done + transitions[0] : BehaviorTransition name=range_loop + transitions[1] : BehaviorTransition name=range_forall + transitions[2] : BehaviorTransition name=queue_loop + transitions[3] : BehaviorTransition name=array_loop + transitions[4] : BehaviorTransition name=data_model_array_forall + transitions[5] : BehaviorTransition name=written_classifier + actions[0] : BehaviorActionBlock + content : ForOrForAllStatement + behaviorActions : AssignmentAction + target : BehaviorVariableHolder element=total [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : IterativeVariableHolder element=step [IterativeVariable] + terms[1] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=total [BehaviorVariable] + iteratedValues : IntegerRange + lowerIntegerValue : BehaviorIntegerLiteral + upperIntegerValue : BehaviorIntegerLiteral + iterativeVariable : IterativeVariable name=step + actions[1] : BehaviorActionBlock + content : ForOrForAllStatement + behaviorActions : AssignmentAction + target : BehaviorVariableHolder element=total [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : IterativeVariableHolder element=other [IterativeVariable] + terms[1] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=total [BehaviorVariable] + iteratedValues : IntegerRange + lowerIntegerValue : BehaviorIntegerLiteral + upperIntegerValue : BehaviorIntegerLiteral + iterativeVariable : IterativeVariable name=other + actions[2] : BehaviorActionBlock + content : ForOrForAllStatement + behaviorActions : AssignmentAction + target : BehaviorVariableHolder element=total [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : IterativeVariableHolder element=sample [IterativeVariable] + terms[1] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=total [BehaviorVariable] + iteratedValues : EventDataPortHolder element=Issue3173::worker.readings [EventDataPort] + iterativeVariable : IterativeVariable name=sample + actions[3] : BehaviorActionBlock + content : ForOrForAllStatement + behaviorActions : AssignmentAction + target : BehaviorVariableHolder element=total [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : IterativeVariableHolder element=element [IterativeVariable] + terms[1] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=total [BehaviorVariable] + iteratedValues : DataSubcomponentHolder element=Issue3173::worker.i.history [DataSubcomponent] + iterativeVariable : IterativeVariable name=element + actions[4] : BehaviorActionBlock + content : ForOrForAllStatement + behaviorActions : AssignmentAction + target : BehaviorVariableHolder element=total [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : DataComponentReference + data[0] : IterativeVariableHolder element=entry [IterativeVariable] + data[1] : StructUnionElementHolder element=left [StructUnionElement] + structUnionElement : StructUnionElement name=left + terms[1] : Term + factors[0] : Factor + firstValue : DataComponentReference + data[0] : IterativeVariableHolder element=entry [IterativeVariable] + data[1] : StructUnionElementHolder element=right [StructUnionElement] + structUnionElement : StructUnionElement name=right + iteratedValues : BehaviorVariableHolder element=pairs [BehaviorVariable] + iterativeVariable : IterativeVariable name=entry + actions[5] : BehaviorActionBlock + content : ForOrForAllStatement + behaviorActions : AssignmentAction + target : BehaviorVariableHolder element=total [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : IterativeVariableHolder element=typed [IterativeVariable] + terms[1] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=total [BehaviorVariable] + iteratedValues : IntegerRange + lowerIntegerValue : BehaviorIntegerLiteral + upperIntegerValue : BehaviorIntegerLiteral + iterativeVariable : IterativeVariable name=typed diff --git a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt new file mode 100644 index 0000000000..20f651d3f8 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt @@ -0,0 +1,41 @@ +annex[0] owner=NonDataIteratorClassifier::worker.i + parsedAnnexSubclause : BehaviorAnnex name=behavior_specification + variables[0] : BehaviorVariable name=total + states[0] : BehaviorState name=start + states[1] : BehaviorState name=done + transitions[0] : BehaviorTransition name=written_thread_type + transitions[1] : BehaviorTransition name=written_thread_implementation + actions[0] : BehaviorActionBlock + content : ForOrForAllStatement + behaviorActions : AssignmentAction + target : BehaviorVariableHolder element=total [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : IterativeVariableHolder element=step [IterativeVariable] + terms[1] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=total [BehaviorVariable] + iteratedValues : IntegerRange + lowerIntegerValue : BehaviorIntegerLiteral + upperIntegerValue : BehaviorIntegerLiteral + iterativeVariable : IterativeVariable name=step + actions[1] : BehaviorActionBlock + content : ForOrForAllStatement + behaviorActions : AssignmentAction + target : BehaviorVariableHolder element=total [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : IterativeVariableHolder element=other [IterativeVariable] + terms[1] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=total [BehaviorVariable] + iteratedValues : IntegerRange + lowerIntegerValue : BehaviorIntegerLiteral + upperIntegerValue : BehaviorIntegerLiteral + iterativeVariable : IterativeVariable name=other diff --git a/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3173_Issue3173.txt b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3173_Issue3173.txt new file mode 100644 index 0000000000..8de827b28c --- /dev/null +++ b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3173_Issue3173.txt @@ -0,0 +1,42 @@ +===== annex[0] owner=Issue3173::worker.i ===== + + variables + total : Base_Types::Integer; + pairs : Pairs; + states + start : initial state; + done : complete final state; + transitions + range_loop : start -[]-> done { + for (step in 0 .. 2) { + total := step + total + } + }; + range_forall : start -[]-> done { + forall (other in 0 .. 2) { + total := other - total + } + }; + queue_loop : start -[]-> done { + for (sample in readings) { + total := sample + total + } + }; + array_loop : start -[]-> done { + for (element in history) { + total := element + total + } + }; + data_model_array_forall : start -[]-> done { + forall (entry in pairs) { + total := entry.left + entry.right + } + }; + written_classifier : start -[]-> done { + for (typed : Base_Types::Integer in 0 .. 2) { + total := typed + total + } + }; +\s\s\s\s +----- Xtext reparse ----- +reparsed diff --git a/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt new file mode 100644 index 0000000000..d7593248e7 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3173_NonDataIteratorClassifier.txt @@ -0,0 +1,21 @@ +===== annex[0] owner=NonDataIteratorClassifier::worker.i ===== + + variables + total : Base_Types::Integer; + states + start : initial state; + done : complete final state; + transitions + written_thread_type : start -[]-> done { + for (step : helper in 0 .. 2) { + total := step + total + } + }; + written_thread_implementation : start -[]-> done { + forall (other : helper.impl in 0 .. 2) { + total := other + total + } + }; +\s\s\s\s +----- Xtext reparse ----- +reparsed diff --git a/ba/org.osate.ba.tests/models/issue3173/.gitignore b/ba/org.osate.ba.tests/models/issue3173/.gitignore new file mode 100644 index 0000000000..afce51184c --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3173/.gitignore @@ -0,0 +1,2 @@ +/.aadlbin-gen/ +/instances/ diff --git a/ba/org.osate.ba.tests/models/issue3173/.project b/ba/org.osate.ba.tests/models/issue3173/.project new file mode 100644 index 0000000000..ad15a515dc --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3173/.project @@ -0,0 +1,8 @@ + + + issue3173 + + + org.eclipse.xtext.ui.shared.xtextBuilder + org.osate.core.aadlnatureorg.eclipse.xtext.ui.shared.xtextNature + diff --git a/ba/org.osate.ba.tests/models/issue3173/Issue3173.aadl b/ba/org.osate.ba.tests/models/issue3173/Issue3173.aadl new file mode 100644 index 0000000000..2e269b074a --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3173/Issue3173.aadl @@ -0,0 +1,96 @@ +-- Copyright (c) 2004-2026 Carnegie Mellon University and others. (see Contributors file). +-- All Rights Reserved. +-- +-- NO WARRANTY. ALL MATERIAL IS FURNISHED ON AN "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY +-- KIND, EITHER EXPRESSED OR IMPLIED, AS TO ANY MATTER INCLUDING, BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR PURPOSE +-- OR MERCHANTABILITY, EXCLUSIVITY, OR RESULTS OBTAINED FROM USE OF THE MATERIAL. CARNEGIE MELLON UNIVERSITY DOES NOT +-- MAKE ANY WARRANTY OF ANY KIND WITH RESPECT TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT. +-- +-- This program and the accompanying materials are made available under the terms of the Eclipse Public License 2.0 +-- which is available at https://www.eclipse.org/legal/epl-2.0/ +-- SPDX-License-Identifier: EPL-2.0 +-- +-- Created, in part, with funding and support from the United States Government. (see Acknowledgments file). +-- +-- This program includes and/or can make use of certain third party source code, object code, documentation and other +-- files ("Third Party Software"). The Third Party Software that is used by this program is dependent upon your system +-- configuration. By using this program, You agree to comply with any and all relevant Third Party Software terms and +-- conditions contained in any such Third Party Software or separate license file distributed with such Third Party +-- Software. The parties who own the Third Party Software ("Third Party Licensors") are intended third party benefici- +-- aries to this license with respect to the terms applicable to their Third Party Software. Third Party Software li- +-- censes only apply to the Third Party Software and not any other portion of this program or this program as a whole. + +package Issue3173 +public + with Base_Types, Data_Model; + + data Pair + properties + Data_Model::Data_Representation => Struct; + Data_Model::Base_Type => (classifier (Base_Types::Integer), classifier (Base_Types::Integer)); + Data_Model::Element_Names => ("left", "right"); + end Pair; + + data Pairs + properties + Data_Model::Data_Representation => Array; + Data_Model::Base_Type => (classifier (Pair)); + Data_Model::Dimension => (3); + end Pairs; + + thread worker + features + readings : in event data port Base_Types::Integer; + end worker; + + -- AS5506/3 Rev A D.6 makes ': data_unique_component_classifier_reference' optional in the for and the forall + -- construct. The iterated values then determine the element type: an integer range makes the iterator an integer, + -- while an input event data port and a data component array each supply the classifier of their own elements. + -- + -- Every loop body names the iterator as the first operand of an arithmetic expression. An operator is defined by + -- the type of its first operand, so an iterator left without a type is reported even though the type conformance + -- check between operands is currently disabled. + thread implementation worker.i + subcomponents + history : data Base_Types::Integer [3]; + annex behavior_specification {** + variables + total : Base_Types::Integer; + pairs : Pairs; + states + start : initial state; + done : complete final state; + transitions + range_loop : start -[]-> done { + for (step in 0 .. 2) { + total := step + total + } + }; + range_forall : start -[]-> done { + forall (other in 0 .. 2) { + total := other - total + } + }; + queue_loop : start -[]-> done { + for (sample in readings) { + total := sample + total + } + }; + array_loop : start -[]-> done { + for (element in history) { + total := element + total + } + }; + data_model_array_forall : start -[]-> done { + forall (entry in pairs) { + total := entry.left + entry.right + } + }; + written_classifier : start -[]-> done { + for (typed : Base_Types::Integer in 0 .. 2) { + total := typed + total + } + }; + **}; + end worker.i; +end Issue3173; diff --git a/ba/org.osate.ba.tests/models/issue3173/NonDataIteratorClassifier.aadl b/ba/org.osate.ba.tests/models/issue3173/NonDataIteratorClassifier.aadl new file mode 100644 index 0000000000..4e1302220f --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3173/NonDataIteratorClassifier.aadl @@ -0,0 +1,60 @@ +-- Copyright (c) 2004-2026 Carnegie Mellon University and others. (see Contributors file). +-- All Rights Reserved. +-- +-- NO WARRANTY. ALL MATERIAL IS FURNISHED ON AN "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY +-- KIND, EITHER EXPRESSED OR IMPLIED, AS TO ANY MATTER INCLUDING, BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR PURPOSE +-- OR MERCHANTABILITY, EXCLUSIVITY, OR RESULTS OBTAINED FROM USE OF THE MATERIAL. CARNEGIE MELLON UNIVERSITY DOES NOT +-- MAKE ANY WARRANTY OF ANY KIND WITH RESPECT TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT. +-- +-- This program and the accompanying materials are made available under the terms of the Eclipse Public License 2.0 +-- which is available at https://www.eclipse.org/legal/epl-2.0/ +-- SPDX-License-Identifier: EPL-2.0 +-- +-- Created, in part, with funding and support from the United States Government. (see Acknowledgments file). +-- +-- This program includes and/or can make use of certain third party source code, object code, documentation and other +-- files ("Third Party Software"). The Third Party Software that is used by this program is dependent upon your system +-- configuration. By using this program, You agree to comply with any and all relevant Third Party Software terms and +-- conditions contained in any such Third Party Software or separate license file distributed with such Third Party +-- Software. The parties who own the Third Party Software ("Third Party Licensors") are intended third party benefici- +-- aries to this license with respect to the terms applicable to their Third Party Software. Third Party Software li- +-- censes only apply to the Third Party Software and not any other portion of this program or this program as a whole. + +package NonDataIteratorClassifier +public + with Base_Types; + + thread helper + end helper; + + thread implementation helper.impl + end helper.impl; + + thread worker + end worker; + + -- The D.6 production spells the written iterator classifier data_unique_component_classifier_reference, so a + -- classifier of any other category is not one. The strict model has nothing to carry it: an iterative variable is + -- typed by a data classifier alone, and making the classifier optional must not turn a rejected declaration into + -- one whose type is inferred from the iterated values instead. + thread implementation worker.i + annex behavior_specification {** + variables + total : Base_Types::Integer; + states + start : initial state; + done : complete final state; + transitions + written_thread_type : start -[]-> done { + for (step : helper in 0 .. 2) { + total := step + total + } + }; + written_thread_implementation : start -[]-> done { + forall (other : helper.impl in 0 .. 2) { + total := other + total + } + }; + **}; + end worker.i; +end NonDataIteratorClassifier; diff --git a/ba/org.osate.ba.tests/src/org/osate/ba/tests/Issue3173Test.java b/ba/org.osate.ba.tests/src/org/osate/ba/tests/Issue3173Test.java new file mode 100644 index 0000000000..afe196522a --- /dev/null +++ b/ba/org.osate.ba.tests/src/org/osate/ba/tests/Issue3173Test.java @@ -0,0 +1,202 @@ +/** + * Copyright (c) 2004-2026 Carnegie Mellon University and others. (see Contributors file). + * All Rights Reserved. + * + * NO WARRANTY. ALL MATERIAL IS FURNISHED ON AN "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY + * KIND, EITHER EXPRESSED OR IMPLIED, AS TO ANY MATTER INCLUDING, BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR PURPOSE + * OR MERCHANTABILITY, EXCLUSIVITY, OR RESULTS OBTAINED FROM USE OF THE MATERIAL. CARNEGIE MELLON UNIVERSITY DOES NOT + * MAKE ANY WARRANTY OF ANY KIND WITH RESPECT TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT. + * + * This program and the accompanying materials are made available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * SPDX-License-Identifier: EPL-2.0 + * + * Created, in part, with funding and support from the United States Government. (see Acknowledgments file). + * + * This program includes and/or can make use of certain third party source code, object code, documentation and other + * files ("Third Party Software"). The Third Party Software that is used by this program is dependent upon your system + * configuration. By using this program, You agree to comply with any and all relevant Third Party Software terms and + * conditions contained in any such Third Party Software or separate license file distributed with such Third Party + * Software. The parties who own the Third Party Software ("Third Party Licensors") are intended third party benefici- + * aries to this license with respect to the terms applicable to their Third Party Software. Third Party Software li- + * censes only apply to the Third Party Software and not any other portion of this program or this program as a whole. + */ +package org.osate.ba.tests; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; + +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.xtext.diagnostics.Severity; +import org.eclipse.xtext.nodemodel.util.NodeModelUtils; +import org.eclipse.xtext.testing.InjectWith; +import org.eclipse.xtext.testing.XtextRunner; +import org.eclipse.xtext.testing.validation.ValidationTestHelper; +import org.eclipse.xtext.validation.Issue; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.osate.aadl2.AadlPackage; +import org.osate.annexsupport.AnnexRegistry; +import org.osate.annexsupport.AnnexUnparserRegistry; +import org.osate.annexsupport.AnnexUtil; +import org.osate.ba.aadlba.BehaviorAnnex; +import org.osate.ba.aadlba.ForOrForAllStatement; +import org.osate.ba.aadlba.IterativeVariableHolder; +import org.osate.ba.analyzers.TypeHolder; +import org.osate.ba.utils.AadlBaUtils; +import org.osate.testsupport.TestHelper; +import org.osate.xtext.aadl2.ba.util.BehaviorAnnexUtil; + +import com.google.inject.Inject; + +/** + * AS5506/3 Rev. A D.6 writes the iterator of a {@code for} and of a {@code forall} construct as + * {@code element_identifier [ : data_unique_component_classifier_reference ]}, so the classifier is optional, and the + * standard's own BA_example4 omits it. The semantics then give the iterator the type of the element the loop iterates: + * an integer for an integer range, the data classifier of an input event data port, and the element classifier of a + * data component array. + *

+ * Verifies that both constructs parse without the classifier, that the strict model carries the type the iterated + * values determine rather than leaving the iterator untyped, that reads of the iterator inside the loop carry that same + * type, and that a loop without a classifier round-trips through the registered unparser. A written classifier of a + * category other than data remains an error, because the inference must not silently replace a rejected declaration. + */ +@RunWith(XtextRunner.class) +@InjectWith(BehaviorAnnexInjectorProvider.class) +public class Issue3173Test { + private static final String MODELS = "org.osate.ba.tests/models/issue3173/"; + + /** + * The type of each iterator, in the order the annex writes the loops. An integer range makes the iterator a + * universal integer, which no data classifier denotes, exactly as a port count value is one; every other iterated + * value names the classifier of its elements, which for a Data Model array is the array's base type. The last loop + * is the positive control: a written classifier is still the iterator's type. + */ + private static final List ITERATOR_TYPES = List.of("step -> Integer ", + "other -> Integer ", "sample -> Integer Base_Types::Integer", + "element -> Integer Base_Types::Integer", "entry -> Struct Issue3173::Pair", + "typed -> Integer Base_Types::Integer"); + + /** Each read of an iterator inside its loop body, with the type the read carries. */ + private static final List ITERATOR_READS = List.of("step -> Integer ", + "other -> Integer ", "sample -> Integer Base_Types::Integer", + "element -> Integer Base_Types::Integer", "entry -> Struct Issue3173::Pair", + "entry -> Struct Issue3173::Pair", "typed -> Integer Base_Types::Integer"); + + @Inject + private TestHelper testHelper; + + @Inject + private ValidationTestHelper validationHelper; + + /** + * Each loop body names its iterator as the first operand of an arithmetic expression, and the applicable operator is + * selected by the type of that operand. An iterator left untyped is therefore reported even though the conformance + * check between the two operand types is currently disabled. + */ + @Test + public void omittedIteratorClassifiersAreAccepted() throws Exception { + validationHelper.assertNoIssues(testHelper.parseFile(MODELS + "Issue3173.aadl")); + } + + @Test + public void omittedIteratorClassifierTakesTheTypeOfTheIteratedElement() throws Exception { + var root = testHelper.parseFile(MODELS + "Issue3173.aadl"); + validationHelper.assertNoIssues(root); + assertEquals(ITERATOR_TYPES, iteratorTypes(strictAnnex(root))); + } + + @Test + public void iteratorReadsCarryTheInferredType() throws Exception { + var root = testHelper.parseFile(MODELS + "Issue3173.aadl"); + validationHelper.assertNoIssues(root); + var reads = new ArrayList(); + for (var contents = strictAnnex(root).eAllContents(); contents.hasNext();) { + if (contents.next() instanceof IterativeVariableHolder holder) { + reads.add(holder.getElement().getName() + " -> " + describe(AadlBaUtils.getTypeHolder(holder))); + } + } + assertEquals(ITERATOR_READS, reads); + } + + /** + * Serializes a copy of the annex rather than the annex itself, because the registered unparser returns the source + * text of anything that still has a node model and the generated sequencers are what has to omit the classifier. + * The copy joins the parsed resource for the duration, since serializing the classifier cross-references needs the + * scope that resource provides. + */ + @Test + public void omittedIteratorClassifierRoundTripsThroughTheUnparser() throws Exception { + var root = testHelper.parseFile(MODELS + "Issue3173.aadl"); + validationHelper.assertNoIssues(root); + var copy = EcoreUtil.copy(AnnexUtil.getAllDefaultAnnexSubclauses(root).getFirst().getParsedAnnexSubclause()); + + final String serialized; + root.eResource().getContents().add(copy); + try { + serialized = ((AnnexUnparserRegistry) AnnexRegistry.getRegistry(AnnexRegistry.ANNEX_UNPARSER_EXT_ID)) + .getAnnexUnparser("behavior_specification") + .unparseAnnexSubclause(copy, ""); + } finally { + root.eResource().getContents().remove(copy); + } + // The serializer emits one flat line with a space around every token, so the assertions run on normalized text. + var normalized = serialized.replaceAll("\\s+", " ").replace("( ", "(").replace(" )", ")"); + assertTrue(serialized, normalized.contains("for (step in 0 .. 2)")); + assertTrue(serialized, normalized.contains("forall (other in 0 .. 2)")); + assertTrue(serialized, normalized.contains("for (sample in readings)")); + assertTrue(serialized, normalized.contains("forall (entry in pairs)")); + assertTrue(serialized, normalized.contains("for (typed : Base_Types::Integer in 0 .. 2)")); + + var source = NodeModelUtils.getNode(root).getText(); + var reparsed = testHelper.parseString(source.substring(0, source.indexOf("{**") + 3) + serialized + + source.substring(source.indexOf("**}"))); + validationHelper.assertNoIssues(reparsed); + assertEquals(ITERATOR_TYPES, iteratorTypes(strictAnnex(reparsed))); + } + + /** + * A classifier of another category has no strict representation, so it is reported on the reference itself and the + * strict-model checkers do not run over the loop. Reporting it keeps the declaration rejected instead of having the + * iterated values supply a type for it. + */ + @Test + public void writtenIteratorClassifierMustBeADataClassifier() throws Exception { + var root = testHelper.parseFile(MODELS + "NonDataIteratorClassifier.aadl"); + var source = NodeModelUtils.getNode(root).getRootNode().getText(); + var issues = validationHelper.validate(root).stream().sorted(Comparator.comparing(Issue::getOffset)).toList(); + assertEquals(issues.toString(), 2, issues.size()); + assertEquals(List.of("helper", "helper.impl"), issues.stream().map(issue -> { + assertEquals(Severity.ERROR, issue.getSeverity()); + var written = source.substring(issue.getOffset(), issue.getOffset() + issue.getLength()); + assertEquals("'" + written + "' is not a data classifier: a for or forall iterator can only name a data" + + " component classifier", issue.getMessage()); + return written; + }).toList()); + } + + /** The name and type of every iterator of the annex, in the order the annex writes the loops. */ + private static List iteratorTypes(final BehaviorAnnex annex) throws Exception { + var result = new ArrayList(); + for (var contents = annex.eAllContents(); contents.hasNext();) { + if (contents.next() instanceof ForOrForAllStatement loop) { + result.add(loop.getIterativeVariable().getName() + " -> " + + describe(AadlBaUtils.getTypeHolder(loop.getIterativeVariable()))); + } + } + return result; + } + + private static String describe(final TypeHolder type) { + return type.getDataRep().getName() + ' ' + + (type.getKlass() == null ? "" : type.getKlass().getQualifiedName()); + } + + private static BehaviorAnnex strictAnnex(final AadlPackage root) { + return BehaviorAnnexUtil.getStrictModel(AnnexUtil.getAllDefaultAnnexSubclauses(root).getFirst()); + } +} diff --git a/ba/org.osate.ba.tests/src/org/osate/ba/tests/characterization/BehaviorAnnexConformanceTest.java b/ba/org.osate.ba.tests/src/org/osate/ba/tests/characterization/BehaviorAnnexConformanceTest.java index cc7a22b72b..e71dba5bce 100644 --- a/ba/org.osate.ba.tests/src/org/osate/ba/tests/characterization/BehaviorAnnexConformanceTest.java +++ b/ba/org.osate.ba.tests/src/org/osate/ba/tests/characterization/BehaviorAnnexConformanceTest.java @@ -68,16 +68,16 @@ public class BehaviorAnnexConformanceTest { /** * The standard expectations that are still skipped, each with the issue that tracks the missing implementation. - * G01 (#3165), G02 (#3166), G03 (#3167), G04 (#3168), G05 (#3169), G08 (#3172), and G10 (#3174) are absent because - * {@link #internalConditionIsAcceptedByTheStandard()}, + * G01 (#3165), G02 (#3166), G03 (#3167), G04 (#3168), G05 (#3169), G08 (#3172), G09 (#3173), and G10 (#3174) are + * absent because {@link #internalConditionIsAcceptedByTheStandard()}, * {@link #externalConditionOperatorsAreAcceptedByTheStandard()}, * {@link #frozenPortParenthesesAreAcceptedByTheStandard()}, * {@link #timeoutResetPortsAreAcceptedByTheStandard()}, {@link #shortCircuitOperatorsAreAcceptedByTheStandard()}, - * {@link #selfPropertyReferenceIsAcceptedByTheStandard()}, and + * {@link #selfPropertyReferenceIsAcceptedByTheStandard()}, + * {@link #optionalLoopClassifierIsAcceptedByTheStandard()}, and * {@link #internalPortActionsAreAcceptedByTheStandard()} pass. */ - private static final List TRACKED_SKIPS = List.of( - "optionalLoopClassifierIsAcceptedByTheStandard -> #3173"); + private static final List TRACKED_SKIPS = List.of(); /** The fixtures an expectation in this class asserts about. */ private static final List ASSERTED_FIXTURES = List.of("InternalCondition.aadl", @@ -130,7 +130,6 @@ public void selfPropertyReferenceIsAcceptedByTheStandard() throws Exception { assertNoIssues("SelfPropertyReference.aadl"); } - @Ignore("Issue #3173: make for and forall classifiers optional") @Test public void optionalLoopClassifierIsAcceptedByTheStandard() throws Exception { assertNoIssues("OptionalForClassifier.aadl"); diff --git a/ba/org.osate.ba/src/org/osate/ba/analyzers/AadlBaTypeChecker.java b/ba/org.osate.ba/src/org/osate/ba/analyzers/AadlBaTypeChecker.java index 120d39146d..cd9e8825b5 100644 --- a/ba/org.osate.ba/src/org/osate/ba/analyzers/AadlBaTypeChecker.java +++ b/ba/org.osate.ba/src/org/osate/ba/analyzers/AadlBaTypeChecker.java @@ -316,8 +316,16 @@ private boolean checkConditionalStatement(CondStatement statement) { return true; } + /** + * D.6 leaves the iterator classifier optional, so an iterator without one is not an unresolved iterator: over an + * integer range D.6 gives it the integer type, which no data classifier denotes, and over any other iterated value + * resolution takes the classifier of the iterated elements. What remains an error is an iterator that ends up with + * no type at all. + */ private boolean checkForOrForAll(ForOrForAllStatement statement) { - boolean result = statement.getIterativeVariable().getDataClassifier() instanceof DataClassifier; + TypeHolder variableType = getType(statement.getIterativeVariable()); + boolean result = variableType != null + && (variableType.getKlass() != null || variableType.getDataRep() != DataRepresentation.UNKNOWN); if (!result) { reportError(statement.getIterativeVariable(), "iterative variable data classifier is not resolved"); } diff --git a/ba/org.osate.ba/src/org/osate/ba/utils/AadlBaUtils.java b/ba/org.osate.ba/src/org/osate/ba/utils/AadlBaUtils.java index 5cd2faf80f..c3f35a257e 100644 --- a/ba/org.osate.ba/src/org/osate/ba/utils/AadlBaUtils.java +++ b/ba/org.osate.ba/src/org/osate/ba/utils/AadlBaUtils.java @@ -124,6 +124,7 @@ import org.osate.ba.aadlba.FeatureType; import org.osate.ba.aadlba.ForOrForAllStatement; import org.osate.ba.aadlba.IndexableElement; +import org.osate.ba.aadlba.IntegerRange; import org.osate.ba.aadlba.IntegerValue; import org.osate.ba.aadlba.InternalPortHolder; import org.osate.ba.aadlba.IterativeVariable; @@ -431,6 +432,10 @@ public static DataRepresentation getDataRepresentation(ValueVariable v) { } else if (el instanceof BehaviorVariable) { // Behavior case. return getDataRepresentation((BehaviorVariable) el); + } else if (el instanceof IterativeVariable variable) { + // A read of an iterator has the type of the iterator, including the universal integer an iterator + // over an integer range has without a classifier of its own. + return getDataRepresentation(variable); } else { // Prototype cases. Classifier klass; @@ -553,7 +558,8 @@ public static Classifier getClassifier(Element el, Classifier parentContainer) { // Local variable case (BehaviorVariable). result = variable.getDataClassifier(); } else if (el instanceof IterativeVariable variable) { - // Iterative variable case. + // Iterative variable case. D.6 leaves the classifier optional, and resolution has already supplied the + // classifier of the iterated elements when the construct writes none. result = variable.getDataClassifier(); } else if (el instanceof Prototype prototype) { result = prototypeResolver(prototype, parentContainer); @@ -935,7 +941,7 @@ private static TypeHolder getTypeHolder(Value v, ComponentClassifier parentConta * Returns the TypeHolder (data representation and component's DataClassifier * if any) of the given IterativeVariable object. * - * @param uccr the given IterativeVariable object. + * @param iv the given IterativeVariable object. * @return the type holder of the given IterativeVariable * object. * @exception UnsupportedOperationException for the unsupported types @@ -943,11 +949,32 @@ private static TypeHolder getTypeHolder(Value v, ComponentClassifier parentConta private static TypeHolder getTypeHolder(IterativeVariable iv) { TypeHolder result = new TypeHolder(); result.setKlass(iv.getDataClassifier()); - result.setDataRep(getDataRepresentation(result.getKlass())); + result.setDataRep(getDataRepresentation(iv)); return result; } + /** + * Returns the data representation of the given IterativeVariable object. + *

+ * D.6 leaves the iterator classifier optional, and resolution supplies the + * classifier of the iterated elements when the construct writes none. An + * integer range is the one case with no classifier to supply: D.6 gives the + * iterator the integer type, which is a universal integer, exactly as a port + * count value is one. + * + * @param iv the given IterativeVariable object + * @return the data representation or DataRepresentation.UNKNOWN + */ + public static DataRepresentation getDataRepresentation(IterativeVariable iv) { + if (iv.getDataClassifier() != null) { + return getDataRepresentation(iv.getDataClassifier()); + } + return iv.eContainer() instanceof ForOrForAllStatement loop + && loop.getIteratedValues() instanceof IntegerRange ? DataRepresentation.INTEGER + : DataRepresentation.UNKNOWN; + } + /** * Returns the TypeHolder (data representation and component's DataClassifier * if any) of the given Element object. diff --git a/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/BehaviorAnnexParser.java b/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/BehaviorAnnexParser.java index e67659e96b..5f69036da2 100644 --- a/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/BehaviorAnnexParser.java +++ b/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/BehaviorAnnexParser.java @@ -148,6 +148,7 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getIfStatementAccess().getGroup_6(), "rule__IfStatement__Group_6__0"); builder.put(grammarAccess.getElseIfClauseAccess().getGroup(), "rule__ElseIfClause__Group__0"); builder.put(grammarAccess.getForStatementAccess().getGroup(), "rule__ForStatement__Group__0"); + builder.put(grammarAccess.getForStatementAccess().getGroup_3(), "rule__ForStatement__Group_3__0"); builder.put(grammarAccess.getWhileStatementAccess().getGroup(), "rule__WhileStatement__Group__0"); builder.put(grammarAccess.getDoUntilStatementAccess().getGroup(), "rule__DoUntilStatement__Group__0"); builder.put(grammarAccess.getElementValuesAccess().getGroup(), "rule__ElementValues__Group__0"); @@ -321,9 +322,9 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getForStatementAccess().getForAssignment_0_0(), "rule__ForStatement__ForAssignment_0_0"); builder.put(grammarAccess.getForStatementAccess().getForallAssignment_0_1(), "rule__ForStatement__ForallAssignment_0_1"); builder.put(grammarAccess.getForStatementAccess().getVariableAssignment_2(), "rule__ForStatement__VariableAssignment_2"); - builder.put(grammarAccess.getForStatementAccess().getDataClassifierAssignment_4(), "rule__ForStatement__DataClassifierAssignment_4"); - builder.put(grammarAccess.getForStatementAccess().getValuesAssignment_6(), "rule__ForStatement__ValuesAssignment_6"); - builder.put(grammarAccess.getForStatementAccess().getActionsAssignment_9(), "rule__ForStatement__ActionsAssignment_9"); + builder.put(grammarAccess.getForStatementAccess().getDataClassifierAssignment_3_1(), "rule__ForStatement__DataClassifierAssignment_3_1"); + builder.put(grammarAccess.getForStatementAccess().getValuesAssignment_5(), "rule__ForStatement__ValuesAssignment_5"); + builder.put(grammarAccess.getForStatementAccess().getActionsAssignment_8(), "rule__ForStatement__ActionsAssignment_8"); builder.put(grammarAccess.getWhileStatementAccess().getConditionAssignment_2(), "rule__WhileStatement__ConditionAssignment_2"); builder.put(grammarAccess.getWhileStatementAccess().getActionsAssignment_5(), "rule__WhileStatement__ActionsAssignment_5"); builder.put(grammarAccess.getDoUntilStatementAccess().getActionsAssignment_1(), "rule__DoUntilStatement__ActionsAssignment_1"); diff --git a/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/internal/InternalBehaviorAnnexParser.g b/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/internal/InternalBehaviorAnnexParser.g index 43063b5a39..da4913b82c 100644 --- a/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/internal/InternalBehaviorAnnexParser.g +++ b/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/internal/InternalBehaviorAnnexParser.g @@ -8640,9 +8640,9 @@ rule__ForStatement__Group__3__Impl } : ( - { before(grammarAccess.getForStatementAccess().getColonKeyword_3()); } - Colon - { after(grammarAccess.getForStatementAccess().getColonKeyword_3()); } + { before(grammarAccess.getForStatementAccess().getGroup_3()); } + (rule__ForStatement__Group_3__0)? + { after(grammarAccess.getForStatementAccess().getGroup_3()); } ) ; finally { @@ -8667,9 +8667,9 @@ rule__ForStatement__Group__4__Impl } : ( - { before(grammarAccess.getForStatementAccess().getDataClassifierAssignment_4()); } - (rule__ForStatement__DataClassifierAssignment_4) - { after(grammarAccess.getForStatementAccess().getDataClassifierAssignment_4()); } + { before(grammarAccess.getForStatementAccess().getInKeyword_4()); } + In + { after(grammarAccess.getForStatementAccess().getInKeyword_4()); } ) ; finally { @@ -8694,9 +8694,9 @@ rule__ForStatement__Group__5__Impl } : ( - { before(grammarAccess.getForStatementAccess().getInKeyword_5()); } - In - { after(grammarAccess.getForStatementAccess().getInKeyword_5()); } + { before(grammarAccess.getForStatementAccess().getValuesAssignment_5()); } + (rule__ForStatement__ValuesAssignment_5) + { after(grammarAccess.getForStatementAccess().getValuesAssignment_5()); } ) ; finally { @@ -8721,9 +8721,9 @@ rule__ForStatement__Group__6__Impl } : ( - { before(grammarAccess.getForStatementAccess().getValuesAssignment_6()); } - (rule__ForStatement__ValuesAssignment_6) - { after(grammarAccess.getForStatementAccess().getValuesAssignment_6()); } + { before(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_6()); } + RightParenthesis + { after(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_6()); } ) ; finally { @@ -8748,9 +8748,9 @@ rule__ForStatement__Group__7__Impl } : ( - { before(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_7()); } - RightParenthesis - { after(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_7()); } + { before(grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_7()); } + LeftCurlyBracket + { after(grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_7()); } ) ; finally { @@ -8775,9 +8775,9 @@ rule__ForStatement__Group__8__Impl } : ( - { before(grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_8()); } - LeftCurlyBracket - { after(grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_8()); } + { before(grammarAccess.getForStatementAccess().getActionsAssignment_8()); } + (rule__ForStatement__ActionsAssignment_8) + { after(grammarAccess.getForStatementAccess().getActionsAssignment_8()); } ) ; finally { @@ -8790,7 +8790,6 @@ rule__ForStatement__Group__9 } : rule__ForStatement__Group__9__Impl - rule__ForStatement__Group__10 ; finally { restoreStackSize(stackSize); @@ -8802,35 +8801,63 @@ rule__ForStatement__Group__9__Impl } : ( - { before(grammarAccess.getForStatementAccess().getActionsAssignment_9()); } - (rule__ForStatement__ActionsAssignment_9) - { after(grammarAccess.getForStatementAccess().getActionsAssignment_9()); } + { before(grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_9()); } + RightCurlyBracket + { after(grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_9()); } ) ; finally { restoreStackSize(stackSize); } -rule__ForStatement__Group__10 + +rule__ForStatement__Group_3__0 @init { int stackSize = keepStackSize(); } : - rule__ForStatement__Group__10__Impl + rule__ForStatement__Group_3__0__Impl + rule__ForStatement__Group_3__1 ; finally { restoreStackSize(stackSize); } -rule__ForStatement__Group__10__Impl +rule__ForStatement__Group_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_10()); } - RightCurlyBracket - { after(grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_10()); } + { before(grammarAccess.getForStatementAccess().getColonKeyword_3_0()); } + Colon + { after(grammarAccess.getForStatementAccess().getColonKeyword_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ForStatement__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ForStatement__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ForStatement__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getForStatementAccess().getDataClassifierAssignment_3_1()); } + (rule__ForStatement__DataClassifierAssignment_3_1) + { after(grammarAccess.getForStatementAccess().getDataClassifierAssignment_3_1()); } ) ; finally { @@ -15722,49 +15749,49 @@ finally { restoreStackSize(stackSize); } -rule__ForStatement__DataClassifierAssignment_4 +rule__ForStatement__DataClassifierAssignment_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_4_0()); } + { before(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_3_1_0()); } ( - { before(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_4_0_1()); } + { before(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_3_1_0_1()); } ruleQCREF - { after(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_4_0_1()); } + { after(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_3_1_0_1()); } ) - { after(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_4_0()); } + { after(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ForStatement__ValuesAssignment_6 +rule__ForStatement__ValuesAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_6_0()); } + { before(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_5_0()); } ruleElementValues - { after(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_6_0()); } + { after(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ForStatement__ActionsAssignment_9 +rule__ForStatement__ActionsAssignment_8 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_9_0()); } + { before(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_8_0()); } ruleBehaviorActions - { after(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_9_0()); } + { after(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_8_0()); } ) ; finally { diff --git a/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/internal/InternalBehaviorAnnexParser.java b/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/internal/InternalBehaviorAnnexParser.java index b07b89e27a..b4aeb52f33 100644 --- a/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/internal/InternalBehaviorAnnexParser.java +++ b/ba/org.osate.xtext.aadl2.ba.ide/src-gen/org/osate/xtext/aadl2/ba/ide/contentassist/antlr/internal/InternalBehaviorAnnexParser.java @@ -13226,11 +13226,6 @@ public final void rule__NumAlt__Alternatives() throws RecognitionException { case PlusSign: { switch ( input.LA(2) ) { - case RULE_ID: - { - alt38=3; - } - break; case RULE_INTEGER_LIT: { alt38=2; @@ -13241,6 +13236,11 @@ public final void rule__NumAlt__Alternatives() throws RecognitionException { alt38=1; } break; + case RULE_ID: + { + alt38=3; + } + break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = @@ -13254,14 +13254,14 @@ public final void rule__NumAlt__Alternatives() throws RecognitionException { case HyphenMinus: { switch ( input.LA(2) ) { - case RULE_ID: + case RULE_INTEGER_LIT: { - alt38=3; + alt38=2; } break; - case RULE_INTEGER_LIT: + case RULE_ID: { - alt38=2; + alt38=3; } break; case RULE_REAL_LIT: @@ -29223,7 +29223,7 @@ public final void rule__ForStatement__Group__3() throws RecognitionException { // InternalBehaviorAnnexParser.g:8629:1: ( rule__ForStatement__Group__3__Impl rule__ForStatement__Group__4 ) // InternalBehaviorAnnexParser.g:8630:2: rule__ForStatement__Group__3__Impl rule__ForStatement__Group__4 { - pushFollow(FollowSets000.FOLLOW_4); + pushFollow(FollowSets000.FOLLOW_55); rule__ForStatement__Group__3__Impl(); state._fsp--; @@ -29252,24 +29252,45 @@ public final void rule__ForStatement__Group__3() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__3__Impl" - // InternalBehaviorAnnexParser.g:8637:1: rule__ForStatement__Group__3__Impl : ( Colon ) ; + // InternalBehaviorAnnexParser.g:8637:1: rule__ForStatement__Group__3__Impl : ( ( rule__ForStatement__Group_3__0 )? ) ; public final void rule__ForStatement__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8641:1: ( ( Colon ) ) - // InternalBehaviorAnnexParser.g:8642:1: ( Colon ) + // InternalBehaviorAnnexParser.g:8641:1: ( ( ( rule__ForStatement__Group_3__0 )? ) ) + // InternalBehaviorAnnexParser.g:8642:1: ( ( rule__ForStatement__Group_3__0 )? ) { - // InternalBehaviorAnnexParser.g:8642:1: ( Colon ) - // InternalBehaviorAnnexParser.g:8643:2: Colon + // InternalBehaviorAnnexParser.g:8642:1: ( ( rule__ForStatement__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:8643:2: ( rule__ForStatement__Group_3__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getColonKeyword_3()); + before(grammarAccess.getForStatementAccess().getGroup_3()); } - match(input,Colon,FollowSets000.FOLLOW_2); if (state.failed) return ; + // InternalBehaviorAnnexParser.g:8644:2: ( rule__ForStatement__Group_3__0 )? + int alt82=2; + int LA82_0 = input.LA(1); + + if ( (LA82_0==Colon) ) { + alt82=1; + } + switch (alt82) { + case 1 : + // InternalBehaviorAnnexParser.g:8644:3: rule__ForStatement__Group_3__0 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__ForStatement__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getColonKeyword_3()); + after(grammarAccess.getForStatementAccess().getGroup_3()); } } @@ -29302,7 +29323,7 @@ public final void rule__ForStatement__Group__4() throws RecognitionException { // InternalBehaviorAnnexParser.g:8656:1: ( rule__ForStatement__Group__4__Impl rule__ForStatement__Group__5 ) // InternalBehaviorAnnexParser.g:8657:2: rule__ForStatement__Group__4__Impl rule__ForStatement__Group__5 { - pushFollow(FollowSets000.FOLLOW_50); + pushFollow(FollowSets000.FOLLOW_13); rule__ForStatement__Group__4__Impl(); state._fsp--; @@ -29331,34 +29352,24 @@ public final void rule__ForStatement__Group__4() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__4__Impl" - // InternalBehaviorAnnexParser.g:8664:1: rule__ForStatement__Group__4__Impl : ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) ; + // InternalBehaviorAnnexParser.g:8664:1: rule__ForStatement__Group__4__Impl : ( In ) ; public final void rule__ForStatement__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8668:1: ( ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) ) - // InternalBehaviorAnnexParser.g:8669:1: ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:8668:1: ( ( In ) ) + // InternalBehaviorAnnexParser.g:8669:1: ( In ) { - // InternalBehaviorAnnexParser.g:8669:1: ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) - // InternalBehaviorAnnexParser.g:8670:2: ( rule__ForStatement__DataClassifierAssignment_4 ) + // InternalBehaviorAnnexParser.g:8669:1: ( In ) + // InternalBehaviorAnnexParser.g:8670:2: In { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getDataClassifierAssignment_4()); - } - // InternalBehaviorAnnexParser.g:8671:2: ( rule__ForStatement__DataClassifierAssignment_4 ) - // InternalBehaviorAnnexParser.g:8671:3: rule__ForStatement__DataClassifierAssignment_4 - { - pushFollow(FollowSets000.FOLLOW_2); - rule__ForStatement__DataClassifierAssignment_4(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getForStatementAccess().getInKeyword_4()); } - + match(input,In,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getDataClassifierAssignment_4()); + after(grammarAccess.getForStatementAccess().getInKeyword_4()); } } @@ -29391,7 +29402,7 @@ public final void rule__ForStatement__Group__5() throws RecognitionException { // InternalBehaviorAnnexParser.g:8683:1: ( rule__ForStatement__Group__5__Impl rule__ForStatement__Group__6 ) // InternalBehaviorAnnexParser.g:8684:2: rule__ForStatement__Group__5__Impl rule__ForStatement__Group__6 { - pushFollow(FollowSets000.FOLLOW_13); + pushFollow(FollowSets000.FOLLOW_37); rule__ForStatement__Group__5__Impl(); state._fsp--; @@ -29420,24 +29431,34 @@ public final void rule__ForStatement__Group__5() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__5__Impl" - // InternalBehaviorAnnexParser.g:8691:1: rule__ForStatement__Group__5__Impl : ( In ) ; + // InternalBehaviorAnnexParser.g:8691:1: rule__ForStatement__Group__5__Impl : ( ( rule__ForStatement__ValuesAssignment_5 ) ) ; public final void rule__ForStatement__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8695:1: ( ( In ) ) - // InternalBehaviorAnnexParser.g:8696:1: ( In ) + // InternalBehaviorAnnexParser.g:8695:1: ( ( ( rule__ForStatement__ValuesAssignment_5 ) ) ) + // InternalBehaviorAnnexParser.g:8696:1: ( ( rule__ForStatement__ValuesAssignment_5 ) ) { - // InternalBehaviorAnnexParser.g:8696:1: ( In ) - // InternalBehaviorAnnexParser.g:8697:2: In + // InternalBehaviorAnnexParser.g:8696:1: ( ( rule__ForStatement__ValuesAssignment_5 ) ) + // InternalBehaviorAnnexParser.g:8697:2: ( rule__ForStatement__ValuesAssignment_5 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getInKeyword_5()); + before(grammarAccess.getForStatementAccess().getValuesAssignment_5()); } - match(input,In,FollowSets000.FOLLOW_2); if (state.failed) return ; + // InternalBehaviorAnnexParser.g:8698:2: ( rule__ForStatement__ValuesAssignment_5 ) + // InternalBehaviorAnnexParser.g:8698:3: rule__ForStatement__ValuesAssignment_5 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__ForStatement__ValuesAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getInKeyword_5()); + after(grammarAccess.getForStatementAccess().getValuesAssignment_5()); } } @@ -29470,7 +29491,7 @@ public final void rule__ForStatement__Group__6() throws RecognitionException { // InternalBehaviorAnnexParser.g:8710:1: ( rule__ForStatement__Group__6__Impl rule__ForStatement__Group__7 ) // InternalBehaviorAnnexParser.g:8711:2: rule__ForStatement__Group__6__Impl rule__ForStatement__Group__7 { - pushFollow(FollowSets000.FOLLOW_37); + pushFollow(FollowSets000.FOLLOW_56); rule__ForStatement__Group__6__Impl(); state._fsp--; @@ -29499,34 +29520,24 @@ public final void rule__ForStatement__Group__6() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__6__Impl" - // InternalBehaviorAnnexParser.g:8718:1: rule__ForStatement__Group__6__Impl : ( ( rule__ForStatement__ValuesAssignment_6 ) ) ; + // InternalBehaviorAnnexParser.g:8718:1: rule__ForStatement__Group__6__Impl : ( RightParenthesis ) ; public final void rule__ForStatement__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8722:1: ( ( ( rule__ForStatement__ValuesAssignment_6 ) ) ) - // InternalBehaviorAnnexParser.g:8723:1: ( ( rule__ForStatement__ValuesAssignment_6 ) ) + // InternalBehaviorAnnexParser.g:8722:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:8723:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:8723:1: ( ( rule__ForStatement__ValuesAssignment_6 ) ) - // InternalBehaviorAnnexParser.g:8724:2: ( rule__ForStatement__ValuesAssignment_6 ) + // InternalBehaviorAnnexParser.g:8723:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8724:2: RightParenthesis { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getValuesAssignment_6()); - } - // InternalBehaviorAnnexParser.g:8725:2: ( rule__ForStatement__ValuesAssignment_6 ) - // InternalBehaviorAnnexParser.g:8725:3: rule__ForStatement__ValuesAssignment_6 - { - pushFollow(FollowSets000.FOLLOW_2); - rule__ForStatement__ValuesAssignment_6(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_6()); } - + match(input,RightParenthesis,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getValuesAssignment_6()); + after(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_6()); } } @@ -29559,7 +29570,7 @@ public final void rule__ForStatement__Group__7() throws RecognitionException { // InternalBehaviorAnnexParser.g:8737:1: ( rule__ForStatement__Group__7__Impl rule__ForStatement__Group__8 ) // InternalBehaviorAnnexParser.g:8738:2: rule__ForStatement__Group__7__Impl rule__ForStatement__Group__8 { - pushFollow(FollowSets000.FOLLOW_56); + pushFollow(FollowSets000.FOLLOW_38); rule__ForStatement__Group__7__Impl(); state._fsp--; @@ -29588,24 +29599,24 @@ public final void rule__ForStatement__Group__7() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__7__Impl" - // InternalBehaviorAnnexParser.g:8745:1: rule__ForStatement__Group__7__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:8745:1: rule__ForStatement__Group__7__Impl : ( LeftCurlyBracket ) ; public final void rule__ForStatement__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8749:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:8750:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8749:1: ( ( LeftCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:8750:1: ( LeftCurlyBracket ) { - // InternalBehaviorAnnexParser.g:8750:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:8751:2: RightParenthesis + // InternalBehaviorAnnexParser.g:8750:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:8751:2: LeftCurlyBracket { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_7()); + before(grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_7()); } - match(input,RightParenthesis,FollowSets000.FOLLOW_2); if (state.failed) return ; + match(input,LeftCurlyBracket,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_7()); + after(grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_7()); } } @@ -29638,7 +29649,7 @@ public final void rule__ForStatement__Group__8() throws RecognitionException { // InternalBehaviorAnnexParser.g:8764:1: ( rule__ForStatement__Group__8__Impl rule__ForStatement__Group__9 ) // InternalBehaviorAnnexParser.g:8765:2: rule__ForStatement__Group__8__Impl rule__ForStatement__Group__9 { - pushFollow(FollowSets000.FOLLOW_38); + pushFollow(FollowSets000.FOLLOW_10); rule__ForStatement__Group__8__Impl(); state._fsp--; @@ -29667,24 +29678,34 @@ public final void rule__ForStatement__Group__8() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__8__Impl" - // InternalBehaviorAnnexParser.g:8772:1: rule__ForStatement__Group__8__Impl : ( LeftCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:8772:1: rule__ForStatement__Group__8__Impl : ( ( rule__ForStatement__ActionsAssignment_8 ) ) ; public final void rule__ForStatement__Group__8__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8776:1: ( ( LeftCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:8777:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:8776:1: ( ( ( rule__ForStatement__ActionsAssignment_8 ) ) ) + // InternalBehaviorAnnexParser.g:8777:1: ( ( rule__ForStatement__ActionsAssignment_8 ) ) { - // InternalBehaviorAnnexParser.g:8777:1: ( LeftCurlyBracket ) - // InternalBehaviorAnnexParser.g:8778:2: LeftCurlyBracket + // InternalBehaviorAnnexParser.g:8777:1: ( ( rule__ForStatement__ActionsAssignment_8 ) ) + // InternalBehaviorAnnexParser.g:8778:2: ( rule__ForStatement__ActionsAssignment_8 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_8()); + before(grammarAccess.getForStatementAccess().getActionsAssignment_8()); } - match(input,LeftCurlyBracket,FollowSets000.FOLLOW_2); if (state.failed) return ; + // InternalBehaviorAnnexParser.g:8779:2: ( rule__ForStatement__ActionsAssignment_8 ) + // InternalBehaviorAnnexParser.g:8779:3: rule__ForStatement__ActionsAssignment_8 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__ForStatement__ActionsAssignment_8(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_8()); + after(grammarAccess.getForStatementAccess().getActionsAssignment_8()); } } @@ -29708,22 +29729,17 @@ public final void rule__ForStatement__Group__8__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__9" - // InternalBehaviorAnnexParser.g:8787:1: rule__ForStatement__Group__9 : rule__ForStatement__Group__9__Impl rule__ForStatement__Group__10 ; + // InternalBehaviorAnnexParser.g:8787:1: rule__ForStatement__Group__9 : rule__ForStatement__Group__9__Impl ; public final void rule__ForStatement__Group__9() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8791:1: ( rule__ForStatement__Group__9__Impl rule__ForStatement__Group__10 ) - // InternalBehaviorAnnexParser.g:8792:2: rule__ForStatement__Group__9__Impl rule__ForStatement__Group__10 + // InternalBehaviorAnnexParser.g:8791:1: ( rule__ForStatement__Group__9__Impl ) + // InternalBehaviorAnnexParser.g:8792:2: rule__ForStatement__Group__9__Impl { - pushFollow(FollowSets000.FOLLOW_10); - rule__ForStatement__Group__9__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__ForStatement__Group__10(); + rule__ForStatement__Group__9__Impl(); state._fsp--; if (state.failed) return ; @@ -29746,34 +29762,103 @@ public final void rule__ForStatement__Group__9() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__9__Impl" - // InternalBehaviorAnnexParser.g:8799:1: rule__ForStatement__Group__9__Impl : ( ( rule__ForStatement__ActionsAssignment_9 ) ) ; + // InternalBehaviorAnnexParser.g:8798:1: rule__ForStatement__Group__9__Impl : ( RightCurlyBracket ) ; public final void rule__ForStatement__Group__9__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8803:1: ( ( ( rule__ForStatement__ActionsAssignment_9 ) ) ) - // InternalBehaviorAnnexParser.g:8804:1: ( ( rule__ForStatement__ActionsAssignment_9 ) ) + // InternalBehaviorAnnexParser.g:8802:1: ( ( RightCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:8803:1: ( RightCurlyBracket ) { - // InternalBehaviorAnnexParser.g:8804:1: ( ( rule__ForStatement__ActionsAssignment_9 ) ) - // InternalBehaviorAnnexParser.g:8805:2: ( rule__ForStatement__ActionsAssignment_9 ) + // InternalBehaviorAnnexParser.g:8803:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:8804:2: RightCurlyBracket { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getActionsAssignment_9()); + before(grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_9()); + } + match(input,RightCurlyBracket,FollowSets000.FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_9()); + } + + } + + } - // InternalBehaviorAnnexParser.g:8806:2: ( rule__ForStatement__ActionsAssignment_9 ) - // InternalBehaviorAnnexParser.g:8806:3: rule__ForStatement__ActionsAssignment_9 + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ForStatement__Group__9__Impl" + + + // $ANTLR start "rule__ForStatement__Group_3__0" + // InternalBehaviorAnnexParser.g:8814:1: rule__ForStatement__Group_3__0 : rule__ForStatement__Group_3__0__Impl rule__ForStatement__Group_3__1 ; + public final void rule__ForStatement__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalBehaviorAnnexParser.g:8818:1: ( rule__ForStatement__Group_3__0__Impl rule__ForStatement__Group_3__1 ) + // InternalBehaviorAnnexParser.g:8819:2: rule__ForStatement__Group_3__0__Impl rule__ForStatement__Group_3__1 { + pushFollow(FollowSets000.FOLLOW_4); + rule__ForStatement__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__ForStatement__ActionsAssignment_9(); + rule__ForStatement__Group_3__1(); state._fsp--; if (state.failed) return ; } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ForStatement__Group_3__0" + + + // $ANTLR start "rule__ForStatement__Group_3__0__Impl" + // InternalBehaviorAnnexParser.g:8826:1: rule__ForStatement__Group_3__0__Impl : ( Colon ) ; + public final void rule__ForStatement__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalBehaviorAnnexParser.g:8830:1: ( ( Colon ) ) + // InternalBehaviorAnnexParser.g:8831:1: ( Colon ) + { + // InternalBehaviorAnnexParser.g:8831:1: ( Colon ) + // InternalBehaviorAnnexParser.g:8832:2: Colon + { + if ( state.backtracking==0 ) { + before(grammarAccess.getForStatementAccess().getColonKeyword_3_0()); + } + match(input,Colon,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getActionsAssignment_9()); + after(grammarAccess.getForStatementAccess().getColonKeyword_3_0()); } } @@ -29793,21 +29878,21 @@ public final void rule__ForStatement__Group__9__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ForStatement__Group__9__Impl" + // $ANTLR end "rule__ForStatement__Group_3__0__Impl" - // $ANTLR start "rule__ForStatement__Group__10" - // InternalBehaviorAnnexParser.g:8814:1: rule__ForStatement__Group__10 : rule__ForStatement__Group__10__Impl ; - public final void rule__ForStatement__Group__10() throws RecognitionException { + // $ANTLR start "rule__ForStatement__Group_3__1" + // InternalBehaviorAnnexParser.g:8841:1: rule__ForStatement__Group_3__1 : rule__ForStatement__Group_3__1__Impl ; + public final void rule__ForStatement__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8818:1: ( rule__ForStatement__Group__10__Impl ) - // InternalBehaviorAnnexParser.g:8819:2: rule__ForStatement__Group__10__Impl + // InternalBehaviorAnnexParser.g:8845:1: ( rule__ForStatement__Group_3__1__Impl ) + // InternalBehaviorAnnexParser.g:8846:2: rule__ForStatement__Group_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__ForStatement__Group__10__Impl(); + rule__ForStatement__Group_3__1__Impl(); state._fsp--; if (state.failed) return ; @@ -29826,28 +29911,38 @@ public final void rule__ForStatement__Group__10() throws RecognitionException { } return ; } - // $ANTLR end "rule__ForStatement__Group__10" + // $ANTLR end "rule__ForStatement__Group_3__1" - // $ANTLR start "rule__ForStatement__Group__10__Impl" - // InternalBehaviorAnnexParser.g:8825:1: rule__ForStatement__Group__10__Impl : ( RightCurlyBracket ) ; - public final void rule__ForStatement__Group__10__Impl() throws RecognitionException { + // $ANTLR start "rule__ForStatement__Group_3__1__Impl" + // InternalBehaviorAnnexParser.g:8852:1: rule__ForStatement__Group_3__1__Impl : ( ( rule__ForStatement__DataClassifierAssignment_3_1 ) ) ; + public final void rule__ForStatement__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8829:1: ( ( RightCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:8830:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:8856:1: ( ( ( rule__ForStatement__DataClassifierAssignment_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:8857:1: ( ( rule__ForStatement__DataClassifierAssignment_3_1 ) ) { - // InternalBehaviorAnnexParser.g:8830:1: ( RightCurlyBracket ) - // InternalBehaviorAnnexParser.g:8831:2: RightCurlyBracket + // InternalBehaviorAnnexParser.g:8857:1: ( ( rule__ForStatement__DataClassifierAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:8858:2: ( rule__ForStatement__DataClassifierAssignment_3_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_10()); + before(grammarAccess.getForStatementAccess().getDataClassifierAssignment_3_1()); } - match(input,RightCurlyBracket,FollowSets000.FOLLOW_2); if (state.failed) return ; + // InternalBehaviorAnnexParser.g:8859:2: ( rule__ForStatement__DataClassifierAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:8859:3: rule__ForStatement__DataClassifierAssignment_3_1 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__ForStatement__DataClassifierAssignment_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_10()); + after(grammarAccess.getForStatementAccess().getDataClassifierAssignment_3_1()); } } @@ -29867,18 +29962,18 @@ public final void rule__ForStatement__Group__10__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ForStatement__Group__10__Impl" + // $ANTLR end "rule__ForStatement__Group_3__1__Impl" // $ANTLR start "rule__WhileStatement__Group__0" - // InternalBehaviorAnnexParser.g:8841:1: rule__WhileStatement__Group__0 : rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 ; + // InternalBehaviorAnnexParser.g:8868:1: rule__WhileStatement__Group__0 : rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 ; public final void rule__WhileStatement__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8845:1: ( rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 ) - // InternalBehaviorAnnexParser.g:8846:2: rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 + // InternalBehaviorAnnexParser.g:8872:1: ( rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 ) + // InternalBehaviorAnnexParser.g:8873:2: rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 { pushFollow(FollowSets000.FOLLOW_27); rule__WhileStatement__Group__0__Impl(); @@ -29909,17 +30004,17 @@ public final void rule__WhileStatement__Group__0() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__0__Impl" - // InternalBehaviorAnnexParser.g:8853:1: rule__WhileStatement__Group__0__Impl : ( While ) ; + // InternalBehaviorAnnexParser.g:8880:1: rule__WhileStatement__Group__0__Impl : ( While ) ; public final void rule__WhileStatement__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8857:1: ( ( While ) ) - // InternalBehaviorAnnexParser.g:8858:1: ( While ) + // InternalBehaviorAnnexParser.g:8884:1: ( ( While ) ) + // InternalBehaviorAnnexParser.g:8885:1: ( While ) { - // InternalBehaviorAnnexParser.g:8858:1: ( While ) - // InternalBehaviorAnnexParser.g:8859:2: While + // InternalBehaviorAnnexParser.g:8885:1: ( While ) + // InternalBehaviorAnnexParser.g:8886:2: While { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); @@ -29950,14 +30045,14 @@ public final void rule__WhileStatement__Group__0__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__1" - // InternalBehaviorAnnexParser.g:8868:1: rule__WhileStatement__Group__1 : rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 ; + // InternalBehaviorAnnexParser.g:8895:1: rule__WhileStatement__Group__1 : rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 ; public final void rule__WhileStatement__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8872:1: ( rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 ) - // InternalBehaviorAnnexParser.g:8873:2: rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 + // InternalBehaviorAnnexParser.g:8899:1: ( rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 ) + // InternalBehaviorAnnexParser.g:8900:2: rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 { pushFollow(FollowSets000.FOLLOW_47); rule__WhileStatement__Group__1__Impl(); @@ -29988,17 +30083,17 @@ public final void rule__WhileStatement__Group__1() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__1__Impl" - // InternalBehaviorAnnexParser.g:8880:1: rule__WhileStatement__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:8907:1: rule__WhileStatement__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__WhileStatement__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8884:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:8885:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:8911:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:8912:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:8885:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:8886:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:8912:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:8913:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); @@ -30029,14 +30124,14 @@ public final void rule__WhileStatement__Group__1__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__2" - // InternalBehaviorAnnexParser.g:8895:1: rule__WhileStatement__Group__2 : rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 ; + // InternalBehaviorAnnexParser.g:8922:1: rule__WhileStatement__Group__2 : rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 ; public final void rule__WhileStatement__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8899:1: ( rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 ) - // InternalBehaviorAnnexParser.g:8900:2: rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 + // InternalBehaviorAnnexParser.g:8926:1: ( rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 ) + // InternalBehaviorAnnexParser.g:8927:2: rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 { pushFollow(FollowSets000.FOLLOW_37); rule__WhileStatement__Group__2__Impl(); @@ -30067,23 +30162,23 @@ public final void rule__WhileStatement__Group__2() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__2__Impl" - // InternalBehaviorAnnexParser.g:8907:1: rule__WhileStatement__Group__2__Impl : ( ( rule__WhileStatement__ConditionAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:8934:1: rule__WhileStatement__Group__2__Impl : ( ( rule__WhileStatement__ConditionAssignment_2 ) ) ; public final void rule__WhileStatement__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8911:1: ( ( ( rule__WhileStatement__ConditionAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:8912:1: ( ( rule__WhileStatement__ConditionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:8938:1: ( ( ( rule__WhileStatement__ConditionAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:8939:1: ( ( rule__WhileStatement__ConditionAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:8912:1: ( ( rule__WhileStatement__ConditionAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:8913:2: ( rule__WhileStatement__ConditionAssignment_2 ) + // InternalBehaviorAnnexParser.g:8939:1: ( ( rule__WhileStatement__ConditionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:8940:2: ( rule__WhileStatement__ConditionAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getConditionAssignment_2()); } - // InternalBehaviorAnnexParser.g:8914:2: ( rule__WhileStatement__ConditionAssignment_2 ) - // InternalBehaviorAnnexParser.g:8914:3: rule__WhileStatement__ConditionAssignment_2 + // InternalBehaviorAnnexParser.g:8941:2: ( rule__WhileStatement__ConditionAssignment_2 ) + // InternalBehaviorAnnexParser.g:8941:3: rule__WhileStatement__ConditionAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__WhileStatement__ConditionAssignment_2(); @@ -30118,14 +30213,14 @@ public final void rule__WhileStatement__Group__2__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__3" - // InternalBehaviorAnnexParser.g:8922:1: rule__WhileStatement__Group__3 : rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 ; + // InternalBehaviorAnnexParser.g:8949:1: rule__WhileStatement__Group__3 : rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 ; public final void rule__WhileStatement__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8926:1: ( rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 ) - // InternalBehaviorAnnexParser.g:8927:2: rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 + // InternalBehaviorAnnexParser.g:8953:1: ( rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 ) + // InternalBehaviorAnnexParser.g:8954:2: rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 { pushFollow(FollowSets000.FOLLOW_56); rule__WhileStatement__Group__3__Impl(); @@ -30156,17 +30251,17 @@ public final void rule__WhileStatement__Group__3() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__3__Impl" - // InternalBehaviorAnnexParser.g:8934:1: rule__WhileStatement__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:8961:1: rule__WhileStatement__Group__3__Impl : ( RightParenthesis ) ; public final void rule__WhileStatement__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8938:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:8939:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8965:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:8966:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:8939:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:8940:2: RightParenthesis + // InternalBehaviorAnnexParser.g:8966:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8967:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); @@ -30197,14 +30292,14 @@ public final void rule__WhileStatement__Group__3__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__4" - // InternalBehaviorAnnexParser.g:8949:1: rule__WhileStatement__Group__4 : rule__WhileStatement__Group__4__Impl rule__WhileStatement__Group__5 ; + // InternalBehaviorAnnexParser.g:8976:1: rule__WhileStatement__Group__4 : rule__WhileStatement__Group__4__Impl rule__WhileStatement__Group__5 ; public final void rule__WhileStatement__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8953:1: ( rule__WhileStatement__Group__4__Impl rule__WhileStatement__Group__5 ) - // InternalBehaviorAnnexParser.g:8954:2: rule__WhileStatement__Group__4__Impl rule__WhileStatement__Group__5 + // InternalBehaviorAnnexParser.g:8980:1: ( rule__WhileStatement__Group__4__Impl rule__WhileStatement__Group__5 ) + // InternalBehaviorAnnexParser.g:8981:2: rule__WhileStatement__Group__4__Impl rule__WhileStatement__Group__5 { pushFollow(FollowSets000.FOLLOW_38); rule__WhileStatement__Group__4__Impl(); @@ -30235,17 +30330,17 @@ public final void rule__WhileStatement__Group__4() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__4__Impl" - // InternalBehaviorAnnexParser.g:8961:1: rule__WhileStatement__Group__4__Impl : ( LeftCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:8988:1: rule__WhileStatement__Group__4__Impl : ( LeftCurlyBracket ) ; public final void rule__WhileStatement__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8965:1: ( ( LeftCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:8966:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:8992:1: ( ( LeftCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:8993:1: ( LeftCurlyBracket ) { - // InternalBehaviorAnnexParser.g:8966:1: ( LeftCurlyBracket ) - // InternalBehaviorAnnexParser.g:8967:2: LeftCurlyBracket + // InternalBehaviorAnnexParser.g:8993:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:8994:2: LeftCurlyBracket { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getLeftCurlyBracketKeyword_4()); @@ -30276,14 +30371,14 @@ public final void rule__WhileStatement__Group__4__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__5" - // InternalBehaviorAnnexParser.g:8976:1: rule__WhileStatement__Group__5 : rule__WhileStatement__Group__5__Impl rule__WhileStatement__Group__6 ; + // InternalBehaviorAnnexParser.g:9003:1: rule__WhileStatement__Group__5 : rule__WhileStatement__Group__5__Impl rule__WhileStatement__Group__6 ; public final void rule__WhileStatement__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8980:1: ( rule__WhileStatement__Group__5__Impl rule__WhileStatement__Group__6 ) - // InternalBehaviorAnnexParser.g:8981:2: rule__WhileStatement__Group__5__Impl rule__WhileStatement__Group__6 + // InternalBehaviorAnnexParser.g:9007:1: ( rule__WhileStatement__Group__5__Impl rule__WhileStatement__Group__6 ) + // InternalBehaviorAnnexParser.g:9008:2: rule__WhileStatement__Group__5__Impl rule__WhileStatement__Group__6 { pushFollow(FollowSets000.FOLLOW_10); rule__WhileStatement__Group__5__Impl(); @@ -30314,23 +30409,23 @@ public final void rule__WhileStatement__Group__5() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__5__Impl" - // InternalBehaviorAnnexParser.g:8988:1: rule__WhileStatement__Group__5__Impl : ( ( rule__WhileStatement__ActionsAssignment_5 ) ) ; + // InternalBehaviorAnnexParser.g:9015:1: rule__WhileStatement__Group__5__Impl : ( ( rule__WhileStatement__ActionsAssignment_5 ) ) ; public final void rule__WhileStatement__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8992:1: ( ( ( rule__WhileStatement__ActionsAssignment_5 ) ) ) - // InternalBehaviorAnnexParser.g:8993:1: ( ( rule__WhileStatement__ActionsAssignment_5 ) ) + // InternalBehaviorAnnexParser.g:9019:1: ( ( ( rule__WhileStatement__ActionsAssignment_5 ) ) ) + // InternalBehaviorAnnexParser.g:9020:1: ( ( rule__WhileStatement__ActionsAssignment_5 ) ) { - // InternalBehaviorAnnexParser.g:8993:1: ( ( rule__WhileStatement__ActionsAssignment_5 ) ) - // InternalBehaviorAnnexParser.g:8994:2: ( rule__WhileStatement__ActionsAssignment_5 ) + // InternalBehaviorAnnexParser.g:9020:1: ( ( rule__WhileStatement__ActionsAssignment_5 ) ) + // InternalBehaviorAnnexParser.g:9021:2: ( rule__WhileStatement__ActionsAssignment_5 ) { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getActionsAssignment_5()); } - // InternalBehaviorAnnexParser.g:8995:2: ( rule__WhileStatement__ActionsAssignment_5 ) - // InternalBehaviorAnnexParser.g:8995:3: rule__WhileStatement__ActionsAssignment_5 + // InternalBehaviorAnnexParser.g:9022:2: ( rule__WhileStatement__ActionsAssignment_5 ) + // InternalBehaviorAnnexParser.g:9022:3: rule__WhileStatement__ActionsAssignment_5 { pushFollow(FollowSets000.FOLLOW_2); rule__WhileStatement__ActionsAssignment_5(); @@ -30365,14 +30460,14 @@ public final void rule__WhileStatement__Group__5__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__6" - // InternalBehaviorAnnexParser.g:9003:1: rule__WhileStatement__Group__6 : rule__WhileStatement__Group__6__Impl ; + // InternalBehaviorAnnexParser.g:9030:1: rule__WhileStatement__Group__6 : rule__WhileStatement__Group__6__Impl ; public final void rule__WhileStatement__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9007:1: ( rule__WhileStatement__Group__6__Impl ) - // InternalBehaviorAnnexParser.g:9008:2: rule__WhileStatement__Group__6__Impl + // InternalBehaviorAnnexParser.g:9034:1: ( rule__WhileStatement__Group__6__Impl ) + // InternalBehaviorAnnexParser.g:9035:2: rule__WhileStatement__Group__6__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__WhileStatement__Group__6__Impl(); @@ -30398,17 +30493,17 @@ public final void rule__WhileStatement__Group__6() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__6__Impl" - // InternalBehaviorAnnexParser.g:9014:1: rule__WhileStatement__Group__6__Impl : ( RightCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:9041:1: rule__WhileStatement__Group__6__Impl : ( RightCurlyBracket ) ; public final void rule__WhileStatement__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9018:1: ( ( RightCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:9019:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:9045:1: ( ( RightCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:9046:1: ( RightCurlyBracket ) { - // InternalBehaviorAnnexParser.g:9019:1: ( RightCurlyBracket ) - // InternalBehaviorAnnexParser.g:9020:2: RightCurlyBracket + // InternalBehaviorAnnexParser.g:9046:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:9047:2: RightCurlyBracket { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getRightCurlyBracketKeyword_6()); @@ -30439,14 +30534,14 @@ public final void rule__WhileStatement__Group__6__Impl() throws RecognitionExcep // $ANTLR start "rule__DoUntilStatement__Group__0" - // InternalBehaviorAnnexParser.g:9030:1: rule__DoUntilStatement__Group__0 : rule__DoUntilStatement__Group__0__Impl rule__DoUntilStatement__Group__1 ; + // InternalBehaviorAnnexParser.g:9057:1: rule__DoUntilStatement__Group__0 : rule__DoUntilStatement__Group__0__Impl rule__DoUntilStatement__Group__1 ; public final void rule__DoUntilStatement__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9034:1: ( rule__DoUntilStatement__Group__0__Impl rule__DoUntilStatement__Group__1 ) - // InternalBehaviorAnnexParser.g:9035:2: rule__DoUntilStatement__Group__0__Impl rule__DoUntilStatement__Group__1 + // InternalBehaviorAnnexParser.g:9061:1: ( rule__DoUntilStatement__Group__0__Impl rule__DoUntilStatement__Group__1 ) + // InternalBehaviorAnnexParser.g:9062:2: rule__DoUntilStatement__Group__0__Impl rule__DoUntilStatement__Group__1 { pushFollow(FollowSets000.FOLLOW_38); rule__DoUntilStatement__Group__0__Impl(); @@ -30477,17 +30572,17 @@ public final void rule__DoUntilStatement__Group__0() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9042:1: rule__DoUntilStatement__Group__0__Impl : ( Do ) ; + // InternalBehaviorAnnexParser.g:9069:1: rule__DoUntilStatement__Group__0__Impl : ( Do ) ; public final void rule__DoUntilStatement__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9046:1: ( ( Do ) ) - // InternalBehaviorAnnexParser.g:9047:1: ( Do ) + // InternalBehaviorAnnexParser.g:9073:1: ( ( Do ) ) + // InternalBehaviorAnnexParser.g:9074:1: ( Do ) { - // InternalBehaviorAnnexParser.g:9047:1: ( Do ) - // InternalBehaviorAnnexParser.g:9048:2: Do + // InternalBehaviorAnnexParser.g:9074:1: ( Do ) + // InternalBehaviorAnnexParser.g:9075:2: Do { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getDoKeyword_0()); @@ -30518,14 +30613,14 @@ public final void rule__DoUntilStatement__Group__0__Impl() throws RecognitionExc // $ANTLR start "rule__DoUntilStatement__Group__1" - // InternalBehaviorAnnexParser.g:9057:1: rule__DoUntilStatement__Group__1 : rule__DoUntilStatement__Group__1__Impl rule__DoUntilStatement__Group__2 ; + // InternalBehaviorAnnexParser.g:9084:1: rule__DoUntilStatement__Group__1 : rule__DoUntilStatement__Group__1__Impl rule__DoUntilStatement__Group__2 ; public final void rule__DoUntilStatement__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9061:1: ( rule__DoUntilStatement__Group__1__Impl rule__DoUntilStatement__Group__2 ) - // InternalBehaviorAnnexParser.g:9062:2: rule__DoUntilStatement__Group__1__Impl rule__DoUntilStatement__Group__2 + // InternalBehaviorAnnexParser.g:9088:1: ( rule__DoUntilStatement__Group__1__Impl rule__DoUntilStatement__Group__2 ) + // InternalBehaviorAnnexParser.g:9089:2: rule__DoUntilStatement__Group__1__Impl rule__DoUntilStatement__Group__2 { pushFollow(FollowSets000.FOLLOW_57); rule__DoUntilStatement__Group__1__Impl(); @@ -30556,23 +30651,23 @@ public final void rule__DoUntilStatement__Group__1() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9069:1: rule__DoUntilStatement__Group__1__Impl : ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:9096:1: rule__DoUntilStatement__Group__1__Impl : ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) ; public final void rule__DoUntilStatement__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9073:1: ( ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:9074:1: ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:9100:1: ( ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:9101:1: ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:9074:1: ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:9075:2: ( rule__DoUntilStatement__ActionsAssignment_1 ) + // InternalBehaviorAnnexParser.g:9101:1: ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:9102:2: ( rule__DoUntilStatement__ActionsAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getActionsAssignment_1()); } - // InternalBehaviorAnnexParser.g:9076:2: ( rule__DoUntilStatement__ActionsAssignment_1 ) - // InternalBehaviorAnnexParser.g:9076:3: rule__DoUntilStatement__ActionsAssignment_1 + // InternalBehaviorAnnexParser.g:9103:2: ( rule__DoUntilStatement__ActionsAssignment_1 ) + // InternalBehaviorAnnexParser.g:9103:3: rule__DoUntilStatement__ActionsAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__DoUntilStatement__ActionsAssignment_1(); @@ -30607,14 +30702,14 @@ public final void rule__DoUntilStatement__Group__1__Impl() throws RecognitionExc // $ANTLR start "rule__DoUntilStatement__Group__2" - // InternalBehaviorAnnexParser.g:9084:1: rule__DoUntilStatement__Group__2 : rule__DoUntilStatement__Group__2__Impl rule__DoUntilStatement__Group__3 ; + // InternalBehaviorAnnexParser.g:9111:1: rule__DoUntilStatement__Group__2 : rule__DoUntilStatement__Group__2__Impl rule__DoUntilStatement__Group__3 ; public final void rule__DoUntilStatement__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9088:1: ( rule__DoUntilStatement__Group__2__Impl rule__DoUntilStatement__Group__3 ) - // InternalBehaviorAnnexParser.g:9089:2: rule__DoUntilStatement__Group__2__Impl rule__DoUntilStatement__Group__3 + // InternalBehaviorAnnexParser.g:9115:1: ( rule__DoUntilStatement__Group__2__Impl rule__DoUntilStatement__Group__3 ) + // InternalBehaviorAnnexParser.g:9116:2: rule__DoUntilStatement__Group__2__Impl rule__DoUntilStatement__Group__3 { pushFollow(FollowSets000.FOLLOW_27); rule__DoUntilStatement__Group__2__Impl(); @@ -30645,17 +30740,17 @@ public final void rule__DoUntilStatement__Group__2() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__2__Impl" - // InternalBehaviorAnnexParser.g:9096:1: rule__DoUntilStatement__Group__2__Impl : ( Until ) ; + // InternalBehaviorAnnexParser.g:9123:1: rule__DoUntilStatement__Group__2__Impl : ( Until ) ; public final void rule__DoUntilStatement__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9100:1: ( ( Until ) ) - // InternalBehaviorAnnexParser.g:9101:1: ( Until ) + // InternalBehaviorAnnexParser.g:9127:1: ( ( Until ) ) + // InternalBehaviorAnnexParser.g:9128:1: ( Until ) { - // InternalBehaviorAnnexParser.g:9101:1: ( Until ) - // InternalBehaviorAnnexParser.g:9102:2: Until + // InternalBehaviorAnnexParser.g:9128:1: ( Until ) + // InternalBehaviorAnnexParser.g:9129:2: Until { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getUntilKeyword_2()); @@ -30686,14 +30781,14 @@ public final void rule__DoUntilStatement__Group__2__Impl() throws RecognitionExc // $ANTLR start "rule__DoUntilStatement__Group__3" - // InternalBehaviorAnnexParser.g:9111:1: rule__DoUntilStatement__Group__3 : rule__DoUntilStatement__Group__3__Impl rule__DoUntilStatement__Group__4 ; + // InternalBehaviorAnnexParser.g:9138:1: rule__DoUntilStatement__Group__3 : rule__DoUntilStatement__Group__3__Impl rule__DoUntilStatement__Group__4 ; public final void rule__DoUntilStatement__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9115:1: ( rule__DoUntilStatement__Group__3__Impl rule__DoUntilStatement__Group__4 ) - // InternalBehaviorAnnexParser.g:9116:2: rule__DoUntilStatement__Group__3__Impl rule__DoUntilStatement__Group__4 + // InternalBehaviorAnnexParser.g:9142:1: ( rule__DoUntilStatement__Group__3__Impl rule__DoUntilStatement__Group__4 ) + // InternalBehaviorAnnexParser.g:9143:2: rule__DoUntilStatement__Group__3__Impl rule__DoUntilStatement__Group__4 { pushFollow(FollowSets000.FOLLOW_47); rule__DoUntilStatement__Group__3__Impl(); @@ -30724,17 +30819,17 @@ public final void rule__DoUntilStatement__Group__3() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__3__Impl" - // InternalBehaviorAnnexParser.g:9123:1: rule__DoUntilStatement__Group__3__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:9150:1: rule__DoUntilStatement__Group__3__Impl : ( LeftParenthesis ) ; public final void rule__DoUntilStatement__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9127:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:9128:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:9154:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:9155:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:9128:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:9129:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:9155:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:9156:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getLeftParenthesisKeyword_3()); @@ -30765,14 +30860,14 @@ public final void rule__DoUntilStatement__Group__3__Impl() throws RecognitionExc // $ANTLR start "rule__DoUntilStatement__Group__4" - // InternalBehaviorAnnexParser.g:9138:1: rule__DoUntilStatement__Group__4 : rule__DoUntilStatement__Group__4__Impl rule__DoUntilStatement__Group__5 ; + // InternalBehaviorAnnexParser.g:9165:1: rule__DoUntilStatement__Group__4 : rule__DoUntilStatement__Group__4__Impl rule__DoUntilStatement__Group__5 ; public final void rule__DoUntilStatement__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9142:1: ( rule__DoUntilStatement__Group__4__Impl rule__DoUntilStatement__Group__5 ) - // InternalBehaviorAnnexParser.g:9143:2: rule__DoUntilStatement__Group__4__Impl rule__DoUntilStatement__Group__5 + // InternalBehaviorAnnexParser.g:9169:1: ( rule__DoUntilStatement__Group__4__Impl rule__DoUntilStatement__Group__5 ) + // InternalBehaviorAnnexParser.g:9170:2: rule__DoUntilStatement__Group__4__Impl rule__DoUntilStatement__Group__5 { pushFollow(FollowSets000.FOLLOW_37); rule__DoUntilStatement__Group__4__Impl(); @@ -30803,23 +30898,23 @@ public final void rule__DoUntilStatement__Group__4() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__4__Impl" - // InternalBehaviorAnnexParser.g:9150:1: rule__DoUntilStatement__Group__4__Impl : ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) ; + // InternalBehaviorAnnexParser.g:9177:1: rule__DoUntilStatement__Group__4__Impl : ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) ; public final void rule__DoUntilStatement__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9154:1: ( ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) ) - // InternalBehaviorAnnexParser.g:9155:1: ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:9181:1: ( ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) ) + // InternalBehaviorAnnexParser.g:9182:1: ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) { - // InternalBehaviorAnnexParser.g:9155:1: ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) - // InternalBehaviorAnnexParser.g:9156:2: ( rule__DoUntilStatement__ConditionAssignment_4 ) + // InternalBehaviorAnnexParser.g:9182:1: ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:9183:2: ( rule__DoUntilStatement__ConditionAssignment_4 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getConditionAssignment_4()); } - // InternalBehaviorAnnexParser.g:9157:2: ( rule__DoUntilStatement__ConditionAssignment_4 ) - // InternalBehaviorAnnexParser.g:9157:3: rule__DoUntilStatement__ConditionAssignment_4 + // InternalBehaviorAnnexParser.g:9184:2: ( rule__DoUntilStatement__ConditionAssignment_4 ) + // InternalBehaviorAnnexParser.g:9184:3: rule__DoUntilStatement__ConditionAssignment_4 { pushFollow(FollowSets000.FOLLOW_2); rule__DoUntilStatement__ConditionAssignment_4(); @@ -30854,14 +30949,14 @@ public final void rule__DoUntilStatement__Group__4__Impl() throws RecognitionExc // $ANTLR start "rule__DoUntilStatement__Group__5" - // InternalBehaviorAnnexParser.g:9165:1: rule__DoUntilStatement__Group__5 : rule__DoUntilStatement__Group__5__Impl ; + // InternalBehaviorAnnexParser.g:9192:1: rule__DoUntilStatement__Group__5 : rule__DoUntilStatement__Group__5__Impl ; public final void rule__DoUntilStatement__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9169:1: ( rule__DoUntilStatement__Group__5__Impl ) - // InternalBehaviorAnnexParser.g:9170:2: rule__DoUntilStatement__Group__5__Impl + // InternalBehaviorAnnexParser.g:9196:1: ( rule__DoUntilStatement__Group__5__Impl ) + // InternalBehaviorAnnexParser.g:9197:2: rule__DoUntilStatement__Group__5__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DoUntilStatement__Group__5__Impl(); @@ -30887,17 +30982,17 @@ public final void rule__DoUntilStatement__Group__5() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__5__Impl" - // InternalBehaviorAnnexParser.g:9176:1: rule__DoUntilStatement__Group__5__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:9203:1: rule__DoUntilStatement__Group__5__Impl : ( RightParenthesis ) ; public final void rule__DoUntilStatement__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9180:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:9181:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:9207:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:9208:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:9181:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:9182:2: RightParenthesis + // InternalBehaviorAnnexParser.g:9208:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:9209:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getRightParenthesisKeyword_5()); @@ -30928,14 +31023,14 @@ public final void rule__DoUntilStatement__Group__5__Impl() throws RecognitionExc // $ANTLR start "rule__ElementValues__Group__0" - // InternalBehaviorAnnexParser.g:9192:1: rule__ElementValues__Group__0 : rule__ElementValues__Group__0__Impl rule__ElementValues__Group__1 ; + // InternalBehaviorAnnexParser.g:9219:1: rule__ElementValues__Group__0 : rule__ElementValues__Group__0__Impl rule__ElementValues__Group__1 ; public final void rule__ElementValues__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9196:1: ( rule__ElementValues__Group__0__Impl rule__ElementValues__Group__1 ) - // InternalBehaviorAnnexParser.g:9197:2: rule__ElementValues__Group__0__Impl rule__ElementValues__Group__1 + // InternalBehaviorAnnexParser.g:9223:1: ( rule__ElementValues__Group__0__Impl rule__ElementValues__Group__1 ) + // InternalBehaviorAnnexParser.g:9224:2: rule__ElementValues__Group__0__Impl rule__ElementValues__Group__1 { pushFollow(FollowSets000.FOLLOW_58); rule__ElementValues__Group__0__Impl(); @@ -30966,23 +31061,23 @@ public final void rule__ElementValues__Group__0() throws RecognitionException { // $ANTLR start "rule__ElementValues__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9204:1: rule__ElementValues__Group__0__Impl : ( ( rule__ElementValues__LowerAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:9231:1: rule__ElementValues__Group__0__Impl : ( ( rule__ElementValues__LowerAssignment_0 ) ) ; public final void rule__ElementValues__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9208:1: ( ( ( rule__ElementValues__LowerAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:9209:1: ( ( rule__ElementValues__LowerAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:9235:1: ( ( ( rule__ElementValues__LowerAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:9236:1: ( ( rule__ElementValues__LowerAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:9209:1: ( ( rule__ElementValues__LowerAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:9210:2: ( rule__ElementValues__LowerAssignment_0 ) + // InternalBehaviorAnnexParser.g:9236:1: ( ( rule__ElementValues__LowerAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:9237:2: ( rule__ElementValues__LowerAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getLowerAssignment_0()); } - // InternalBehaviorAnnexParser.g:9211:2: ( rule__ElementValues__LowerAssignment_0 ) - // InternalBehaviorAnnexParser.g:9211:3: rule__ElementValues__LowerAssignment_0 + // InternalBehaviorAnnexParser.g:9238:2: ( rule__ElementValues__LowerAssignment_0 ) + // InternalBehaviorAnnexParser.g:9238:3: rule__ElementValues__LowerAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ElementValues__LowerAssignment_0(); @@ -31017,14 +31112,14 @@ public final void rule__ElementValues__Group__0__Impl() throws RecognitionExcept // $ANTLR start "rule__ElementValues__Group__1" - // InternalBehaviorAnnexParser.g:9219:1: rule__ElementValues__Group__1 : rule__ElementValues__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:9246:1: rule__ElementValues__Group__1 : rule__ElementValues__Group__1__Impl ; public final void rule__ElementValues__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9223:1: ( rule__ElementValues__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9224:2: rule__ElementValues__Group__1__Impl + // InternalBehaviorAnnexParser.g:9250:1: ( rule__ElementValues__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9251:2: rule__ElementValues__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ElementValues__Group__1__Impl(); @@ -31050,31 +31145,31 @@ public final void rule__ElementValues__Group__1() throws RecognitionException { // $ANTLR start "rule__ElementValues__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9230:1: rule__ElementValues__Group__1__Impl : ( ( rule__ElementValues__Group_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:9257:1: rule__ElementValues__Group__1__Impl : ( ( rule__ElementValues__Group_1__0 )? ) ; public final void rule__ElementValues__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9234:1: ( ( ( rule__ElementValues__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:9235:1: ( ( rule__ElementValues__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:9261:1: ( ( ( rule__ElementValues__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:9262:1: ( ( rule__ElementValues__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:9235:1: ( ( rule__ElementValues__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:9236:2: ( rule__ElementValues__Group_1__0 )? + // InternalBehaviorAnnexParser.g:9262:1: ( ( rule__ElementValues__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:9263:2: ( rule__ElementValues__Group_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:9237:2: ( rule__ElementValues__Group_1__0 )? - int alt82=2; - int LA82_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:9264:2: ( rule__ElementValues__Group_1__0 )? + int alt83=2; + int LA83_0 = input.LA(1); - if ( (LA82_0==FullStopFullStop) ) { - alt82=1; + if ( (LA83_0==FullStopFullStop) ) { + alt83=1; } - switch (alt82) { + switch (alt83) { case 1 : - // InternalBehaviorAnnexParser.g:9237:3: rule__ElementValues__Group_1__0 + // InternalBehaviorAnnexParser.g:9264:3: rule__ElementValues__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ElementValues__Group_1__0(); @@ -31112,14 +31207,14 @@ public final void rule__ElementValues__Group__1__Impl() throws RecognitionExcept // $ANTLR start "rule__ElementValues__Group_1__0" - // InternalBehaviorAnnexParser.g:9246:1: rule__ElementValues__Group_1__0 : rule__ElementValues__Group_1__0__Impl rule__ElementValues__Group_1__1 ; + // InternalBehaviorAnnexParser.g:9273:1: rule__ElementValues__Group_1__0 : rule__ElementValues__Group_1__0__Impl rule__ElementValues__Group_1__1 ; public final void rule__ElementValues__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9250:1: ( rule__ElementValues__Group_1__0__Impl rule__ElementValues__Group_1__1 ) - // InternalBehaviorAnnexParser.g:9251:2: rule__ElementValues__Group_1__0__Impl rule__ElementValues__Group_1__1 + // InternalBehaviorAnnexParser.g:9277:1: ( rule__ElementValues__Group_1__0__Impl rule__ElementValues__Group_1__1 ) + // InternalBehaviorAnnexParser.g:9278:2: rule__ElementValues__Group_1__0__Impl rule__ElementValues__Group_1__1 { pushFollow(FollowSets000.FOLLOW_13); rule__ElementValues__Group_1__0__Impl(); @@ -31150,17 +31245,17 @@ public final void rule__ElementValues__Group_1__0() throws RecognitionException // $ANTLR start "rule__ElementValues__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:9258:1: rule__ElementValues__Group_1__0__Impl : ( FullStopFullStop ) ; + // InternalBehaviorAnnexParser.g:9285:1: rule__ElementValues__Group_1__0__Impl : ( FullStopFullStop ) ; public final void rule__ElementValues__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9262:1: ( ( FullStopFullStop ) ) - // InternalBehaviorAnnexParser.g:9263:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:9289:1: ( ( FullStopFullStop ) ) + // InternalBehaviorAnnexParser.g:9290:1: ( FullStopFullStop ) { - // InternalBehaviorAnnexParser.g:9263:1: ( FullStopFullStop ) - // InternalBehaviorAnnexParser.g:9264:2: FullStopFullStop + // InternalBehaviorAnnexParser.g:9290:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:9291:2: FullStopFullStop { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getFullStopFullStopKeyword_1_0()); @@ -31191,14 +31286,14 @@ public final void rule__ElementValues__Group_1__0__Impl() throws RecognitionExce // $ANTLR start "rule__ElementValues__Group_1__1" - // InternalBehaviorAnnexParser.g:9273:1: rule__ElementValues__Group_1__1 : rule__ElementValues__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:9300:1: rule__ElementValues__Group_1__1 : rule__ElementValues__Group_1__1__Impl ; public final void rule__ElementValues__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9277:1: ( rule__ElementValues__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:9278:2: rule__ElementValues__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:9304:1: ( rule__ElementValues__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:9305:2: rule__ElementValues__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ElementValues__Group_1__1__Impl(); @@ -31224,23 +31319,23 @@ public final void rule__ElementValues__Group_1__1() throws RecognitionException // $ANTLR start "rule__ElementValues__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:9284:1: rule__ElementValues__Group_1__1__Impl : ( ( rule__ElementValues__UpperAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:9311:1: rule__ElementValues__Group_1__1__Impl : ( ( rule__ElementValues__UpperAssignment_1_1 ) ) ; public final void rule__ElementValues__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9288:1: ( ( ( rule__ElementValues__UpperAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:9289:1: ( ( rule__ElementValues__UpperAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9315:1: ( ( ( rule__ElementValues__UpperAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:9316:1: ( ( rule__ElementValues__UpperAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:9289:1: ( ( rule__ElementValues__UpperAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:9290:2: ( rule__ElementValues__UpperAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9316:1: ( ( rule__ElementValues__UpperAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9317:2: ( rule__ElementValues__UpperAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getUpperAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:9291:2: ( rule__ElementValues__UpperAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:9291:3: rule__ElementValues__UpperAssignment_1_1 + // InternalBehaviorAnnexParser.g:9318:2: ( rule__ElementValues__UpperAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9318:3: rule__ElementValues__UpperAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ElementValues__UpperAssignment_1_1(); @@ -31275,14 +31370,14 @@ public final void rule__ElementValues__Group_1__1__Impl() throws RecognitionExce // $ANTLR start "rule__BehaviorTime__Group__0" - // InternalBehaviorAnnexParser.g:9300:1: rule__BehaviorTime__Group__0 : rule__BehaviorTime__Group__0__Impl rule__BehaviorTime__Group__1 ; + // InternalBehaviorAnnexParser.g:9327:1: rule__BehaviorTime__Group__0 : rule__BehaviorTime__Group__0__Impl rule__BehaviorTime__Group__1 ; public final void rule__BehaviorTime__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9304:1: ( rule__BehaviorTime__Group__0__Impl rule__BehaviorTime__Group__1 ) - // InternalBehaviorAnnexParser.g:9305:2: rule__BehaviorTime__Group__0__Impl rule__BehaviorTime__Group__1 + // InternalBehaviorAnnexParser.g:9331:1: ( rule__BehaviorTime__Group__0__Impl rule__BehaviorTime__Group__1 ) + // InternalBehaviorAnnexParser.g:9332:2: rule__BehaviorTime__Group__0__Impl rule__BehaviorTime__Group__1 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorTime__Group__0__Impl(); @@ -31313,23 +31408,23 @@ public final void rule__BehaviorTime__Group__0() throws RecognitionException { // $ANTLR start "rule__BehaviorTime__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9312:1: rule__BehaviorTime__Group__0__Impl : ( ( rule__BehaviorTime__ValueAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:9339:1: rule__BehaviorTime__Group__0__Impl : ( ( rule__BehaviorTime__ValueAssignment_0 ) ) ; public final void rule__BehaviorTime__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9316:1: ( ( ( rule__BehaviorTime__ValueAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:9317:1: ( ( rule__BehaviorTime__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:9343:1: ( ( ( rule__BehaviorTime__ValueAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:9344:1: ( ( rule__BehaviorTime__ValueAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:9317:1: ( ( rule__BehaviorTime__ValueAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:9318:2: ( rule__BehaviorTime__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:9344:1: ( ( rule__BehaviorTime__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:9345:2: ( rule__BehaviorTime__ValueAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTimeAccess().getValueAssignment_0()); } - // InternalBehaviorAnnexParser.g:9319:2: ( rule__BehaviorTime__ValueAssignment_0 ) - // InternalBehaviorAnnexParser.g:9319:3: rule__BehaviorTime__ValueAssignment_0 + // InternalBehaviorAnnexParser.g:9346:2: ( rule__BehaviorTime__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:9346:3: rule__BehaviorTime__ValueAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTime__ValueAssignment_0(); @@ -31364,14 +31459,14 @@ public final void rule__BehaviorTime__Group__0__Impl() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTime__Group__1" - // InternalBehaviorAnnexParser.g:9327:1: rule__BehaviorTime__Group__1 : rule__BehaviorTime__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:9354:1: rule__BehaviorTime__Group__1 : rule__BehaviorTime__Group__1__Impl ; public final void rule__BehaviorTime__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9331:1: ( rule__BehaviorTime__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9332:2: rule__BehaviorTime__Group__1__Impl + // InternalBehaviorAnnexParser.g:9358:1: ( rule__BehaviorTime__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9359:2: rule__BehaviorTime__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTime__Group__1__Impl(); @@ -31397,23 +31492,23 @@ public final void rule__BehaviorTime__Group__1() throws RecognitionException { // $ANTLR start "rule__BehaviorTime__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9338:1: rule__BehaviorTime__Group__1__Impl : ( ( rule__BehaviorTime__UnitAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:9365:1: rule__BehaviorTime__Group__1__Impl : ( ( rule__BehaviorTime__UnitAssignment_1 ) ) ; public final void rule__BehaviorTime__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9342:1: ( ( ( rule__BehaviorTime__UnitAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:9343:1: ( ( rule__BehaviorTime__UnitAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:9369:1: ( ( ( rule__BehaviorTime__UnitAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:9370:1: ( ( rule__BehaviorTime__UnitAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:9343:1: ( ( rule__BehaviorTime__UnitAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:9344:2: ( rule__BehaviorTime__UnitAssignment_1 ) + // InternalBehaviorAnnexParser.g:9370:1: ( ( rule__BehaviorTime__UnitAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:9371:2: ( rule__BehaviorTime__UnitAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTimeAccess().getUnitAssignment_1()); } - // InternalBehaviorAnnexParser.g:9345:2: ( rule__BehaviorTime__UnitAssignment_1 ) - // InternalBehaviorAnnexParser.g:9345:3: rule__BehaviorTime__UnitAssignment_1 + // InternalBehaviorAnnexParser.g:9372:2: ( rule__BehaviorTime__UnitAssignment_1 ) + // InternalBehaviorAnnexParser.g:9372:3: rule__BehaviorTime__UnitAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTime__UnitAssignment_1(); @@ -31448,14 +31543,14 @@ public final void rule__BehaviorTime__Group__1__Impl() throws RecognitionExcepti // $ANTLR start "rule__ValueExpression__Group__0" - // InternalBehaviorAnnexParser.g:9354:1: rule__ValueExpression__Group__0 : rule__ValueExpression__Group__0__Impl rule__ValueExpression__Group__1 ; + // InternalBehaviorAnnexParser.g:9381:1: rule__ValueExpression__Group__0 : rule__ValueExpression__Group__0__Impl rule__ValueExpression__Group__1 ; public final void rule__ValueExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9358:1: ( rule__ValueExpression__Group__0__Impl rule__ValueExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:9359:2: rule__ValueExpression__Group__0__Impl rule__ValueExpression__Group__1 + // InternalBehaviorAnnexParser.g:9385:1: ( rule__ValueExpression__Group__0__Impl rule__ValueExpression__Group__1 ) + // InternalBehaviorAnnexParser.g:9386:2: rule__ValueExpression__Group__0__Impl rule__ValueExpression__Group__1 { pushFollow(FollowSets000.FOLLOW_59); rule__ValueExpression__Group__0__Impl(); @@ -31486,17 +31581,17 @@ public final void rule__ValueExpression__Group__0() throws RecognitionException // $ANTLR start "rule__ValueExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9366:1: rule__ValueExpression__Group__0__Impl : ( ruleRelation ) ; + // InternalBehaviorAnnexParser.g:9393:1: rule__ValueExpression__Group__0__Impl : ( ruleRelation ) ; public final void rule__ValueExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9370:1: ( ( ruleRelation ) ) - // InternalBehaviorAnnexParser.g:9371:1: ( ruleRelation ) + // InternalBehaviorAnnexParser.g:9397:1: ( ( ruleRelation ) ) + // InternalBehaviorAnnexParser.g:9398:1: ( ruleRelation ) { - // InternalBehaviorAnnexParser.g:9371:1: ( ruleRelation ) - // InternalBehaviorAnnexParser.g:9372:2: ruleRelation + // InternalBehaviorAnnexParser.g:9398:1: ( ruleRelation ) + // InternalBehaviorAnnexParser.g:9399:2: ruleRelation { if ( state.backtracking==0 ) { before(grammarAccess.getValueExpressionAccess().getRelationParserRuleCall_0()); @@ -31531,14 +31626,14 @@ public final void rule__ValueExpression__Group__0__Impl() throws RecognitionExce // $ANTLR start "rule__ValueExpression__Group__1" - // InternalBehaviorAnnexParser.g:9381:1: rule__ValueExpression__Group__1 : rule__ValueExpression__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:9408:1: rule__ValueExpression__Group__1 : rule__ValueExpression__Group__1__Impl ; public final void rule__ValueExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9385:1: ( rule__ValueExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9386:2: rule__ValueExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:9412:1: ( rule__ValueExpression__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9413:2: rule__ValueExpression__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ValueExpression__Group__1__Impl(); @@ -31564,35 +31659,35 @@ public final void rule__ValueExpression__Group__1() throws RecognitionException // $ANTLR start "rule__ValueExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9392:1: rule__ValueExpression__Group__1__Impl : ( ( rule__ValueExpression__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:9419:1: rule__ValueExpression__Group__1__Impl : ( ( rule__ValueExpression__Group_1__0 )* ) ; public final void rule__ValueExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9396:1: ( ( ( rule__ValueExpression__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:9397:1: ( ( rule__ValueExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:9423:1: ( ( ( rule__ValueExpression__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:9424:1: ( ( rule__ValueExpression__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:9397:1: ( ( rule__ValueExpression__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:9398:2: ( rule__ValueExpression__Group_1__0 )* + // InternalBehaviorAnnexParser.g:9424:1: ( ( rule__ValueExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:9425:2: ( rule__ValueExpression__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getValueExpressionAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:9399:2: ( rule__ValueExpression__Group_1__0 )* - loop83: + // InternalBehaviorAnnexParser.g:9426:2: ( rule__ValueExpression__Group_1__0 )* + loop84: do { - int alt83=2; - int LA83_0 = input.LA(1); + int alt84=2; + int LA84_0 = input.LA(1); - if ( (LA83_0==And||LA83_0==Xor||LA83_0==Or) ) { - alt83=1; + if ( (LA84_0==And||LA84_0==Xor||LA84_0==Or) ) { + alt84=1; } - switch (alt83) { + switch (alt84) { case 1 : - // InternalBehaviorAnnexParser.g:9399:3: rule__ValueExpression__Group_1__0 + // InternalBehaviorAnnexParser.g:9426:3: rule__ValueExpression__Group_1__0 { pushFollow(FollowSets000.FOLLOW_60); rule__ValueExpression__Group_1__0(); @@ -31604,7 +31699,7 @@ public final void rule__ValueExpression__Group__1__Impl() throws RecognitionExce break; default : - break loop83; + break loop84; } } while (true); @@ -31633,14 +31728,14 @@ public final void rule__ValueExpression__Group__1__Impl() throws RecognitionExce // $ANTLR start "rule__ValueExpression__Group_1__0" - // InternalBehaviorAnnexParser.g:9408:1: rule__ValueExpression__Group_1__0 : rule__ValueExpression__Group_1__0__Impl rule__ValueExpression__Group_1__1 ; + // InternalBehaviorAnnexParser.g:9435:1: rule__ValueExpression__Group_1__0 : rule__ValueExpression__Group_1__0__Impl rule__ValueExpression__Group_1__1 ; public final void rule__ValueExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9412:1: ( rule__ValueExpression__Group_1__0__Impl rule__ValueExpression__Group_1__1 ) - // InternalBehaviorAnnexParser.g:9413:2: rule__ValueExpression__Group_1__0__Impl rule__ValueExpression__Group_1__1 + // InternalBehaviorAnnexParser.g:9439:1: ( rule__ValueExpression__Group_1__0__Impl rule__ValueExpression__Group_1__1 ) + // InternalBehaviorAnnexParser.g:9440:2: rule__ValueExpression__Group_1__0__Impl rule__ValueExpression__Group_1__1 { pushFollow(FollowSets000.FOLLOW_59); rule__ValueExpression__Group_1__0__Impl(); @@ -31671,23 +31766,23 @@ public final void rule__ValueExpression__Group_1__0() throws RecognitionExceptio // $ANTLR start "rule__ValueExpression__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:9420:1: rule__ValueExpression__Group_1__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:9447:1: rule__ValueExpression__Group_1__0__Impl : ( () ) ; public final void rule__ValueExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9424:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:9425:1: ( () ) + // InternalBehaviorAnnexParser.g:9451:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:9452:1: ( () ) { - // InternalBehaviorAnnexParser.g:9425:1: ( () ) - // InternalBehaviorAnnexParser.g:9426:2: () + // InternalBehaviorAnnexParser.g:9452:1: ( () ) + // InternalBehaviorAnnexParser.g:9453:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getValueExpressionAccess().getBinaryExpressionLeftAction_1_0()); } - // InternalBehaviorAnnexParser.g:9427:2: () - // InternalBehaviorAnnexParser.g:9427:3: + // InternalBehaviorAnnexParser.g:9454:2: () + // InternalBehaviorAnnexParser.g:9454:3: { } @@ -31712,14 +31807,14 @@ public final void rule__ValueExpression__Group_1__0__Impl() throws RecognitionEx // $ANTLR start "rule__ValueExpression__Group_1__1" - // InternalBehaviorAnnexParser.g:9435:1: rule__ValueExpression__Group_1__1 : rule__ValueExpression__Group_1__1__Impl rule__ValueExpression__Group_1__2 ; + // InternalBehaviorAnnexParser.g:9462:1: rule__ValueExpression__Group_1__1 : rule__ValueExpression__Group_1__1__Impl rule__ValueExpression__Group_1__2 ; public final void rule__ValueExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9439:1: ( rule__ValueExpression__Group_1__1__Impl rule__ValueExpression__Group_1__2 ) - // InternalBehaviorAnnexParser.g:9440:2: rule__ValueExpression__Group_1__1__Impl rule__ValueExpression__Group_1__2 + // InternalBehaviorAnnexParser.g:9466:1: ( rule__ValueExpression__Group_1__1__Impl rule__ValueExpression__Group_1__2 ) + // InternalBehaviorAnnexParser.g:9467:2: rule__ValueExpression__Group_1__1__Impl rule__ValueExpression__Group_1__2 { pushFollow(FollowSets000.FOLLOW_47); rule__ValueExpression__Group_1__1__Impl(); @@ -31750,23 +31845,23 @@ public final void rule__ValueExpression__Group_1__1() throws RecognitionExceptio // $ANTLR start "rule__ValueExpression__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:9447:1: rule__ValueExpression__Group_1__1__Impl : ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:9474:1: rule__ValueExpression__Group_1__1__Impl : ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) ; public final void rule__ValueExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9451:1: ( ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:9452:1: ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9478:1: ( ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:9479:1: ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:9452:1: ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:9453:2: ( rule__ValueExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9479:1: ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9480:2: ( rule__ValueExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getValueExpressionAccess().getOperatorAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:9454:2: ( rule__ValueExpression__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:9454:3: rule__ValueExpression__OperatorAssignment_1_1 + // InternalBehaviorAnnexParser.g:9481:2: ( rule__ValueExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9481:3: rule__ValueExpression__OperatorAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ValueExpression__OperatorAssignment_1_1(); @@ -31801,14 +31896,14 @@ public final void rule__ValueExpression__Group_1__1__Impl() throws RecognitionEx // $ANTLR start "rule__ValueExpression__Group_1__2" - // InternalBehaviorAnnexParser.g:9462:1: rule__ValueExpression__Group_1__2 : rule__ValueExpression__Group_1__2__Impl ; + // InternalBehaviorAnnexParser.g:9489:1: rule__ValueExpression__Group_1__2 : rule__ValueExpression__Group_1__2__Impl ; public final void rule__ValueExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9466:1: ( rule__ValueExpression__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:9467:2: rule__ValueExpression__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:9493:1: ( rule__ValueExpression__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:9494:2: rule__ValueExpression__Group_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ValueExpression__Group_1__2__Impl(); @@ -31834,23 +31929,23 @@ public final void rule__ValueExpression__Group_1__2() throws RecognitionExceptio // $ANTLR start "rule__ValueExpression__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:9473:1: rule__ValueExpression__Group_1__2__Impl : ( ( rule__ValueExpression__RightAssignment_1_2 ) ) ; + // InternalBehaviorAnnexParser.g:9500:1: rule__ValueExpression__Group_1__2__Impl : ( ( rule__ValueExpression__RightAssignment_1_2 ) ) ; public final void rule__ValueExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9477:1: ( ( ( rule__ValueExpression__RightAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:9478:1: ( ( rule__ValueExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9504:1: ( ( ( rule__ValueExpression__RightAssignment_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:9505:1: ( ( rule__ValueExpression__RightAssignment_1_2 ) ) { - // InternalBehaviorAnnexParser.g:9478:1: ( ( rule__ValueExpression__RightAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:9479:2: ( rule__ValueExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9505:1: ( ( rule__ValueExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9506:2: ( rule__ValueExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getValueExpressionAccess().getRightAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:9480:2: ( rule__ValueExpression__RightAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:9480:3: rule__ValueExpression__RightAssignment_1_2 + // InternalBehaviorAnnexParser.g:9507:2: ( rule__ValueExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9507:3: rule__ValueExpression__RightAssignment_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ValueExpression__RightAssignment_1_2(); @@ -31885,14 +31980,14 @@ public final void rule__ValueExpression__Group_1__2__Impl() throws RecognitionEx // $ANTLR start "rule__LogicalOrOperator__Group_0__0" - // InternalBehaviorAnnexParser.g:9489:1: rule__LogicalOrOperator__Group_0__0 : rule__LogicalOrOperator__Group_0__0__Impl rule__LogicalOrOperator__Group_0__1 ; + // InternalBehaviorAnnexParser.g:9516:1: rule__LogicalOrOperator__Group_0__0 : rule__LogicalOrOperator__Group_0__0__Impl rule__LogicalOrOperator__Group_0__1 ; public final void rule__LogicalOrOperator__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9493:1: ( rule__LogicalOrOperator__Group_0__0__Impl rule__LogicalOrOperator__Group_0__1 ) - // InternalBehaviorAnnexParser.g:9494:2: rule__LogicalOrOperator__Group_0__0__Impl rule__LogicalOrOperator__Group_0__1 + // InternalBehaviorAnnexParser.g:9520:1: ( rule__LogicalOrOperator__Group_0__0__Impl rule__LogicalOrOperator__Group_0__1 ) + // InternalBehaviorAnnexParser.g:9521:2: rule__LogicalOrOperator__Group_0__0__Impl rule__LogicalOrOperator__Group_0__1 { pushFollow(FollowSets000.FOLLOW_61); rule__LogicalOrOperator__Group_0__0__Impl(); @@ -31923,17 +32018,17 @@ public final void rule__LogicalOrOperator__Group_0__0() throws RecognitionExcept // $ANTLR start "rule__LogicalOrOperator__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:9501:1: rule__LogicalOrOperator__Group_0__0__Impl : ( Or ) ; + // InternalBehaviorAnnexParser.g:9528:1: rule__LogicalOrOperator__Group_0__0__Impl : ( Or ) ; public final void rule__LogicalOrOperator__Group_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9505:1: ( ( Or ) ) - // InternalBehaviorAnnexParser.g:9506:1: ( Or ) + // InternalBehaviorAnnexParser.g:9532:1: ( ( Or ) ) + // InternalBehaviorAnnexParser.g:9533:1: ( Or ) { - // InternalBehaviorAnnexParser.g:9506:1: ( Or ) - // InternalBehaviorAnnexParser.g:9507:2: Or + // InternalBehaviorAnnexParser.g:9533:1: ( Or ) + // InternalBehaviorAnnexParser.g:9534:2: Or { if ( state.backtracking==0 ) { before(grammarAccess.getLogicalOrOperatorAccess().getOrKeyword_0_0()); @@ -31964,14 +32059,14 @@ public final void rule__LogicalOrOperator__Group_0__0__Impl() throws Recognition // $ANTLR start "rule__LogicalOrOperator__Group_0__1" - // InternalBehaviorAnnexParser.g:9516:1: rule__LogicalOrOperator__Group_0__1 : rule__LogicalOrOperator__Group_0__1__Impl ; + // InternalBehaviorAnnexParser.g:9543:1: rule__LogicalOrOperator__Group_0__1 : rule__LogicalOrOperator__Group_0__1__Impl ; public final void rule__LogicalOrOperator__Group_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9520:1: ( rule__LogicalOrOperator__Group_0__1__Impl ) - // InternalBehaviorAnnexParser.g:9521:2: rule__LogicalOrOperator__Group_0__1__Impl + // InternalBehaviorAnnexParser.g:9547:1: ( rule__LogicalOrOperator__Group_0__1__Impl ) + // InternalBehaviorAnnexParser.g:9548:2: rule__LogicalOrOperator__Group_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__LogicalOrOperator__Group_0__1__Impl(); @@ -31997,31 +32092,31 @@ public final void rule__LogicalOrOperator__Group_0__1() throws RecognitionExcept // $ANTLR start "rule__LogicalOrOperator__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:9527:1: rule__LogicalOrOperator__Group_0__1__Impl : ( ( Else )? ) ; + // InternalBehaviorAnnexParser.g:9554:1: rule__LogicalOrOperator__Group_0__1__Impl : ( ( Else )? ) ; public final void rule__LogicalOrOperator__Group_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9531:1: ( ( ( Else )? ) ) - // InternalBehaviorAnnexParser.g:9532:1: ( ( Else )? ) + // InternalBehaviorAnnexParser.g:9558:1: ( ( ( Else )? ) ) + // InternalBehaviorAnnexParser.g:9559:1: ( ( Else )? ) { - // InternalBehaviorAnnexParser.g:9532:1: ( ( Else )? ) - // InternalBehaviorAnnexParser.g:9533:2: ( Else )? + // InternalBehaviorAnnexParser.g:9559:1: ( ( Else )? ) + // InternalBehaviorAnnexParser.g:9560:2: ( Else )? { if ( state.backtracking==0 ) { before(grammarAccess.getLogicalOrOperatorAccess().getElseKeyword_0_1()); } - // InternalBehaviorAnnexParser.g:9534:2: ( Else )? - int alt84=2; - int LA84_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:9561:2: ( Else )? + int alt85=2; + int LA85_0 = input.LA(1); - if ( (LA84_0==Else) ) { - alt84=1; + if ( (LA85_0==Else) ) { + alt85=1; } - switch (alt84) { + switch (alt85) { case 1 : - // InternalBehaviorAnnexParser.g:9534:3: Else + // InternalBehaviorAnnexParser.g:9561:3: Else { match(input,Else,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -32055,14 +32150,14 @@ public final void rule__LogicalOrOperator__Group_0__1__Impl() throws Recognition // $ANTLR start "rule__LogicalAndOperator__Group__0" - // InternalBehaviorAnnexParser.g:9543:1: rule__LogicalAndOperator__Group__0 : rule__LogicalAndOperator__Group__0__Impl rule__LogicalAndOperator__Group__1 ; + // InternalBehaviorAnnexParser.g:9570:1: rule__LogicalAndOperator__Group__0 : rule__LogicalAndOperator__Group__0__Impl rule__LogicalAndOperator__Group__1 ; public final void rule__LogicalAndOperator__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9547:1: ( rule__LogicalAndOperator__Group__0__Impl rule__LogicalAndOperator__Group__1 ) - // InternalBehaviorAnnexParser.g:9548:2: rule__LogicalAndOperator__Group__0__Impl rule__LogicalAndOperator__Group__1 + // InternalBehaviorAnnexParser.g:9574:1: ( rule__LogicalAndOperator__Group__0__Impl rule__LogicalAndOperator__Group__1 ) + // InternalBehaviorAnnexParser.g:9575:2: rule__LogicalAndOperator__Group__0__Impl rule__LogicalAndOperator__Group__1 { pushFollow(FollowSets000.FOLLOW_62); rule__LogicalAndOperator__Group__0__Impl(); @@ -32093,17 +32188,17 @@ public final void rule__LogicalAndOperator__Group__0() throws RecognitionExcepti // $ANTLR start "rule__LogicalAndOperator__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9555:1: rule__LogicalAndOperator__Group__0__Impl : ( And ) ; + // InternalBehaviorAnnexParser.g:9582:1: rule__LogicalAndOperator__Group__0__Impl : ( And ) ; public final void rule__LogicalAndOperator__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9559:1: ( ( And ) ) - // InternalBehaviorAnnexParser.g:9560:1: ( And ) + // InternalBehaviorAnnexParser.g:9586:1: ( ( And ) ) + // InternalBehaviorAnnexParser.g:9587:1: ( And ) { - // InternalBehaviorAnnexParser.g:9560:1: ( And ) - // InternalBehaviorAnnexParser.g:9561:2: And + // InternalBehaviorAnnexParser.g:9587:1: ( And ) + // InternalBehaviorAnnexParser.g:9588:2: And { if ( state.backtracking==0 ) { before(grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); @@ -32134,14 +32229,14 @@ public final void rule__LogicalAndOperator__Group__0__Impl() throws RecognitionE // $ANTLR start "rule__LogicalAndOperator__Group__1" - // InternalBehaviorAnnexParser.g:9570:1: rule__LogicalAndOperator__Group__1 : rule__LogicalAndOperator__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:9597:1: rule__LogicalAndOperator__Group__1 : rule__LogicalAndOperator__Group__1__Impl ; public final void rule__LogicalAndOperator__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9574:1: ( rule__LogicalAndOperator__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9575:2: rule__LogicalAndOperator__Group__1__Impl + // InternalBehaviorAnnexParser.g:9601:1: ( rule__LogicalAndOperator__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9602:2: rule__LogicalAndOperator__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__LogicalAndOperator__Group__1__Impl(); @@ -32167,31 +32262,31 @@ public final void rule__LogicalAndOperator__Group__1() throws RecognitionExcepti // $ANTLR start "rule__LogicalAndOperator__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9581:1: rule__LogicalAndOperator__Group__1__Impl : ( ( Then )? ) ; + // InternalBehaviorAnnexParser.g:9608:1: rule__LogicalAndOperator__Group__1__Impl : ( ( Then )? ) ; public final void rule__LogicalAndOperator__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9585:1: ( ( ( Then )? ) ) - // InternalBehaviorAnnexParser.g:9586:1: ( ( Then )? ) + // InternalBehaviorAnnexParser.g:9612:1: ( ( ( Then )? ) ) + // InternalBehaviorAnnexParser.g:9613:1: ( ( Then )? ) { - // InternalBehaviorAnnexParser.g:9586:1: ( ( Then )? ) - // InternalBehaviorAnnexParser.g:9587:2: ( Then )? + // InternalBehaviorAnnexParser.g:9613:1: ( ( Then )? ) + // InternalBehaviorAnnexParser.g:9614:2: ( Then )? { if ( state.backtracking==0 ) { before(grammarAccess.getLogicalAndOperatorAccess().getThenKeyword_1()); } - // InternalBehaviorAnnexParser.g:9588:2: ( Then )? - int alt85=2; - int LA85_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:9615:2: ( Then )? + int alt86=2; + int LA86_0 = input.LA(1); - if ( (LA85_0==Then) ) { - alt85=1; + if ( (LA86_0==Then) ) { + alt86=1; } - switch (alt85) { + switch (alt86) { case 1 : - // InternalBehaviorAnnexParser.g:9588:3: Then + // InternalBehaviorAnnexParser.g:9615:3: Then { match(input,Then,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -32225,14 +32320,14 @@ public final void rule__LogicalAndOperator__Group__1__Impl() throws RecognitionE // $ANTLR start "rule__Relation__Group__0" - // InternalBehaviorAnnexParser.g:9597:1: rule__Relation__Group__0 : rule__Relation__Group__0__Impl rule__Relation__Group__1 ; + // InternalBehaviorAnnexParser.g:9624:1: rule__Relation__Group__0 : rule__Relation__Group__0__Impl rule__Relation__Group__1 ; public final void rule__Relation__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9601:1: ( rule__Relation__Group__0__Impl rule__Relation__Group__1 ) - // InternalBehaviorAnnexParser.g:9602:2: rule__Relation__Group__0__Impl rule__Relation__Group__1 + // InternalBehaviorAnnexParser.g:9628:1: ( rule__Relation__Group__0__Impl rule__Relation__Group__1 ) + // InternalBehaviorAnnexParser.g:9629:2: rule__Relation__Group__0__Impl rule__Relation__Group__1 { pushFollow(FollowSets000.FOLLOW_63); rule__Relation__Group__0__Impl(); @@ -32263,17 +32358,17 @@ public final void rule__Relation__Group__0() throws RecognitionException { // $ANTLR start "rule__Relation__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9609:1: rule__Relation__Group__0__Impl : ( ruleSimpleExpression ) ; + // InternalBehaviorAnnexParser.g:9636:1: rule__Relation__Group__0__Impl : ( ruleSimpleExpression ) ; public final void rule__Relation__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9613:1: ( ( ruleSimpleExpression ) ) - // InternalBehaviorAnnexParser.g:9614:1: ( ruleSimpleExpression ) + // InternalBehaviorAnnexParser.g:9640:1: ( ( ruleSimpleExpression ) ) + // InternalBehaviorAnnexParser.g:9641:1: ( ruleSimpleExpression ) { - // InternalBehaviorAnnexParser.g:9614:1: ( ruleSimpleExpression ) - // InternalBehaviorAnnexParser.g:9615:2: ruleSimpleExpression + // InternalBehaviorAnnexParser.g:9641:1: ( ruleSimpleExpression ) + // InternalBehaviorAnnexParser.g:9642:2: ruleSimpleExpression { if ( state.backtracking==0 ) { before(grammarAccess.getRelationAccess().getSimpleExpressionParserRuleCall_0()); @@ -32308,14 +32403,14 @@ public final void rule__Relation__Group__0__Impl() throws RecognitionException { // $ANTLR start "rule__Relation__Group__1" - // InternalBehaviorAnnexParser.g:9624:1: rule__Relation__Group__1 : rule__Relation__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:9651:1: rule__Relation__Group__1 : rule__Relation__Group__1__Impl ; public final void rule__Relation__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9628:1: ( rule__Relation__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9629:2: rule__Relation__Group__1__Impl + // InternalBehaviorAnnexParser.g:9655:1: ( rule__Relation__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9656:2: rule__Relation__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__Relation__Group__1__Impl(); @@ -32341,31 +32436,31 @@ public final void rule__Relation__Group__1() throws RecognitionException { // $ANTLR start "rule__Relation__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9635:1: rule__Relation__Group__1__Impl : ( ( rule__Relation__Group_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:9662:1: rule__Relation__Group__1__Impl : ( ( rule__Relation__Group_1__0 )? ) ; public final void rule__Relation__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9639:1: ( ( ( rule__Relation__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:9640:1: ( ( rule__Relation__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:9666:1: ( ( ( rule__Relation__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:9667:1: ( ( rule__Relation__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:9640:1: ( ( rule__Relation__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:9641:2: ( rule__Relation__Group_1__0 )? + // InternalBehaviorAnnexParser.g:9667:1: ( ( rule__Relation__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:9668:2: ( rule__Relation__Group_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getRelationAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:9642:2: ( rule__Relation__Group_1__0 )? - int alt86=2; - int LA86_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:9669:2: ( rule__Relation__Group_1__0 )? + int alt87=2; + int LA87_0 = input.LA(1); - if ( (LA86_0==ExclamationMarkEqualsSign||LA86_0==LessThanSignEqualsSign||LA86_0==GreaterThanSignEqualsSign||(LA86_0>=LessThanSign && LA86_0<=GreaterThanSign)) ) { - alt86=1; + if ( (LA87_0==ExclamationMarkEqualsSign||LA87_0==LessThanSignEqualsSign||LA87_0==GreaterThanSignEqualsSign||(LA87_0>=LessThanSign && LA87_0<=GreaterThanSign)) ) { + alt87=1; } - switch (alt86) { + switch (alt87) { case 1 : - // InternalBehaviorAnnexParser.g:9642:3: rule__Relation__Group_1__0 + // InternalBehaviorAnnexParser.g:9669:3: rule__Relation__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__Relation__Group_1__0(); @@ -32403,14 +32498,14 @@ public final void rule__Relation__Group__1__Impl() throws RecognitionException { // $ANTLR start "rule__Relation__Group_1__0" - // InternalBehaviorAnnexParser.g:9651:1: rule__Relation__Group_1__0 : rule__Relation__Group_1__0__Impl rule__Relation__Group_1__1 ; + // InternalBehaviorAnnexParser.g:9678:1: rule__Relation__Group_1__0 : rule__Relation__Group_1__0__Impl rule__Relation__Group_1__1 ; public final void rule__Relation__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9655:1: ( rule__Relation__Group_1__0__Impl rule__Relation__Group_1__1 ) - // InternalBehaviorAnnexParser.g:9656:2: rule__Relation__Group_1__0__Impl rule__Relation__Group_1__1 + // InternalBehaviorAnnexParser.g:9682:1: ( rule__Relation__Group_1__0__Impl rule__Relation__Group_1__1 ) + // InternalBehaviorAnnexParser.g:9683:2: rule__Relation__Group_1__0__Impl rule__Relation__Group_1__1 { pushFollow(FollowSets000.FOLLOW_63); rule__Relation__Group_1__0__Impl(); @@ -32441,23 +32536,23 @@ public final void rule__Relation__Group_1__0() throws RecognitionException { // $ANTLR start "rule__Relation__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:9663:1: rule__Relation__Group_1__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:9690:1: rule__Relation__Group_1__0__Impl : ( () ) ; public final void rule__Relation__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9667:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:9668:1: ( () ) + // InternalBehaviorAnnexParser.g:9694:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:9695:1: ( () ) { - // InternalBehaviorAnnexParser.g:9668:1: ( () ) - // InternalBehaviorAnnexParser.g:9669:2: () + // InternalBehaviorAnnexParser.g:9695:1: ( () ) + // InternalBehaviorAnnexParser.g:9696:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getRelationAccess().getBinaryExpressionLeftAction_1_0()); } - // InternalBehaviorAnnexParser.g:9670:2: () - // InternalBehaviorAnnexParser.g:9670:3: + // InternalBehaviorAnnexParser.g:9697:2: () + // InternalBehaviorAnnexParser.g:9697:3: { } @@ -32482,14 +32577,14 @@ public final void rule__Relation__Group_1__0__Impl() throws RecognitionException // $ANTLR start "rule__Relation__Group_1__1" - // InternalBehaviorAnnexParser.g:9678:1: rule__Relation__Group_1__1 : rule__Relation__Group_1__1__Impl rule__Relation__Group_1__2 ; + // InternalBehaviorAnnexParser.g:9705:1: rule__Relation__Group_1__1 : rule__Relation__Group_1__1__Impl rule__Relation__Group_1__2 ; public final void rule__Relation__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9682:1: ( rule__Relation__Group_1__1__Impl rule__Relation__Group_1__2 ) - // InternalBehaviorAnnexParser.g:9683:2: rule__Relation__Group_1__1__Impl rule__Relation__Group_1__2 + // InternalBehaviorAnnexParser.g:9709:1: ( rule__Relation__Group_1__1__Impl rule__Relation__Group_1__2 ) + // InternalBehaviorAnnexParser.g:9710:2: rule__Relation__Group_1__1__Impl rule__Relation__Group_1__2 { pushFollow(FollowSets000.FOLLOW_47); rule__Relation__Group_1__1__Impl(); @@ -32520,23 +32615,23 @@ public final void rule__Relation__Group_1__1() throws RecognitionException { // $ANTLR start "rule__Relation__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:9690:1: rule__Relation__Group_1__1__Impl : ( ( rule__Relation__OperatorAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:9717:1: rule__Relation__Group_1__1__Impl : ( ( rule__Relation__OperatorAssignment_1_1 ) ) ; public final void rule__Relation__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9694:1: ( ( ( rule__Relation__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:9695:1: ( ( rule__Relation__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9721:1: ( ( ( rule__Relation__OperatorAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:9722:1: ( ( rule__Relation__OperatorAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:9695:1: ( ( rule__Relation__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:9696:2: ( rule__Relation__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9722:1: ( ( rule__Relation__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9723:2: ( rule__Relation__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getRelationAccess().getOperatorAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:9697:2: ( rule__Relation__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:9697:3: rule__Relation__OperatorAssignment_1_1 + // InternalBehaviorAnnexParser.g:9724:2: ( rule__Relation__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9724:3: rule__Relation__OperatorAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__Relation__OperatorAssignment_1_1(); @@ -32571,14 +32666,14 @@ public final void rule__Relation__Group_1__1__Impl() throws RecognitionException // $ANTLR start "rule__Relation__Group_1__2" - // InternalBehaviorAnnexParser.g:9705:1: rule__Relation__Group_1__2 : rule__Relation__Group_1__2__Impl ; + // InternalBehaviorAnnexParser.g:9732:1: rule__Relation__Group_1__2 : rule__Relation__Group_1__2__Impl ; public final void rule__Relation__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9709:1: ( rule__Relation__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:9710:2: rule__Relation__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:9736:1: ( rule__Relation__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:9737:2: rule__Relation__Group_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__Relation__Group_1__2__Impl(); @@ -32604,23 +32699,23 @@ public final void rule__Relation__Group_1__2() throws RecognitionException { // $ANTLR start "rule__Relation__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:9716:1: rule__Relation__Group_1__2__Impl : ( ( rule__Relation__RightAssignment_1_2 ) ) ; + // InternalBehaviorAnnexParser.g:9743:1: rule__Relation__Group_1__2__Impl : ( ( rule__Relation__RightAssignment_1_2 ) ) ; public final void rule__Relation__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9720:1: ( ( ( rule__Relation__RightAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:9721:1: ( ( rule__Relation__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9747:1: ( ( ( rule__Relation__RightAssignment_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:9748:1: ( ( rule__Relation__RightAssignment_1_2 ) ) { - // InternalBehaviorAnnexParser.g:9721:1: ( ( rule__Relation__RightAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:9722:2: ( rule__Relation__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9748:1: ( ( rule__Relation__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9749:2: ( rule__Relation__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getRelationAccess().getRightAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:9723:2: ( rule__Relation__RightAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:9723:3: rule__Relation__RightAssignment_1_2 + // InternalBehaviorAnnexParser.g:9750:2: ( rule__Relation__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9750:3: rule__Relation__RightAssignment_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__Relation__RightAssignment_1_2(); @@ -32655,14 +32750,14 @@ public final void rule__Relation__Group_1__2__Impl() throws RecognitionException // $ANTLR start "rule__SimpleExpression__Group__0" - // InternalBehaviorAnnexParser.g:9732:1: rule__SimpleExpression__Group__0 : rule__SimpleExpression__Group__0__Impl rule__SimpleExpression__Group__1 ; + // InternalBehaviorAnnexParser.g:9759:1: rule__SimpleExpression__Group__0 : rule__SimpleExpression__Group__0__Impl rule__SimpleExpression__Group__1 ; public final void rule__SimpleExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9736:1: ( rule__SimpleExpression__Group__0__Impl rule__SimpleExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:9737:2: rule__SimpleExpression__Group__0__Impl rule__SimpleExpression__Group__1 + // InternalBehaviorAnnexParser.g:9763:1: ( rule__SimpleExpression__Group__0__Impl rule__SimpleExpression__Group__1 ) + // InternalBehaviorAnnexParser.g:9764:2: rule__SimpleExpression__Group__0__Impl rule__SimpleExpression__Group__1 { pushFollow(FollowSets000.FOLLOW_64); rule__SimpleExpression__Group__0__Impl(); @@ -32693,23 +32788,23 @@ public final void rule__SimpleExpression__Group__0() throws RecognitionException // $ANTLR start "rule__SimpleExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9744:1: rule__SimpleExpression__Group__0__Impl : ( ( rule__SimpleExpression__Alternatives_0 ) ) ; + // InternalBehaviorAnnexParser.g:9771:1: rule__SimpleExpression__Group__0__Impl : ( ( rule__SimpleExpression__Alternatives_0 ) ) ; public final void rule__SimpleExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9748:1: ( ( ( rule__SimpleExpression__Alternatives_0 ) ) ) - // InternalBehaviorAnnexParser.g:9749:1: ( ( rule__SimpleExpression__Alternatives_0 ) ) + // InternalBehaviorAnnexParser.g:9775:1: ( ( ( rule__SimpleExpression__Alternatives_0 ) ) ) + // InternalBehaviorAnnexParser.g:9776:1: ( ( rule__SimpleExpression__Alternatives_0 ) ) { - // InternalBehaviorAnnexParser.g:9749:1: ( ( rule__SimpleExpression__Alternatives_0 ) ) - // InternalBehaviorAnnexParser.g:9750:2: ( rule__SimpleExpression__Alternatives_0 ) + // InternalBehaviorAnnexParser.g:9776:1: ( ( rule__SimpleExpression__Alternatives_0 ) ) + // InternalBehaviorAnnexParser.g:9777:2: ( rule__SimpleExpression__Alternatives_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getAlternatives_0()); } - // InternalBehaviorAnnexParser.g:9751:2: ( rule__SimpleExpression__Alternatives_0 ) - // InternalBehaviorAnnexParser.g:9751:3: rule__SimpleExpression__Alternatives_0 + // InternalBehaviorAnnexParser.g:9778:2: ( rule__SimpleExpression__Alternatives_0 ) + // InternalBehaviorAnnexParser.g:9778:3: rule__SimpleExpression__Alternatives_0 { pushFollow(FollowSets000.FOLLOW_2); rule__SimpleExpression__Alternatives_0(); @@ -32744,14 +32839,14 @@ public final void rule__SimpleExpression__Group__0__Impl() throws RecognitionExc // $ANTLR start "rule__SimpleExpression__Group__1" - // InternalBehaviorAnnexParser.g:9759:1: rule__SimpleExpression__Group__1 : rule__SimpleExpression__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:9786:1: rule__SimpleExpression__Group__1 : rule__SimpleExpression__Group__1__Impl ; public final void rule__SimpleExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9763:1: ( rule__SimpleExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9764:2: rule__SimpleExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:9790:1: ( rule__SimpleExpression__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9791:2: rule__SimpleExpression__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__SimpleExpression__Group__1__Impl(); @@ -32777,35 +32872,35 @@ public final void rule__SimpleExpression__Group__1() throws RecognitionException // $ANTLR start "rule__SimpleExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9770:1: rule__SimpleExpression__Group__1__Impl : ( ( rule__SimpleExpression__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:9797:1: rule__SimpleExpression__Group__1__Impl : ( ( rule__SimpleExpression__Group_1__0 )* ) ; public final void rule__SimpleExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9774:1: ( ( ( rule__SimpleExpression__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:9775:1: ( ( rule__SimpleExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:9801:1: ( ( ( rule__SimpleExpression__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:9802:1: ( ( rule__SimpleExpression__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:9775:1: ( ( rule__SimpleExpression__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:9776:2: ( rule__SimpleExpression__Group_1__0 )* + // InternalBehaviorAnnexParser.g:9802:1: ( ( rule__SimpleExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:9803:2: ( rule__SimpleExpression__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:9777:2: ( rule__SimpleExpression__Group_1__0 )* - loop87: + // InternalBehaviorAnnexParser.g:9804:2: ( rule__SimpleExpression__Group_1__0 )* + loop88: do { - int alt87=2; - int LA87_0 = input.LA(1); + int alt88=2; + int LA88_0 = input.LA(1); - if ( (LA87_0==PlusSign||LA87_0==HyphenMinus) ) { - alt87=1; + if ( (LA88_0==PlusSign||LA88_0==HyphenMinus) ) { + alt88=1; } - switch (alt87) { + switch (alt88) { case 1 : - // InternalBehaviorAnnexParser.g:9777:3: rule__SimpleExpression__Group_1__0 + // InternalBehaviorAnnexParser.g:9804:3: rule__SimpleExpression__Group_1__0 { pushFollow(FollowSets000.FOLLOW_65); rule__SimpleExpression__Group_1__0(); @@ -32817,7 +32912,7 @@ public final void rule__SimpleExpression__Group__1__Impl() throws RecognitionExc break; default : - break loop87; + break loop88; } } while (true); @@ -32846,14 +32941,14 @@ public final void rule__SimpleExpression__Group__1__Impl() throws RecognitionExc // $ANTLR start "rule__SimpleExpression__Group_0_0__0" - // InternalBehaviorAnnexParser.g:9786:1: rule__SimpleExpression__Group_0_0__0 : rule__SimpleExpression__Group_0_0__0__Impl rule__SimpleExpression__Group_0_0__1 ; + // InternalBehaviorAnnexParser.g:9813:1: rule__SimpleExpression__Group_0_0__0 : rule__SimpleExpression__Group_0_0__0__Impl rule__SimpleExpression__Group_0_0__1 ; public final void rule__SimpleExpression__Group_0_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9790:1: ( rule__SimpleExpression__Group_0_0__0__Impl rule__SimpleExpression__Group_0_0__1 ) - // InternalBehaviorAnnexParser.g:9791:2: rule__SimpleExpression__Group_0_0__0__Impl rule__SimpleExpression__Group_0_0__1 + // InternalBehaviorAnnexParser.g:9817:1: ( rule__SimpleExpression__Group_0_0__0__Impl rule__SimpleExpression__Group_0_0__1 ) + // InternalBehaviorAnnexParser.g:9818:2: rule__SimpleExpression__Group_0_0__0__Impl rule__SimpleExpression__Group_0_0__1 { pushFollow(FollowSets000.FOLLOW_64); rule__SimpleExpression__Group_0_0__0__Impl(); @@ -32884,23 +32979,23 @@ public final void rule__SimpleExpression__Group_0_0__0() throws RecognitionExcep // $ANTLR start "rule__SimpleExpression__Group_0_0__0__Impl" - // InternalBehaviorAnnexParser.g:9798:1: rule__SimpleExpression__Group_0_0__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:9825:1: rule__SimpleExpression__Group_0_0__0__Impl : ( () ) ; public final void rule__SimpleExpression__Group_0_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9802:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:9803:1: ( () ) + // InternalBehaviorAnnexParser.g:9829:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:9830:1: ( () ) { - // InternalBehaviorAnnexParser.g:9803:1: ( () ) - // InternalBehaviorAnnexParser.g:9804:2: () + // InternalBehaviorAnnexParser.g:9830:1: ( () ) + // InternalBehaviorAnnexParser.g:9831:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getUnaryExpressionAction_0_0_0()); } - // InternalBehaviorAnnexParser.g:9805:2: () - // InternalBehaviorAnnexParser.g:9805:3: + // InternalBehaviorAnnexParser.g:9832:2: () + // InternalBehaviorAnnexParser.g:9832:3: { } @@ -32925,14 +33020,14 @@ public final void rule__SimpleExpression__Group_0_0__0__Impl() throws Recognitio // $ANTLR start "rule__SimpleExpression__Group_0_0__1" - // InternalBehaviorAnnexParser.g:9813:1: rule__SimpleExpression__Group_0_0__1 : rule__SimpleExpression__Group_0_0__1__Impl rule__SimpleExpression__Group_0_0__2 ; + // InternalBehaviorAnnexParser.g:9840:1: rule__SimpleExpression__Group_0_0__1 : rule__SimpleExpression__Group_0_0__1__Impl rule__SimpleExpression__Group_0_0__2 ; public final void rule__SimpleExpression__Group_0_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9817:1: ( rule__SimpleExpression__Group_0_0__1__Impl rule__SimpleExpression__Group_0_0__2 ) - // InternalBehaviorAnnexParser.g:9818:2: rule__SimpleExpression__Group_0_0__1__Impl rule__SimpleExpression__Group_0_0__2 + // InternalBehaviorAnnexParser.g:9844:1: ( rule__SimpleExpression__Group_0_0__1__Impl rule__SimpleExpression__Group_0_0__2 ) + // InternalBehaviorAnnexParser.g:9845:2: rule__SimpleExpression__Group_0_0__1__Impl rule__SimpleExpression__Group_0_0__2 { pushFollow(FollowSets000.FOLLOW_47); rule__SimpleExpression__Group_0_0__1__Impl(); @@ -32963,23 +33058,23 @@ public final void rule__SimpleExpression__Group_0_0__1() throws RecognitionExcep // $ANTLR start "rule__SimpleExpression__Group_0_0__1__Impl" - // InternalBehaviorAnnexParser.g:9825:1: rule__SimpleExpression__Group_0_0__1__Impl : ( ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) ) ; + // InternalBehaviorAnnexParser.g:9852:1: rule__SimpleExpression__Group_0_0__1__Impl : ( ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) ) ; public final void rule__SimpleExpression__Group_0_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9829:1: ( ( ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) ) ) - // InternalBehaviorAnnexParser.g:9830:1: ( ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) ) + // InternalBehaviorAnnexParser.g:9856:1: ( ( ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) ) ) + // InternalBehaviorAnnexParser.g:9857:1: ( ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) ) { - // InternalBehaviorAnnexParser.g:9830:1: ( ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) ) - // InternalBehaviorAnnexParser.g:9831:2: ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) + // InternalBehaviorAnnexParser.g:9857:1: ( ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) ) + // InternalBehaviorAnnexParser.g:9858:2: ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_0_0_1()); } - // InternalBehaviorAnnexParser.g:9832:2: ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) - // InternalBehaviorAnnexParser.g:9832:3: rule__SimpleExpression__OperatorAssignment_0_0_1 + // InternalBehaviorAnnexParser.g:9859:2: ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) + // InternalBehaviorAnnexParser.g:9859:3: rule__SimpleExpression__OperatorAssignment_0_0_1 { pushFollow(FollowSets000.FOLLOW_2); rule__SimpleExpression__OperatorAssignment_0_0_1(); @@ -33014,14 +33109,14 @@ public final void rule__SimpleExpression__Group_0_0__1__Impl() throws Recognitio // $ANTLR start "rule__SimpleExpression__Group_0_0__2" - // InternalBehaviorAnnexParser.g:9840:1: rule__SimpleExpression__Group_0_0__2 : rule__SimpleExpression__Group_0_0__2__Impl ; + // InternalBehaviorAnnexParser.g:9867:1: rule__SimpleExpression__Group_0_0__2 : rule__SimpleExpression__Group_0_0__2__Impl ; public final void rule__SimpleExpression__Group_0_0__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9844:1: ( rule__SimpleExpression__Group_0_0__2__Impl ) - // InternalBehaviorAnnexParser.g:9845:2: rule__SimpleExpression__Group_0_0__2__Impl + // InternalBehaviorAnnexParser.g:9871:1: ( rule__SimpleExpression__Group_0_0__2__Impl ) + // InternalBehaviorAnnexParser.g:9872:2: rule__SimpleExpression__Group_0_0__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__SimpleExpression__Group_0_0__2__Impl(); @@ -33047,23 +33142,23 @@ public final void rule__SimpleExpression__Group_0_0__2() throws RecognitionExcep // $ANTLR start "rule__SimpleExpression__Group_0_0__2__Impl" - // InternalBehaviorAnnexParser.g:9851:1: rule__SimpleExpression__Group_0_0__2__Impl : ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) ; + // InternalBehaviorAnnexParser.g:9878:1: rule__SimpleExpression__Group_0_0__2__Impl : ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) ; public final void rule__SimpleExpression__Group_0_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9855:1: ( ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) ) - // InternalBehaviorAnnexParser.g:9856:1: ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) + // InternalBehaviorAnnexParser.g:9882:1: ( ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) ) + // InternalBehaviorAnnexParser.g:9883:1: ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) { - // InternalBehaviorAnnexParser.g:9856:1: ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) - // InternalBehaviorAnnexParser.g:9857:2: ( rule__SimpleExpression__OperandAssignment_0_0_2 ) + // InternalBehaviorAnnexParser.g:9883:1: ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) + // InternalBehaviorAnnexParser.g:9884:2: ( rule__SimpleExpression__OperandAssignment_0_0_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getOperandAssignment_0_0_2()); } - // InternalBehaviorAnnexParser.g:9858:2: ( rule__SimpleExpression__OperandAssignment_0_0_2 ) - // InternalBehaviorAnnexParser.g:9858:3: rule__SimpleExpression__OperandAssignment_0_0_2 + // InternalBehaviorAnnexParser.g:9885:2: ( rule__SimpleExpression__OperandAssignment_0_0_2 ) + // InternalBehaviorAnnexParser.g:9885:3: rule__SimpleExpression__OperandAssignment_0_0_2 { pushFollow(FollowSets000.FOLLOW_2); rule__SimpleExpression__OperandAssignment_0_0_2(); @@ -33098,14 +33193,14 @@ public final void rule__SimpleExpression__Group_0_0__2__Impl() throws Recognitio // $ANTLR start "rule__SimpleExpression__Group_1__0" - // InternalBehaviorAnnexParser.g:9867:1: rule__SimpleExpression__Group_1__0 : rule__SimpleExpression__Group_1__0__Impl rule__SimpleExpression__Group_1__1 ; + // InternalBehaviorAnnexParser.g:9894:1: rule__SimpleExpression__Group_1__0 : rule__SimpleExpression__Group_1__0__Impl rule__SimpleExpression__Group_1__1 ; public final void rule__SimpleExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9871:1: ( rule__SimpleExpression__Group_1__0__Impl rule__SimpleExpression__Group_1__1 ) - // InternalBehaviorAnnexParser.g:9872:2: rule__SimpleExpression__Group_1__0__Impl rule__SimpleExpression__Group_1__1 + // InternalBehaviorAnnexParser.g:9898:1: ( rule__SimpleExpression__Group_1__0__Impl rule__SimpleExpression__Group_1__1 ) + // InternalBehaviorAnnexParser.g:9899:2: rule__SimpleExpression__Group_1__0__Impl rule__SimpleExpression__Group_1__1 { pushFollow(FollowSets000.FOLLOW_64); rule__SimpleExpression__Group_1__0__Impl(); @@ -33136,23 +33231,23 @@ public final void rule__SimpleExpression__Group_1__0() throws RecognitionExcepti // $ANTLR start "rule__SimpleExpression__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:9879:1: rule__SimpleExpression__Group_1__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:9906:1: rule__SimpleExpression__Group_1__0__Impl : ( () ) ; public final void rule__SimpleExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9883:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:9884:1: ( () ) + // InternalBehaviorAnnexParser.g:9910:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:9911:1: ( () ) { - // InternalBehaviorAnnexParser.g:9884:1: ( () ) - // InternalBehaviorAnnexParser.g:9885:2: () + // InternalBehaviorAnnexParser.g:9911:1: ( () ) + // InternalBehaviorAnnexParser.g:9912:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getBinaryExpressionLeftAction_1_0()); } - // InternalBehaviorAnnexParser.g:9886:2: () - // InternalBehaviorAnnexParser.g:9886:3: + // InternalBehaviorAnnexParser.g:9913:2: () + // InternalBehaviorAnnexParser.g:9913:3: { } @@ -33177,14 +33272,14 @@ public final void rule__SimpleExpression__Group_1__0__Impl() throws RecognitionE // $ANTLR start "rule__SimpleExpression__Group_1__1" - // InternalBehaviorAnnexParser.g:9894:1: rule__SimpleExpression__Group_1__1 : rule__SimpleExpression__Group_1__1__Impl rule__SimpleExpression__Group_1__2 ; + // InternalBehaviorAnnexParser.g:9921:1: rule__SimpleExpression__Group_1__1 : rule__SimpleExpression__Group_1__1__Impl rule__SimpleExpression__Group_1__2 ; public final void rule__SimpleExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9898:1: ( rule__SimpleExpression__Group_1__1__Impl rule__SimpleExpression__Group_1__2 ) - // InternalBehaviorAnnexParser.g:9899:2: rule__SimpleExpression__Group_1__1__Impl rule__SimpleExpression__Group_1__2 + // InternalBehaviorAnnexParser.g:9925:1: ( rule__SimpleExpression__Group_1__1__Impl rule__SimpleExpression__Group_1__2 ) + // InternalBehaviorAnnexParser.g:9926:2: rule__SimpleExpression__Group_1__1__Impl rule__SimpleExpression__Group_1__2 { pushFollow(FollowSets000.FOLLOW_47); rule__SimpleExpression__Group_1__1__Impl(); @@ -33215,23 +33310,23 @@ public final void rule__SimpleExpression__Group_1__1() throws RecognitionExcepti // $ANTLR start "rule__SimpleExpression__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:9906:1: rule__SimpleExpression__Group_1__1__Impl : ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:9933:1: rule__SimpleExpression__Group_1__1__Impl : ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) ; public final void rule__SimpleExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9910:1: ( ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:9911:1: ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9937:1: ( ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:9938:1: ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:9911:1: ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:9912:2: ( rule__SimpleExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9938:1: ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9939:2: ( rule__SimpleExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:9913:2: ( rule__SimpleExpression__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:9913:3: rule__SimpleExpression__OperatorAssignment_1_1 + // InternalBehaviorAnnexParser.g:9940:2: ( rule__SimpleExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9940:3: rule__SimpleExpression__OperatorAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__SimpleExpression__OperatorAssignment_1_1(); @@ -33266,14 +33361,14 @@ public final void rule__SimpleExpression__Group_1__1__Impl() throws RecognitionE // $ANTLR start "rule__SimpleExpression__Group_1__2" - // InternalBehaviorAnnexParser.g:9921:1: rule__SimpleExpression__Group_1__2 : rule__SimpleExpression__Group_1__2__Impl ; + // InternalBehaviorAnnexParser.g:9948:1: rule__SimpleExpression__Group_1__2 : rule__SimpleExpression__Group_1__2__Impl ; public final void rule__SimpleExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9925:1: ( rule__SimpleExpression__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:9926:2: rule__SimpleExpression__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:9952:1: ( rule__SimpleExpression__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:9953:2: rule__SimpleExpression__Group_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__SimpleExpression__Group_1__2__Impl(); @@ -33299,23 +33394,23 @@ public final void rule__SimpleExpression__Group_1__2() throws RecognitionExcepti // $ANTLR start "rule__SimpleExpression__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:9932:1: rule__SimpleExpression__Group_1__2__Impl : ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) ; + // InternalBehaviorAnnexParser.g:9959:1: rule__SimpleExpression__Group_1__2__Impl : ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) ; public final void rule__SimpleExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9936:1: ( ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:9937:1: ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9963:1: ( ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:9964:1: ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) { - // InternalBehaviorAnnexParser.g:9937:1: ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:9938:2: ( rule__SimpleExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9964:1: ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9965:2: ( rule__SimpleExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getRightAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:9939:2: ( rule__SimpleExpression__RightAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:9939:3: rule__SimpleExpression__RightAssignment_1_2 + // InternalBehaviorAnnexParser.g:9966:2: ( rule__SimpleExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9966:3: rule__SimpleExpression__RightAssignment_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__SimpleExpression__RightAssignment_1_2(); @@ -33350,14 +33445,14 @@ public final void rule__SimpleExpression__Group_1__2__Impl() throws RecognitionE // $ANTLR start "rule__Term__Group__0" - // InternalBehaviorAnnexParser.g:9948:1: rule__Term__Group__0 : rule__Term__Group__0__Impl rule__Term__Group__1 ; + // InternalBehaviorAnnexParser.g:9975:1: rule__Term__Group__0 : rule__Term__Group__0__Impl rule__Term__Group__1 ; public final void rule__Term__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9952:1: ( rule__Term__Group__0__Impl rule__Term__Group__1 ) - // InternalBehaviorAnnexParser.g:9953:2: rule__Term__Group__0__Impl rule__Term__Group__1 + // InternalBehaviorAnnexParser.g:9979:1: ( rule__Term__Group__0__Impl rule__Term__Group__1 ) + // InternalBehaviorAnnexParser.g:9980:2: rule__Term__Group__0__Impl rule__Term__Group__1 { pushFollow(FollowSets000.FOLLOW_66); rule__Term__Group__0__Impl(); @@ -33388,17 +33483,17 @@ public final void rule__Term__Group__0() throws RecognitionException { // $ANTLR start "rule__Term__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9960:1: rule__Term__Group__0__Impl : ( ruleFactor ) ; + // InternalBehaviorAnnexParser.g:9987:1: rule__Term__Group__0__Impl : ( ruleFactor ) ; public final void rule__Term__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9964:1: ( ( ruleFactor ) ) - // InternalBehaviorAnnexParser.g:9965:1: ( ruleFactor ) + // InternalBehaviorAnnexParser.g:9991:1: ( ( ruleFactor ) ) + // InternalBehaviorAnnexParser.g:9992:1: ( ruleFactor ) { - // InternalBehaviorAnnexParser.g:9965:1: ( ruleFactor ) - // InternalBehaviorAnnexParser.g:9966:2: ruleFactor + // InternalBehaviorAnnexParser.g:9992:1: ( ruleFactor ) + // InternalBehaviorAnnexParser.g:9993:2: ruleFactor { if ( state.backtracking==0 ) { before(grammarAccess.getTermAccess().getFactorParserRuleCall_0()); @@ -33433,14 +33528,14 @@ public final void rule__Term__Group__0__Impl() throws RecognitionException { // $ANTLR start "rule__Term__Group__1" - // InternalBehaviorAnnexParser.g:9975:1: rule__Term__Group__1 : rule__Term__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:10002:1: rule__Term__Group__1 : rule__Term__Group__1__Impl ; public final void rule__Term__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9979:1: ( rule__Term__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9980:2: rule__Term__Group__1__Impl + // InternalBehaviorAnnexParser.g:10006:1: ( rule__Term__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:10007:2: rule__Term__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__Term__Group__1__Impl(); @@ -33466,35 +33561,35 @@ public final void rule__Term__Group__1() throws RecognitionException { // $ANTLR start "rule__Term__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9986:1: rule__Term__Group__1__Impl : ( ( rule__Term__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:10013:1: rule__Term__Group__1__Impl : ( ( rule__Term__Group_1__0 )* ) ; public final void rule__Term__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9990:1: ( ( ( rule__Term__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:9991:1: ( ( rule__Term__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:10017:1: ( ( ( rule__Term__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:10018:1: ( ( rule__Term__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:9991:1: ( ( rule__Term__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:9992:2: ( rule__Term__Group_1__0 )* + // InternalBehaviorAnnexParser.g:10018:1: ( ( rule__Term__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:10019:2: ( rule__Term__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getTermAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:9993:2: ( rule__Term__Group_1__0 )* - loop88: + // InternalBehaviorAnnexParser.g:10020:2: ( rule__Term__Group_1__0 )* + loop89: do { - int alt88=2; - int LA88_0 = input.LA(1); + int alt89=2; + int LA89_0 = input.LA(1); - if ( (LA88_0==Mod||LA88_0==Rem||LA88_0==Asterisk||LA88_0==Solidus) ) { - alt88=1; + if ( (LA89_0==Mod||LA89_0==Rem||LA89_0==Asterisk||LA89_0==Solidus) ) { + alt89=1; } - switch (alt88) { + switch (alt89) { case 1 : - // InternalBehaviorAnnexParser.g:9993:3: rule__Term__Group_1__0 + // InternalBehaviorAnnexParser.g:10020:3: rule__Term__Group_1__0 { pushFollow(FollowSets000.FOLLOW_67); rule__Term__Group_1__0(); @@ -33506,7 +33601,7 @@ public final void rule__Term__Group__1__Impl() throws RecognitionException { break; default : - break loop88; + break loop89; } } while (true); @@ -33535,14 +33630,14 @@ public final void rule__Term__Group__1__Impl() throws RecognitionException { // $ANTLR start "rule__Term__Group_1__0" - // InternalBehaviorAnnexParser.g:10002:1: rule__Term__Group_1__0 : rule__Term__Group_1__0__Impl rule__Term__Group_1__1 ; + // InternalBehaviorAnnexParser.g:10029:1: rule__Term__Group_1__0 : rule__Term__Group_1__0__Impl rule__Term__Group_1__1 ; public final void rule__Term__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10006:1: ( rule__Term__Group_1__0__Impl rule__Term__Group_1__1 ) - // InternalBehaviorAnnexParser.g:10007:2: rule__Term__Group_1__0__Impl rule__Term__Group_1__1 + // InternalBehaviorAnnexParser.g:10033:1: ( rule__Term__Group_1__0__Impl rule__Term__Group_1__1 ) + // InternalBehaviorAnnexParser.g:10034:2: rule__Term__Group_1__0__Impl rule__Term__Group_1__1 { pushFollow(FollowSets000.FOLLOW_66); rule__Term__Group_1__0__Impl(); @@ -33573,23 +33668,23 @@ public final void rule__Term__Group_1__0() throws RecognitionException { // $ANTLR start "rule__Term__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:10014:1: rule__Term__Group_1__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:10041:1: rule__Term__Group_1__0__Impl : ( () ) ; public final void rule__Term__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10018:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:10019:1: ( () ) + // InternalBehaviorAnnexParser.g:10045:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:10046:1: ( () ) { - // InternalBehaviorAnnexParser.g:10019:1: ( () ) - // InternalBehaviorAnnexParser.g:10020:2: () + // InternalBehaviorAnnexParser.g:10046:1: ( () ) + // InternalBehaviorAnnexParser.g:10047:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getTermAccess().getBinaryExpressionLeftAction_1_0()); } - // InternalBehaviorAnnexParser.g:10021:2: () - // InternalBehaviorAnnexParser.g:10021:3: + // InternalBehaviorAnnexParser.g:10048:2: () + // InternalBehaviorAnnexParser.g:10048:3: { } @@ -33614,14 +33709,14 @@ public final void rule__Term__Group_1__0__Impl() throws RecognitionException { // $ANTLR start "rule__Term__Group_1__1" - // InternalBehaviorAnnexParser.g:10029:1: rule__Term__Group_1__1 : rule__Term__Group_1__1__Impl rule__Term__Group_1__2 ; + // InternalBehaviorAnnexParser.g:10056:1: rule__Term__Group_1__1 : rule__Term__Group_1__1__Impl rule__Term__Group_1__2 ; public final void rule__Term__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10033:1: ( rule__Term__Group_1__1__Impl rule__Term__Group_1__2 ) - // InternalBehaviorAnnexParser.g:10034:2: rule__Term__Group_1__1__Impl rule__Term__Group_1__2 + // InternalBehaviorAnnexParser.g:10060:1: ( rule__Term__Group_1__1__Impl rule__Term__Group_1__2 ) + // InternalBehaviorAnnexParser.g:10061:2: rule__Term__Group_1__1__Impl rule__Term__Group_1__2 { pushFollow(FollowSets000.FOLLOW_47); rule__Term__Group_1__1__Impl(); @@ -33652,23 +33747,23 @@ public final void rule__Term__Group_1__1() throws RecognitionException { // $ANTLR start "rule__Term__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:10041:1: rule__Term__Group_1__1__Impl : ( ( rule__Term__OperatorAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:10068:1: rule__Term__Group_1__1__Impl : ( ( rule__Term__OperatorAssignment_1_1 ) ) ; public final void rule__Term__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10045:1: ( ( ( rule__Term__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:10046:1: ( ( rule__Term__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:10072:1: ( ( ( rule__Term__OperatorAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:10073:1: ( ( rule__Term__OperatorAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:10046:1: ( ( rule__Term__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:10047:2: ( rule__Term__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:10073:1: ( ( rule__Term__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:10074:2: ( rule__Term__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getTermAccess().getOperatorAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:10048:2: ( rule__Term__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:10048:3: rule__Term__OperatorAssignment_1_1 + // InternalBehaviorAnnexParser.g:10075:2: ( rule__Term__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:10075:3: rule__Term__OperatorAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__Term__OperatorAssignment_1_1(); @@ -33703,14 +33798,14 @@ public final void rule__Term__Group_1__1__Impl() throws RecognitionException { // $ANTLR start "rule__Term__Group_1__2" - // InternalBehaviorAnnexParser.g:10056:1: rule__Term__Group_1__2 : rule__Term__Group_1__2__Impl ; + // InternalBehaviorAnnexParser.g:10083:1: rule__Term__Group_1__2 : rule__Term__Group_1__2__Impl ; public final void rule__Term__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10060:1: ( rule__Term__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:10061:2: rule__Term__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:10087:1: ( rule__Term__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:10088:2: rule__Term__Group_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__Term__Group_1__2__Impl(); @@ -33736,23 +33831,23 @@ public final void rule__Term__Group_1__2() throws RecognitionException { // $ANTLR start "rule__Term__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:10067:1: rule__Term__Group_1__2__Impl : ( ( rule__Term__RightAssignment_1_2 ) ) ; + // InternalBehaviorAnnexParser.g:10094:1: rule__Term__Group_1__2__Impl : ( ( rule__Term__RightAssignment_1_2 ) ) ; public final void rule__Term__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10071:1: ( ( ( rule__Term__RightAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:10072:1: ( ( rule__Term__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:10098:1: ( ( ( rule__Term__RightAssignment_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:10099:1: ( ( rule__Term__RightAssignment_1_2 ) ) { - // InternalBehaviorAnnexParser.g:10072:1: ( ( rule__Term__RightAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:10073:2: ( rule__Term__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:10099:1: ( ( rule__Term__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:10100:2: ( rule__Term__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getTermAccess().getRightAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:10074:2: ( rule__Term__RightAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:10074:3: rule__Term__RightAssignment_1_2 + // InternalBehaviorAnnexParser.g:10101:2: ( rule__Term__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:10101:3: rule__Term__RightAssignment_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__Term__RightAssignment_1_2(); @@ -33787,14 +33882,14 @@ public final void rule__Term__Group_1__2__Impl() throws RecognitionException { // $ANTLR start "rule__Factor__Group_0__0" - // InternalBehaviorAnnexParser.g:10083:1: rule__Factor__Group_0__0 : rule__Factor__Group_0__0__Impl rule__Factor__Group_0__1 ; + // InternalBehaviorAnnexParser.g:10110:1: rule__Factor__Group_0__0 : rule__Factor__Group_0__0__Impl rule__Factor__Group_0__1 ; public final void rule__Factor__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10087:1: ( rule__Factor__Group_0__0__Impl rule__Factor__Group_0__1 ) - // InternalBehaviorAnnexParser.g:10088:2: rule__Factor__Group_0__0__Impl rule__Factor__Group_0__1 + // InternalBehaviorAnnexParser.g:10114:1: ( rule__Factor__Group_0__0__Impl rule__Factor__Group_0__1 ) + // InternalBehaviorAnnexParser.g:10115:2: rule__Factor__Group_0__0__Impl rule__Factor__Group_0__1 { pushFollow(FollowSets000.FOLLOW_68); rule__Factor__Group_0__0__Impl(); @@ -33825,17 +33920,17 @@ public final void rule__Factor__Group_0__0() throws RecognitionException { // $ANTLR start "rule__Factor__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:10095:1: rule__Factor__Group_0__0__Impl : ( ruleValue ) ; + // InternalBehaviorAnnexParser.g:10122:1: rule__Factor__Group_0__0__Impl : ( ruleValue ) ; public final void rule__Factor__Group_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10099:1: ( ( ruleValue ) ) - // InternalBehaviorAnnexParser.g:10100:1: ( ruleValue ) + // InternalBehaviorAnnexParser.g:10126:1: ( ( ruleValue ) ) + // InternalBehaviorAnnexParser.g:10127:1: ( ruleValue ) { - // InternalBehaviorAnnexParser.g:10100:1: ( ruleValue ) - // InternalBehaviorAnnexParser.g:10101:2: ruleValue + // InternalBehaviorAnnexParser.g:10127:1: ( ruleValue ) + // InternalBehaviorAnnexParser.g:10128:2: ruleValue { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getValueParserRuleCall_0_0()); @@ -33870,14 +33965,14 @@ public final void rule__Factor__Group_0__0__Impl() throws RecognitionException { // $ANTLR start "rule__Factor__Group_0__1" - // InternalBehaviorAnnexParser.g:10110:1: rule__Factor__Group_0__1 : rule__Factor__Group_0__1__Impl ; + // InternalBehaviorAnnexParser.g:10137:1: rule__Factor__Group_0__1 : rule__Factor__Group_0__1__Impl ; public final void rule__Factor__Group_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10114:1: ( rule__Factor__Group_0__1__Impl ) - // InternalBehaviorAnnexParser.g:10115:2: rule__Factor__Group_0__1__Impl + // InternalBehaviorAnnexParser.g:10141:1: ( rule__Factor__Group_0__1__Impl ) + // InternalBehaviorAnnexParser.g:10142:2: rule__Factor__Group_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__Factor__Group_0__1__Impl(); @@ -33903,31 +33998,31 @@ public final void rule__Factor__Group_0__1() throws RecognitionException { // $ANTLR start "rule__Factor__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:10121:1: rule__Factor__Group_0__1__Impl : ( ( rule__Factor__Group_0_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:10148:1: rule__Factor__Group_0__1__Impl : ( ( rule__Factor__Group_0_1__0 )? ) ; public final void rule__Factor__Group_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10125:1: ( ( ( rule__Factor__Group_0_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:10126:1: ( ( rule__Factor__Group_0_1__0 )? ) + // InternalBehaviorAnnexParser.g:10152:1: ( ( ( rule__Factor__Group_0_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:10153:1: ( ( rule__Factor__Group_0_1__0 )? ) { - // InternalBehaviorAnnexParser.g:10126:1: ( ( rule__Factor__Group_0_1__0 )? ) - // InternalBehaviorAnnexParser.g:10127:2: ( rule__Factor__Group_0_1__0 )? + // InternalBehaviorAnnexParser.g:10153:1: ( ( rule__Factor__Group_0_1__0 )? ) + // InternalBehaviorAnnexParser.g:10154:2: ( rule__Factor__Group_0_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getGroup_0_1()); } - // InternalBehaviorAnnexParser.g:10128:2: ( rule__Factor__Group_0_1__0 )? - int alt89=2; - int LA89_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:10155:2: ( rule__Factor__Group_0_1__0 )? + int alt90=2; + int LA90_0 = input.LA(1); - if ( (LA89_0==AsteriskAsterisk) ) { - alt89=1; + if ( (LA90_0==AsteriskAsterisk) ) { + alt90=1; } - switch (alt89) { + switch (alt90) { case 1 : - // InternalBehaviorAnnexParser.g:10128:3: rule__Factor__Group_0_1__0 + // InternalBehaviorAnnexParser.g:10155:3: rule__Factor__Group_0_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__Factor__Group_0_1__0(); @@ -33965,14 +34060,14 @@ public final void rule__Factor__Group_0__1__Impl() throws RecognitionException { // $ANTLR start "rule__Factor__Group_0_1__0" - // InternalBehaviorAnnexParser.g:10137:1: rule__Factor__Group_0_1__0 : rule__Factor__Group_0_1__0__Impl rule__Factor__Group_0_1__1 ; + // InternalBehaviorAnnexParser.g:10164:1: rule__Factor__Group_0_1__0 : rule__Factor__Group_0_1__0__Impl rule__Factor__Group_0_1__1 ; public final void rule__Factor__Group_0_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10141:1: ( rule__Factor__Group_0_1__0__Impl rule__Factor__Group_0_1__1 ) - // InternalBehaviorAnnexParser.g:10142:2: rule__Factor__Group_0_1__0__Impl rule__Factor__Group_0_1__1 + // InternalBehaviorAnnexParser.g:10168:1: ( rule__Factor__Group_0_1__0__Impl rule__Factor__Group_0_1__1 ) + // InternalBehaviorAnnexParser.g:10169:2: rule__Factor__Group_0_1__0__Impl rule__Factor__Group_0_1__1 { pushFollow(FollowSets000.FOLLOW_68); rule__Factor__Group_0_1__0__Impl(); @@ -34003,23 +34098,23 @@ public final void rule__Factor__Group_0_1__0() throws RecognitionException { // $ANTLR start "rule__Factor__Group_0_1__0__Impl" - // InternalBehaviorAnnexParser.g:10149:1: rule__Factor__Group_0_1__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:10176:1: rule__Factor__Group_0_1__0__Impl : ( () ) ; public final void rule__Factor__Group_0_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10153:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:10154:1: ( () ) + // InternalBehaviorAnnexParser.g:10180:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:10181:1: ( () ) { - // InternalBehaviorAnnexParser.g:10154:1: ( () ) - // InternalBehaviorAnnexParser.g:10155:2: () + // InternalBehaviorAnnexParser.g:10181:1: ( () ) + // InternalBehaviorAnnexParser.g:10182:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getBinaryExpressionLeftAction_0_1_0()); } - // InternalBehaviorAnnexParser.g:10156:2: () - // InternalBehaviorAnnexParser.g:10156:3: + // InternalBehaviorAnnexParser.g:10183:2: () + // InternalBehaviorAnnexParser.g:10183:3: { } @@ -34044,14 +34139,14 @@ public final void rule__Factor__Group_0_1__0__Impl() throws RecognitionException // $ANTLR start "rule__Factor__Group_0_1__1" - // InternalBehaviorAnnexParser.g:10164:1: rule__Factor__Group_0_1__1 : rule__Factor__Group_0_1__1__Impl rule__Factor__Group_0_1__2 ; + // InternalBehaviorAnnexParser.g:10191:1: rule__Factor__Group_0_1__1 : rule__Factor__Group_0_1__1__Impl rule__Factor__Group_0_1__2 ; public final void rule__Factor__Group_0_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10168:1: ( rule__Factor__Group_0_1__1__Impl rule__Factor__Group_0_1__2 ) - // InternalBehaviorAnnexParser.g:10169:2: rule__Factor__Group_0_1__1__Impl rule__Factor__Group_0_1__2 + // InternalBehaviorAnnexParser.g:10195:1: ( rule__Factor__Group_0_1__1__Impl rule__Factor__Group_0_1__2 ) + // InternalBehaviorAnnexParser.g:10196:2: rule__Factor__Group_0_1__1__Impl rule__Factor__Group_0_1__2 { pushFollow(FollowSets000.FOLLOW_29); rule__Factor__Group_0_1__1__Impl(); @@ -34082,23 +34177,23 @@ public final void rule__Factor__Group_0_1__1() throws RecognitionException { // $ANTLR start "rule__Factor__Group_0_1__1__Impl" - // InternalBehaviorAnnexParser.g:10176:1: rule__Factor__Group_0_1__1__Impl : ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:10203:1: rule__Factor__Group_0_1__1__Impl : ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) ; public final void rule__Factor__Group_0_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10180:1: ( ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:10181:1: ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) + // InternalBehaviorAnnexParser.g:10207:1: ( ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:10208:1: ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) { - // InternalBehaviorAnnexParser.g:10181:1: ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) - // InternalBehaviorAnnexParser.g:10182:2: ( rule__Factor__OperatorAssignment_0_1_1 ) + // InternalBehaviorAnnexParser.g:10208:1: ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) + // InternalBehaviorAnnexParser.g:10209:2: ( rule__Factor__OperatorAssignment_0_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getOperatorAssignment_0_1_1()); } - // InternalBehaviorAnnexParser.g:10183:2: ( rule__Factor__OperatorAssignment_0_1_1 ) - // InternalBehaviorAnnexParser.g:10183:3: rule__Factor__OperatorAssignment_0_1_1 + // InternalBehaviorAnnexParser.g:10210:2: ( rule__Factor__OperatorAssignment_0_1_1 ) + // InternalBehaviorAnnexParser.g:10210:3: rule__Factor__OperatorAssignment_0_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__Factor__OperatorAssignment_0_1_1(); @@ -34133,14 +34228,14 @@ public final void rule__Factor__Group_0_1__1__Impl() throws RecognitionException // $ANTLR start "rule__Factor__Group_0_1__2" - // InternalBehaviorAnnexParser.g:10191:1: rule__Factor__Group_0_1__2 : rule__Factor__Group_0_1__2__Impl ; + // InternalBehaviorAnnexParser.g:10218:1: rule__Factor__Group_0_1__2 : rule__Factor__Group_0_1__2__Impl ; public final void rule__Factor__Group_0_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10195:1: ( rule__Factor__Group_0_1__2__Impl ) - // InternalBehaviorAnnexParser.g:10196:2: rule__Factor__Group_0_1__2__Impl + // InternalBehaviorAnnexParser.g:10222:1: ( rule__Factor__Group_0_1__2__Impl ) + // InternalBehaviorAnnexParser.g:10223:2: rule__Factor__Group_0_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__Factor__Group_0_1__2__Impl(); @@ -34166,23 +34261,23 @@ public final void rule__Factor__Group_0_1__2() throws RecognitionException { // $ANTLR start "rule__Factor__Group_0_1__2__Impl" - // InternalBehaviorAnnexParser.g:10202:1: rule__Factor__Group_0_1__2__Impl : ( ( rule__Factor__RightAssignment_0_1_2 ) ) ; + // InternalBehaviorAnnexParser.g:10229:1: rule__Factor__Group_0_1__2__Impl : ( ( rule__Factor__RightAssignment_0_1_2 ) ) ; public final void rule__Factor__Group_0_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10206:1: ( ( ( rule__Factor__RightAssignment_0_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:10207:1: ( ( rule__Factor__RightAssignment_0_1_2 ) ) + // InternalBehaviorAnnexParser.g:10233:1: ( ( ( rule__Factor__RightAssignment_0_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:10234:1: ( ( rule__Factor__RightAssignment_0_1_2 ) ) { - // InternalBehaviorAnnexParser.g:10207:1: ( ( rule__Factor__RightAssignment_0_1_2 ) ) - // InternalBehaviorAnnexParser.g:10208:2: ( rule__Factor__RightAssignment_0_1_2 ) + // InternalBehaviorAnnexParser.g:10234:1: ( ( rule__Factor__RightAssignment_0_1_2 ) ) + // InternalBehaviorAnnexParser.g:10235:2: ( rule__Factor__RightAssignment_0_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getRightAssignment_0_1_2()); } - // InternalBehaviorAnnexParser.g:10209:2: ( rule__Factor__RightAssignment_0_1_2 ) - // InternalBehaviorAnnexParser.g:10209:3: rule__Factor__RightAssignment_0_1_2 + // InternalBehaviorAnnexParser.g:10236:2: ( rule__Factor__RightAssignment_0_1_2 ) + // InternalBehaviorAnnexParser.g:10236:3: rule__Factor__RightAssignment_0_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__Factor__RightAssignment_0_1_2(); @@ -34217,14 +34312,14 @@ public final void rule__Factor__Group_0_1__2__Impl() throws RecognitionException // $ANTLR start "rule__Factor__Group_1__0" - // InternalBehaviorAnnexParser.g:10218:1: rule__Factor__Group_1__0 : rule__Factor__Group_1__0__Impl rule__Factor__Group_1__1 ; + // InternalBehaviorAnnexParser.g:10245:1: rule__Factor__Group_1__0 : rule__Factor__Group_1__0__Impl rule__Factor__Group_1__1 ; public final void rule__Factor__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10222:1: ( rule__Factor__Group_1__0__Impl rule__Factor__Group_1__1 ) - // InternalBehaviorAnnexParser.g:10223:2: rule__Factor__Group_1__0__Impl rule__Factor__Group_1__1 + // InternalBehaviorAnnexParser.g:10249:1: ( rule__Factor__Group_1__0__Impl rule__Factor__Group_1__1 ) + // InternalBehaviorAnnexParser.g:10250:2: rule__Factor__Group_1__0__Impl rule__Factor__Group_1__1 { pushFollow(FollowSets000.FOLLOW_47); rule__Factor__Group_1__0__Impl(); @@ -34255,23 +34350,23 @@ public final void rule__Factor__Group_1__0() throws RecognitionException { // $ANTLR start "rule__Factor__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:10230:1: rule__Factor__Group_1__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:10257:1: rule__Factor__Group_1__0__Impl : ( () ) ; public final void rule__Factor__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10234:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:10235:1: ( () ) + // InternalBehaviorAnnexParser.g:10261:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:10262:1: ( () ) { - // InternalBehaviorAnnexParser.g:10235:1: ( () ) - // InternalBehaviorAnnexParser.g:10236:2: () + // InternalBehaviorAnnexParser.g:10262:1: ( () ) + // InternalBehaviorAnnexParser.g:10263:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getUnaryExpressionAction_1_0()); } - // InternalBehaviorAnnexParser.g:10237:2: () - // InternalBehaviorAnnexParser.g:10237:3: + // InternalBehaviorAnnexParser.g:10264:2: () + // InternalBehaviorAnnexParser.g:10264:3: { } @@ -34296,14 +34391,14 @@ public final void rule__Factor__Group_1__0__Impl() throws RecognitionException { // $ANTLR start "rule__Factor__Group_1__1" - // InternalBehaviorAnnexParser.g:10245:1: rule__Factor__Group_1__1 : rule__Factor__Group_1__1__Impl rule__Factor__Group_1__2 ; + // InternalBehaviorAnnexParser.g:10272:1: rule__Factor__Group_1__1 : rule__Factor__Group_1__1__Impl rule__Factor__Group_1__2 ; public final void rule__Factor__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10249:1: ( rule__Factor__Group_1__1__Impl rule__Factor__Group_1__2 ) - // InternalBehaviorAnnexParser.g:10250:2: rule__Factor__Group_1__1__Impl rule__Factor__Group_1__2 + // InternalBehaviorAnnexParser.g:10276:1: ( rule__Factor__Group_1__1__Impl rule__Factor__Group_1__2 ) + // InternalBehaviorAnnexParser.g:10277:2: rule__Factor__Group_1__1__Impl rule__Factor__Group_1__2 { pushFollow(FollowSets000.FOLLOW_29); rule__Factor__Group_1__1__Impl(); @@ -34334,23 +34429,23 @@ public final void rule__Factor__Group_1__1() throws RecognitionException { // $ANTLR start "rule__Factor__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:10257:1: rule__Factor__Group_1__1__Impl : ( ( rule__Factor__OperatorAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:10284:1: rule__Factor__Group_1__1__Impl : ( ( rule__Factor__OperatorAssignment_1_1 ) ) ; public final void rule__Factor__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10261:1: ( ( ( rule__Factor__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:10262:1: ( ( rule__Factor__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:10288:1: ( ( ( rule__Factor__OperatorAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:10289:1: ( ( rule__Factor__OperatorAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:10262:1: ( ( rule__Factor__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:10263:2: ( rule__Factor__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:10289:1: ( ( rule__Factor__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:10290:2: ( rule__Factor__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getOperatorAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:10264:2: ( rule__Factor__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:10264:3: rule__Factor__OperatorAssignment_1_1 + // InternalBehaviorAnnexParser.g:10291:2: ( rule__Factor__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:10291:3: rule__Factor__OperatorAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__Factor__OperatorAssignment_1_1(); @@ -34385,14 +34480,14 @@ public final void rule__Factor__Group_1__1__Impl() throws RecognitionException { // $ANTLR start "rule__Factor__Group_1__2" - // InternalBehaviorAnnexParser.g:10272:1: rule__Factor__Group_1__2 : rule__Factor__Group_1__2__Impl ; + // InternalBehaviorAnnexParser.g:10299:1: rule__Factor__Group_1__2 : rule__Factor__Group_1__2__Impl ; public final void rule__Factor__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10276:1: ( rule__Factor__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:10277:2: rule__Factor__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:10303:1: ( rule__Factor__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:10304:2: rule__Factor__Group_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__Factor__Group_1__2__Impl(); @@ -34418,23 +34513,23 @@ public final void rule__Factor__Group_1__2() throws RecognitionException { // $ANTLR start "rule__Factor__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:10283:1: rule__Factor__Group_1__2__Impl : ( ( rule__Factor__OperandAssignment_1_2 ) ) ; + // InternalBehaviorAnnexParser.g:10310:1: rule__Factor__Group_1__2__Impl : ( ( rule__Factor__OperandAssignment_1_2 ) ) ; public final void rule__Factor__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10287:1: ( ( ( rule__Factor__OperandAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:10288:1: ( ( rule__Factor__OperandAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:10314:1: ( ( ( rule__Factor__OperandAssignment_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:10315:1: ( ( rule__Factor__OperandAssignment_1_2 ) ) { - // InternalBehaviorAnnexParser.g:10288:1: ( ( rule__Factor__OperandAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:10289:2: ( rule__Factor__OperandAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:10315:1: ( ( rule__Factor__OperandAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:10316:2: ( rule__Factor__OperandAssignment_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getOperandAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:10290:2: ( rule__Factor__OperandAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:10290:3: rule__Factor__OperandAssignment_1_2 + // InternalBehaviorAnnexParser.g:10317:2: ( rule__Factor__OperandAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:10317:3: rule__Factor__OperandAssignment_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__Factor__OperandAssignment_1_2(); @@ -34469,14 +34564,14 @@ public final void rule__Factor__Group_1__2__Impl() throws RecognitionException { // $ANTLR start "rule__ParenthesizedExpression__Group__0" - // InternalBehaviorAnnexParser.g:10299:1: rule__ParenthesizedExpression__Group__0 : rule__ParenthesizedExpression__Group__0__Impl rule__ParenthesizedExpression__Group__1 ; + // InternalBehaviorAnnexParser.g:10326:1: rule__ParenthesizedExpression__Group__0 : rule__ParenthesizedExpression__Group__0__Impl rule__ParenthesizedExpression__Group__1 ; public final void rule__ParenthesizedExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10303:1: ( rule__ParenthesizedExpression__Group__0__Impl rule__ParenthesizedExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:10304:2: rule__ParenthesizedExpression__Group__0__Impl rule__ParenthesizedExpression__Group__1 + // InternalBehaviorAnnexParser.g:10330:1: ( rule__ParenthesizedExpression__Group__0__Impl rule__ParenthesizedExpression__Group__1 ) + // InternalBehaviorAnnexParser.g:10331:2: rule__ParenthesizedExpression__Group__0__Impl rule__ParenthesizedExpression__Group__1 { pushFollow(FollowSets000.FOLLOW_47); rule__ParenthesizedExpression__Group__0__Impl(); @@ -34507,17 +34602,17 @@ public final void rule__ParenthesizedExpression__Group__0() throws RecognitionEx // $ANTLR start "rule__ParenthesizedExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10311:1: rule__ParenthesizedExpression__Group__0__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:10338:1: rule__ParenthesizedExpression__Group__0__Impl : ( LeftParenthesis ) ; public final void rule__ParenthesizedExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10315:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:10316:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:10342:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:10343:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:10316:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:10317:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:10343:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:10344:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); @@ -34548,14 +34643,14 @@ public final void rule__ParenthesizedExpression__Group__0__Impl() throws Recogni // $ANTLR start "rule__ParenthesizedExpression__Group__1" - // InternalBehaviorAnnexParser.g:10326:1: rule__ParenthesizedExpression__Group__1 : rule__ParenthesizedExpression__Group__1__Impl rule__ParenthesizedExpression__Group__2 ; + // InternalBehaviorAnnexParser.g:10353:1: rule__ParenthesizedExpression__Group__1 : rule__ParenthesizedExpression__Group__1__Impl rule__ParenthesizedExpression__Group__2 ; public final void rule__ParenthesizedExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10330:1: ( rule__ParenthesizedExpression__Group__1__Impl rule__ParenthesizedExpression__Group__2 ) - // InternalBehaviorAnnexParser.g:10331:2: rule__ParenthesizedExpression__Group__1__Impl rule__ParenthesizedExpression__Group__2 + // InternalBehaviorAnnexParser.g:10357:1: ( rule__ParenthesizedExpression__Group__1__Impl rule__ParenthesizedExpression__Group__2 ) + // InternalBehaviorAnnexParser.g:10358:2: rule__ParenthesizedExpression__Group__1__Impl rule__ParenthesizedExpression__Group__2 { pushFollow(FollowSets000.FOLLOW_37); rule__ParenthesizedExpression__Group__1__Impl(); @@ -34586,23 +34681,23 @@ public final void rule__ParenthesizedExpression__Group__1() throws RecognitionEx // $ANTLR start "rule__ParenthesizedExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10338:1: rule__ParenthesizedExpression__Group__1__Impl : ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10365:1: rule__ParenthesizedExpression__Group__1__Impl : ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) ; public final void rule__ParenthesizedExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10342:1: ( ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10343:1: ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10369:1: ( ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10370:1: ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10343:1: ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10344:2: ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) + // InternalBehaviorAnnexParser.g:10370:1: ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10371:2: ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getParenthesizedExpressionAccess().getExpressionAssignment_1()); } - // InternalBehaviorAnnexParser.g:10345:2: ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) - // InternalBehaviorAnnexParser.g:10345:3: rule__ParenthesizedExpression__ExpressionAssignment_1 + // InternalBehaviorAnnexParser.g:10372:2: ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) + // InternalBehaviorAnnexParser.g:10372:3: rule__ParenthesizedExpression__ExpressionAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ParenthesizedExpression__ExpressionAssignment_1(); @@ -34637,14 +34732,14 @@ public final void rule__ParenthesizedExpression__Group__1__Impl() throws Recogni // $ANTLR start "rule__ParenthesizedExpression__Group__2" - // InternalBehaviorAnnexParser.g:10353:1: rule__ParenthesizedExpression__Group__2 : rule__ParenthesizedExpression__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:10380:1: rule__ParenthesizedExpression__Group__2 : rule__ParenthesizedExpression__Group__2__Impl ; public final void rule__ParenthesizedExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10357:1: ( rule__ParenthesizedExpression__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:10358:2: rule__ParenthesizedExpression__Group__2__Impl + // InternalBehaviorAnnexParser.g:10384:1: ( rule__ParenthesizedExpression__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:10385:2: rule__ParenthesizedExpression__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ParenthesizedExpression__Group__2__Impl(); @@ -34670,17 +34765,17 @@ public final void rule__ParenthesizedExpression__Group__2() throws RecognitionEx // $ANTLR start "rule__ParenthesizedExpression__Group__2__Impl" - // InternalBehaviorAnnexParser.g:10364:1: rule__ParenthesizedExpression__Group__2__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:10391:1: rule__ParenthesizedExpression__Group__2__Impl : ( RightParenthesis ) ; public final void rule__ParenthesizedExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10368:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:10369:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:10395:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:10396:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:10369:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:10370:2: RightParenthesis + // InternalBehaviorAnnexParser.g:10396:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:10397:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); @@ -34711,14 +34806,14 @@ public final void rule__ParenthesizedExpression__Group__2__Impl() throws Recogni // $ANTLR start "rule__BehaviorBooleanLiteral__Group__0" - // InternalBehaviorAnnexParser.g:10380:1: rule__BehaviorBooleanLiteral__Group__0 : rule__BehaviorBooleanLiteral__Group__0__Impl rule__BehaviorBooleanLiteral__Group__1 ; + // InternalBehaviorAnnexParser.g:10407:1: rule__BehaviorBooleanLiteral__Group__0 : rule__BehaviorBooleanLiteral__Group__0__Impl rule__BehaviorBooleanLiteral__Group__1 ; public final void rule__BehaviorBooleanLiteral__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10384:1: ( rule__BehaviorBooleanLiteral__Group__0__Impl rule__BehaviorBooleanLiteral__Group__1 ) - // InternalBehaviorAnnexParser.g:10385:2: rule__BehaviorBooleanLiteral__Group__0__Impl rule__BehaviorBooleanLiteral__Group__1 + // InternalBehaviorAnnexParser.g:10411:1: ( rule__BehaviorBooleanLiteral__Group__0__Impl rule__BehaviorBooleanLiteral__Group__1 ) + // InternalBehaviorAnnexParser.g:10412:2: rule__BehaviorBooleanLiteral__Group__0__Impl rule__BehaviorBooleanLiteral__Group__1 { pushFollow(FollowSets000.FOLLOW_69); rule__BehaviorBooleanLiteral__Group__0__Impl(); @@ -34749,23 +34844,23 @@ public final void rule__BehaviorBooleanLiteral__Group__0() throws RecognitionExc // $ANTLR start "rule__BehaviorBooleanLiteral__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10392:1: rule__BehaviorBooleanLiteral__Group__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:10419:1: rule__BehaviorBooleanLiteral__Group__0__Impl : ( () ) ; public final void rule__BehaviorBooleanLiteral__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10396:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:10397:1: ( () ) + // InternalBehaviorAnnexParser.g:10423:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:10424:1: ( () ) { - // InternalBehaviorAnnexParser.g:10397:1: ( () ) - // InternalBehaviorAnnexParser.g:10398:2: () + // InternalBehaviorAnnexParser.g:10424:1: ( () ) + // InternalBehaviorAnnexParser.g:10425:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getBehaviorBooleanLiteralAction_0()); } - // InternalBehaviorAnnexParser.g:10399:2: () - // InternalBehaviorAnnexParser.g:10399:3: + // InternalBehaviorAnnexParser.g:10426:2: () + // InternalBehaviorAnnexParser.g:10426:3: { } @@ -34790,14 +34885,14 @@ public final void rule__BehaviorBooleanLiteral__Group__0__Impl() throws Recognit // $ANTLR start "rule__BehaviorBooleanLiteral__Group__1" - // InternalBehaviorAnnexParser.g:10407:1: rule__BehaviorBooleanLiteral__Group__1 : rule__BehaviorBooleanLiteral__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:10434:1: rule__BehaviorBooleanLiteral__Group__1 : rule__BehaviorBooleanLiteral__Group__1__Impl ; public final void rule__BehaviorBooleanLiteral__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10411:1: ( rule__BehaviorBooleanLiteral__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:10412:2: rule__BehaviorBooleanLiteral__Group__1__Impl + // InternalBehaviorAnnexParser.g:10438:1: ( rule__BehaviorBooleanLiteral__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:10439:2: rule__BehaviorBooleanLiteral__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorBooleanLiteral__Group__1__Impl(); @@ -34823,23 +34918,23 @@ public final void rule__BehaviorBooleanLiteral__Group__1() throws RecognitionExc // $ANTLR start "rule__BehaviorBooleanLiteral__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10418:1: rule__BehaviorBooleanLiteral__Group__1__Impl : ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) ; + // InternalBehaviorAnnexParser.g:10445:1: rule__BehaviorBooleanLiteral__Group__1__Impl : ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) ; public final void rule__BehaviorBooleanLiteral__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10422:1: ( ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) ) - // InternalBehaviorAnnexParser.g:10423:1: ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:10449:1: ( ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) ) + // InternalBehaviorAnnexParser.g:10450:1: ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) { - // InternalBehaviorAnnexParser.g:10423:1: ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) - // InternalBehaviorAnnexParser.g:10424:2: ( rule__BehaviorBooleanLiteral__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:10450:1: ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:10451:2: ( rule__BehaviorBooleanLiteral__Alternatives_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:10425:2: ( rule__BehaviorBooleanLiteral__Alternatives_1 ) - // InternalBehaviorAnnexParser.g:10425:3: rule__BehaviorBooleanLiteral__Alternatives_1 + // InternalBehaviorAnnexParser.g:10452:2: ( rule__BehaviorBooleanLiteral__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:10452:3: rule__BehaviorBooleanLiteral__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorBooleanLiteral__Alternatives_1(); @@ -34874,14 +34969,14 @@ public final void rule__BehaviorBooleanLiteral__Group__1__Impl() throws Recognit // $ANTLR start "rule__ReferenceExpression__Group__0" - // InternalBehaviorAnnexParser.g:10434:1: rule__ReferenceExpression__Group__0 : rule__ReferenceExpression__Group__0__Impl rule__ReferenceExpression__Group__1 ; + // InternalBehaviorAnnexParser.g:10461:1: rule__ReferenceExpression__Group__0 : rule__ReferenceExpression__Group__0__Impl rule__ReferenceExpression__Group__1 ; public final void rule__ReferenceExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10438:1: ( rule__ReferenceExpression__Group__0__Impl rule__ReferenceExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:10439:2: rule__ReferenceExpression__Group__0__Impl rule__ReferenceExpression__Group__1 + // InternalBehaviorAnnexParser.g:10465:1: ( rule__ReferenceExpression__Group__0__Impl rule__ReferenceExpression__Group__1 ) + // InternalBehaviorAnnexParser.g:10466:2: rule__ReferenceExpression__Group__0__Impl rule__ReferenceExpression__Group__1 { pushFollow(FollowSets000.FOLLOW_70); rule__ReferenceExpression__Group__0__Impl(); @@ -34912,23 +35007,23 @@ public final void rule__ReferenceExpression__Group__0() throws RecognitionExcept // $ANTLR start "rule__ReferenceExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10446:1: rule__ReferenceExpression__Group__0__Impl : ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:10473:1: rule__ReferenceExpression__Group__0__Impl : ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) ; public final void rule__ReferenceExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10450:1: ( ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:10451:1: ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:10477:1: ( ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:10478:1: ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:10451:1: ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:10452:2: ( rule__ReferenceExpression__ReferenceAssignment_0 ) + // InternalBehaviorAnnexParser.g:10478:1: ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:10479:2: ( rule__ReferenceExpression__ReferenceAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getReferenceAssignment_0()); } - // InternalBehaviorAnnexParser.g:10453:2: ( rule__ReferenceExpression__ReferenceAssignment_0 ) - // InternalBehaviorAnnexParser.g:10453:3: rule__ReferenceExpression__ReferenceAssignment_0 + // InternalBehaviorAnnexParser.g:10480:2: ( rule__ReferenceExpression__ReferenceAssignment_0 ) + // InternalBehaviorAnnexParser.g:10480:3: rule__ReferenceExpression__ReferenceAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__ReferenceAssignment_0(); @@ -34963,14 +35058,14 @@ public final void rule__ReferenceExpression__Group__0__Impl() throws Recognition // $ANTLR start "rule__ReferenceExpression__Group__1" - // InternalBehaviorAnnexParser.g:10461:1: rule__ReferenceExpression__Group__1 : rule__ReferenceExpression__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:10488:1: rule__ReferenceExpression__Group__1 : rule__ReferenceExpression__Group__1__Impl ; public final void rule__ReferenceExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10465:1: ( rule__ReferenceExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:10466:2: rule__ReferenceExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:10492:1: ( rule__ReferenceExpression__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:10493:2: rule__ReferenceExpression__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__Group__1__Impl(); @@ -34996,31 +35091,31 @@ public final void rule__ReferenceExpression__Group__1() throws RecognitionExcept // $ANTLR start "rule__ReferenceExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10472:1: rule__ReferenceExpression__Group__1__Impl : ( ( rule__ReferenceExpression__Alternatives_1 )? ) ; + // InternalBehaviorAnnexParser.g:10499:1: rule__ReferenceExpression__Group__1__Impl : ( ( rule__ReferenceExpression__Alternatives_1 )? ) ; public final void rule__ReferenceExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10476:1: ( ( ( rule__ReferenceExpression__Alternatives_1 )? ) ) - // InternalBehaviorAnnexParser.g:10477:1: ( ( rule__ReferenceExpression__Alternatives_1 )? ) + // InternalBehaviorAnnexParser.g:10503:1: ( ( ( rule__ReferenceExpression__Alternatives_1 )? ) ) + // InternalBehaviorAnnexParser.g:10504:1: ( ( rule__ReferenceExpression__Alternatives_1 )? ) { - // InternalBehaviorAnnexParser.g:10477:1: ( ( rule__ReferenceExpression__Alternatives_1 )? ) - // InternalBehaviorAnnexParser.g:10478:2: ( rule__ReferenceExpression__Alternatives_1 )? + // InternalBehaviorAnnexParser.g:10504:1: ( ( rule__ReferenceExpression__Alternatives_1 )? ) + // InternalBehaviorAnnexParser.g:10505:2: ( rule__ReferenceExpression__Alternatives_1 )? { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:10479:2: ( rule__ReferenceExpression__Alternatives_1 )? - int alt90=2; - int LA90_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:10506:2: ( rule__ReferenceExpression__Alternatives_1 )? + int alt91=2; + int LA91_0 = input.LA(1); - if ( (LA90_0==NumberSign||LA90_0==Apostrophe||LA90_0==QuestionMark) ) { - alt90=1; + if ( (LA91_0==NumberSign||LA91_0==Apostrophe||LA91_0==QuestionMark) ) { + alt91=1; } - switch (alt90) { + switch (alt91) { case 1 : - // InternalBehaviorAnnexParser.g:10479:3: rule__ReferenceExpression__Alternatives_1 + // InternalBehaviorAnnexParser.g:10506:3: rule__ReferenceExpression__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__Alternatives_1(); @@ -35058,14 +35153,14 @@ public final void rule__ReferenceExpression__Group__1__Impl() throws Recognition // $ANTLR start "rule__ReferenceExpression__Group_1_2__0" - // InternalBehaviorAnnexParser.g:10488:1: rule__ReferenceExpression__Group_1_2__0 : rule__ReferenceExpression__Group_1_2__0__Impl rule__ReferenceExpression__Group_1_2__1 ; + // InternalBehaviorAnnexParser.g:10515:1: rule__ReferenceExpression__Group_1_2__0 : rule__ReferenceExpression__Group_1_2__0__Impl rule__ReferenceExpression__Group_1_2__1 ; public final void rule__ReferenceExpression__Group_1_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10492:1: ( rule__ReferenceExpression__Group_1_2__0__Impl rule__ReferenceExpression__Group_1_2__1 ) - // InternalBehaviorAnnexParser.g:10493:2: rule__ReferenceExpression__Group_1_2__0__Impl rule__ReferenceExpression__Group_1_2__1 + // InternalBehaviorAnnexParser.g:10519:1: ( rule__ReferenceExpression__Group_1_2__0__Impl rule__ReferenceExpression__Group_1_2__1 ) + // InternalBehaviorAnnexParser.g:10520:2: rule__ReferenceExpression__Group_1_2__0__Impl rule__ReferenceExpression__Group_1_2__1 { pushFollow(FollowSets000.FOLLOW_71); rule__ReferenceExpression__Group_1_2__0__Impl(); @@ -35096,17 +35191,17 @@ public final void rule__ReferenceExpression__Group_1_2__0() throws RecognitionEx // $ANTLR start "rule__ReferenceExpression__Group_1_2__0__Impl" - // InternalBehaviorAnnexParser.g:10500:1: rule__ReferenceExpression__Group_1_2__0__Impl : ( Apostrophe ) ; + // InternalBehaviorAnnexParser.g:10527:1: rule__ReferenceExpression__Group_1_2__0__Impl : ( Apostrophe ) ; public final void rule__ReferenceExpression__Group_1_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10504:1: ( ( Apostrophe ) ) - // InternalBehaviorAnnexParser.g:10505:1: ( Apostrophe ) + // InternalBehaviorAnnexParser.g:10531:1: ( ( Apostrophe ) ) + // InternalBehaviorAnnexParser.g:10532:1: ( Apostrophe ) { - // InternalBehaviorAnnexParser.g:10505:1: ( Apostrophe ) - // InternalBehaviorAnnexParser.g:10506:2: Apostrophe + // InternalBehaviorAnnexParser.g:10532:1: ( Apostrophe ) + // InternalBehaviorAnnexParser.g:10533:2: Apostrophe { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getApostropheKeyword_1_2_0()); @@ -35137,14 +35232,14 @@ public final void rule__ReferenceExpression__Group_1_2__0__Impl() throws Recogni // $ANTLR start "rule__ReferenceExpression__Group_1_2__1" - // InternalBehaviorAnnexParser.g:10515:1: rule__ReferenceExpression__Group_1_2__1 : rule__ReferenceExpression__Group_1_2__1__Impl ; + // InternalBehaviorAnnexParser.g:10542:1: rule__ReferenceExpression__Group_1_2__1 : rule__ReferenceExpression__Group_1_2__1__Impl ; public final void rule__ReferenceExpression__Group_1_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10519:1: ( rule__ReferenceExpression__Group_1_2__1__Impl ) - // InternalBehaviorAnnexParser.g:10520:2: rule__ReferenceExpression__Group_1_2__1__Impl + // InternalBehaviorAnnexParser.g:10546:1: ( rule__ReferenceExpression__Group_1_2__1__Impl ) + // InternalBehaviorAnnexParser.g:10547:2: rule__ReferenceExpression__Group_1_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__Group_1_2__1__Impl(); @@ -35170,23 +35265,23 @@ public final void rule__ReferenceExpression__Group_1_2__1() throws RecognitionEx // $ANTLR start "rule__ReferenceExpression__Group_1_2__1__Impl" - // InternalBehaviorAnnexParser.g:10526:1: rule__ReferenceExpression__Group_1_2__1__Impl : ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) ; + // InternalBehaviorAnnexParser.g:10553:1: rule__ReferenceExpression__Group_1_2__1__Impl : ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) ; public final void rule__ReferenceExpression__Group_1_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10530:1: ( ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) ) - // InternalBehaviorAnnexParser.g:10531:1: ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) + // InternalBehaviorAnnexParser.g:10557:1: ( ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) ) + // InternalBehaviorAnnexParser.g:10558:1: ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) { - // InternalBehaviorAnnexParser.g:10531:1: ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) - // InternalBehaviorAnnexParser.g:10532:2: ( rule__ReferenceExpression__Alternatives_1_2_1 ) + // InternalBehaviorAnnexParser.g:10558:1: ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) + // InternalBehaviorAnnexParser.g:10559:2: ( rule__ReferenceExpression__Alternatives_1_2_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getAlternatives_1_2_1()); } - // InternalBehaviorAnnexParser.g:10533:2: ( rule__ReferenceExpression__Alternatives_1_2_1 ) - // InternalBehaviorAnnexParser.g:10533:3: rule__ReferenceExpression__Alternatives_1_2_1 + // InternalBehaviorAnnexParser.g:10560:2: ( rule__ReferenceExpression__Alternatives_1_2_1 ) + // InternalBehaviorAnnexParser.g:10560:3: rule__ReferenceExpression__Alternatives_1_2_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__Alternatives_1_2_1(); @@ -35221,14 +35316,14 @@ public final void rule__ReferenceExpression__Group_1_2__1__Impl() throws Recogni // $ANTLR start "rule__HashPropertyReference__Group__0" - // InternalBehaviorAnnexParser.g:10542:1: rule__HashPropertyReference__Group__0 : rule__HashPropertyReference__Group__0__Impl rule__HashPropertyReference__Group__1 ; + // InternalBehaviorAnnexParser.g:10569:1: rule__HashPropertyReference__Group__0 : rule__HashPropertyReference__Group__0__Impl rule__HashPropertyReference__Group__1 ; public final void rule__HashPropertyReference__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10546:1: ( rule__HashPropertyReference__Group__0__Impl rule__HashPropertyReference__Group__1 ) - // InternalBehaviorAnnexParser.g:10547:2: rule__HashPropertyReference__Group__0__Impl rule__HashPropertyReference__Group__1 + // InternalBehaviorAnnexParser.g:10573:1: ( rule__HashPropertyReference__Group__0__Impl rule__HashPropertyReference__Group__1 ) + // InternalBehaviorAnnexParser.g:10574:2: rule__HashPropertyReference__Group__0__Impl rule__HashPropertyReference__Group__1 { pushFollow(FollowSets000.FOLLOW_4); rule__HashPropertyReference__Group__0__Impl(); @@ -35259,17 +35354,17 @@ public final void rule__HashPropertyReference__Group__0() throws RecognitionExce // $ANTLR start "rule__HashPropertyReference__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10554:1: rule__HashPropertyReference__Group__0__Impl : ( NumberSign ) ; + // InternalBehaviorAnnexParser.g:10581:1: rule__HashPropertyReference__Group__0__Impl : ( NumberSign ) ; public final void rule__HashPropertyReference__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10558:1: ( ( NumberSign ) ) - // InternalBehaviorAnnexParser.g:10559:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10585:1: ( ( NumberSign ) ) + // InternalBehaviorAnnexParser.g:10586:1: ( NumberSign ) { - // InternalBehaviorAnnexParser.g:10559:1: ( NumberSign ) - // InternalBehaviorAnnexParser.g:10560:2: NumberSign + // InternalBehaviorAnnexParser.g:10586:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10587:2: NumberSign { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getNumberSignKeyword_0()); @@ -35300,14 +35395,14 @@ public final void rule__HashPropertyReference__Group__0__Impl() throws Recogniti // $ANTLR start "rule__HashPropertyReference__Group__1" - // InternalBehaviorAnnexParser.g:10569:1: rule__HashPropertyReference__Group__1 : rule__HashPropertyReference__Group__1__Impl rule__HashPropertyReference__Group__2 ; + // InternalBehaviorAnnexParser.g:10596:1: rule__HashPropertyReference__Group__1 : rule__HashPropertyReference__Group__1__Impl rule__HashPropertyReference__Group__2 ; public final void rule__HashPropertyReference__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10573:1: ( rule__HashPropertyReference__Group__1__Impl rule__HashPropertyReference__Group__2 ) - // InternalBehaviorAnnexParser.g:10574:2: rule__HashPropertyReference__Group__1__Impl rule__HashPropertyReference__Group__2 + // InternalBehaviorAnnexParser.g:10600:1: ( rule__HashPropertyReference__Group__1__Impl rule__HashPropertyReference__Group__2 ) + // InternalBehaviorAnnexParser.g:10601:2: rule__HashPropertyReference__Group__1__Impl rule__HashPropertyReference__Group__2 { pushFollow(FollowSets000.FOLLOW_72); rule__HashPropertyReference__Group__1__Impl(); @@ -35338,23 +35433,23 @@ public final void rule__HashPropertyReference__Group__1() throws RecognitionExce // $ANTLR start "rule__HashPropertyReference__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10581:1: rule__HashPropertyReference__Group__1__Impl : ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10608:1: rule__HashPropertyReference__Group__1__Impl : ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) ; public final void rule__HashPropertyReference__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10585:1: ( ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10586:1: ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10612:1: ( ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10613:1: ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10586:1: ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10587:2: ( rule__HashPropertyReference__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10613:1: ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10614:2: ( rule__HashPropertyReference__PropertyAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getPropertyAssignment_1()); } - // InternalBehaviorAnnexParser.g:10588:2: ( rule__HashPropertyReference__PropertyAssignment_1 ) - // InternalBehaviorAnnexParser.g:10588:3: rule__HashPropertyReference__PropertyAssignment_1 + // InternalBehaviorAnnexParser.g:10615:2: ( rule__HashPropertyReference__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10615:3: rule__HashPropertyReference__PropertyAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__HashPropertyReference__PropertyAssignment_1(); @@ -35389,14 +35484,14 @@ public final void rule__HashPropertyReference__Group__1__Impl() throws Recogniti // $ANTLR start "rule__HashPropertyReference__Group__2" - // InternalBehaviorAnnexParser.g:10596:1: rule__HashPropertyReference__Group__2 : rule__HashPropertyReference__Group__2__Impl rule__HashPropertyReference__Group__3 ; + // InternalBehaviorAnnexParser.g:10623:1: rule__HashPropertyReference__Group__2 : rule__HashPropertyReference__Group__2__Impl rule__HashPropertyReference__Group__3 ; public final void rule__HashPropertyReference__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10600:1: ( rule__HashPropertyReference__Group__2__Impl rule__HashPropertyReference__Group__3 ) - // InternalBehaviorAnnexParser.g:10601:2: rule__HashPropertyReference__Group__2__Impl rule__HashPropertyReference__Group__3 + // InternalBehaviorAnnexParser.g:10627:1: ( rule__HashPropertyReference__Group__2__Impl rule__HashPropertyReference__Group__3 ) + // InternalBehaviorAnnexParser.g:10628:2: rule__HashPropertyReference__Group__2__Impl rule__HashPropertyReference__Group__3 { pushFollow(FollowSets000.FOLLOW_72); rule__HashPropertyReference__Group__2__Impl(); @@ -35427,35 +35522,35 @@ public final void rule__HashPropertyReference__Group__2() throws RecognitionExce // $ANTLR start "rule__HashPropertyReference__Group__2__Impl" - // InternalBehaviorAnnexParser.g:10608:1: rule__HashPropertyReference__Group__2__Impl : ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) ; + // InternalBehaviorAnnexParser.g:10635:1: rule__HashPropertyReference__Group__2__Impl : ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) ; public final void rule__HashPropertyReference__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10612:1: ( ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) ) - // InternalBehaviorAnnexParser.g:10613:1: ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10639:1: ( ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) ) + // InternalBehaviorAnnexParser.g:10640:1: ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) { - // InternalBehaviorAnnexParser.g:10613:1: ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) - // InternalBehaviorAnnexParser.g:10614:2: ( rule__HashPropertyReference__IndexesAssignment_2 )* + // InternalBehaviorAnnexParser.g:10640:1: ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10641:2: ( rule__HashPropertyReference__IndexesAssignment_2 )* { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getIndexesAssignment_2()); } - // InternalBehaviorAnnexParser.g:10615:2: ( rule__HashPropertyReference__IndexesAssignment_2 )* - loop91: + // InternalBehaviorAnnexParser.g:10642:2: ( rule__HashPropertyReference__IndexesAssignment_2 )* + loop92: do { - int alt91=2; - int LA91_0 = input.LA(1); + int alt92=2; + int LA92_0 = input.LA(1); - if ( (LA91_0==LeftSquareBracket) ) { - alt91=1; + if ( (LA92_0==LeftSquareBracket) ) { + alt92=1; } - switch (alt91) { + switch (alt92) { case 1 : - // InternalBehaviorAnnexParser.g:10615:3: rule__HashPropertyReference__IndexesAssignment_2 + // InternalBehaviorAnnexParser.g:10642:3: rule__HashPropertyReference__IndexesAssignment_2 { pushFollow(FollowSets000.FOLLOW_12); rule__HashPropertyReference__IndexesAssignment_2(); @@ -35467,7 +35562,7 @@ public final void rule__HashPropertyReference__Group__2__Impl() throws Recogniti break; default : - break loop91; + break loop92; } } while (true); @@ -35496,14 +35591,14 @@ public final void rule__HashPropertyReference__Group__2__Impl() throws Recogniti // $ANTLR start "rule__HashPropertyReference__Group__3" - // InternalBehaviorAnnexParser.g:10623:1: rule__HashPropertyReference__Group__3 : rule__HashPropertyReference__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:10650:1: rule__HashPropertyReference__Group__3 : rule__HashPropertyReference__Group__3__Impl ; public final void rule__HashPropertyReference__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10627:1: ( rule__HashPropertyReference__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:10628:2: rule__HashPropertyReference__Group__3__Impl + // InternalBehaviorAnnexParser.g:10654:1: ( rule__HashPropertyReference__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:10655:2: rule__HashPropertyReference__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__HashPropertyReference__Group__3__Impl(); @@ -35529,35 +35624,35 @@ public final void rule__HashPropertyReference__Group__3() throws RecognitionExce // $ANTLR start "rule__HashPropertyReference__Group__3__Impl" - // InternalBehaviorAnnexParser.g:10634:1: rule__HashPropertyReference__Group__3__Impl : ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) ; + // InternalBehaviorAnnexParser.g:10661:1: rule__HashPropertyReference__Group__3__Impl : ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) ; public final void rule__HashPropertyReference__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10638:1: ( ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) ) - // InternalBehaviorAnnexParser.g:10639:1: ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) + // InternalBehaviorAnnexParser.g:10665:1: ( ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) ) + // InternalBehaviorAnnexParser.g:10666:1: ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) { - // InternalBehaviorAnnexParser.g:10639:1: ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) - // InternalBehaviorAnnexParser.g:10640:2: ( rule__HashPropertyReference__FieldsAssignment_3 )* + // InternalBehaviorAnnexParser.g:10666:1: ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) + // InternalBehaviorAnnexParser.g:10667:2: ( rule__HashPropertyReference__FieldsAssignment_3 )* { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getFieldsAssignment_3()); } - // InternalBehaviorAnnexParser.g:10641:2: ( rule__HashPropertyReference__FieldsAssignment_3 )* - loop92: + // InternalBehaviorAnnexParser.g:10668:2: ( rule__HashPropertyReference__FieldsAssignment_3 )* + loop93: do { - int alt92=2; - int LA92_0 = input.LA(1); + int alt93=2; + int LA93_0 = input.LA(1); - if ( (LA92_0==FullStop) ) { - alt92=1; + if ( (LA93_0==FullStop) ) { + alt93=1; } - switch (alt92) { + switch (alt93) { case 1 : - // InternalBehaviorAnnexParser.g:10641:3: rule__HashPropertyReference__FieldsAssignment_3 + // InternalBehaviorAnnexParser.g:10668:3: rule__HashPropertyReference__FieldsAssignment_3 { pushFollow(FollowSets000.FOLLOW_73); rule__HashPropertyReference__FieldsAssignment_3(); @@ -35569,7 +35664,7 @@ public final void rule__HashPropertyReference__Group__3__Impl() throws Recogniti break; default : - break loop92; + break loop93; } } while (true); @@ -35598,14 +35693,14 @@ public final void rule__HashPropertyReference__Group__3__Impl() throws Recogniti // $ANTLR start "rule__PropertyReferenceTail__Group__0" - // InternalBehaviorAnnexParser.g:10650:1: rule__PropertyReferenceTail__Group__0 : rule__PropertyReferenceTail__Group__0__Impl rule__PropertyReferenceTail__Group__1 ; + // InternalBehaviorAnnexParser.g:10677:1: rule__PropertyReferenceTail__Group__0 : rule__PropertyReferenceTail__Group__0__Impl rule__PropertyReferenceTail__Group__1 ; public final void rule__PropertyReferenceTail__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10654:1: ( rule__PropertyReferenceTail__Group__0__Impl rule__PropertyReferenceTail__Group__1 ) - // InternalBehaviorAnnexParser.g:10655:2: rule__PropertyReferenceTail__Group__0__Impl rule__PropertyReferenceTail__Group__1 + // InternalBehaviorAnnexParser.g:10681:1: ( rule__PropertyReferenceTail__Group__0__Impl rule__PropertyReferenceTail__Group__1 ) + // InternalBehaviorAnnexParser.g:10682:2: rule__PropertyReferenceTail__Group__0__Impl rule__PropertyReferenceTail__Group__1 { pushFollow(FollowSets000.FOLLOW_4); rule__PropertyReferenceTail__Group__0__Impl(); @@ -35636,17 +35731,17 @@ public final void rule__PropertyReferenceTail__Group__0() throws RecognitionExce // $ANTLR start "rule__PropertyReferenceTail__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10662:1: rule__PropertyReferenceTail__Group__0__Impl : ( NumberSign ) ; + // InternalBehaviorAnnexParser.g:10689:1: rule__PropertyReferenceTail__Group__0__Impl : ( NumberSign ) ; public final void rule__PropertyReferenceTail__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10666:1: ( ( NumberSign ) ) - // InternalBehaviorAnnexParser.g:10667:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10693:1: ( ( NumberSign ) ) + // InternalBehaviorAnnexParser.g:10694:1: ( NumberSign ) { - // InternalBehaviorAnnexParser.g:10667:1: ( NumberSign ) - // InternalBehaviorAnnexParser.g:10668:2: NumberSign + // InternalBehaviorAnnexParser.g:10694:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10695:2: NumberSign { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getNumberSignKeyword_0()); @@ -35677,14 +35772,14 @@ public final void rule__PropertyReferenceTail__Group__0__Impl() throws Recogniti // $ANTLR start "rule__PropertyReferenceTail__Group__1" - // InternalBehaviorAnnexParser.g:10677:1: rule__PropertyReferenceTail__Group__1 : rule__PropertyReferenceTail__Group__1__Impl rule__PropertyReferenceTail__Group__2 ; + // InternalBehaviorAnnexParser.g:10704:1: rule__PropertyReferenceTail__Group__1 : rule__PropertyReferenceTail__Group__1__Impl rule__PropertyReferenceTail__Group__2 ; public final void rule__PropertyReferenceTail__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10681:1: ( rule__PropertyReferenceTail__Group__1__Impl rule__PropertyReferenceTail__Group__2 ) - // InternalBehaviorAnnexParser.g:10682:2: rule__PropertyReferenceTail__Group__1__Impl rule__PropertyReferenceTail__Group__2 + // InternalBehaviorAnnexParser.g:10708:1: ( rule__PropertyReferenceTail__Group__1__Impl rule__PropertyReferenceTail__Group__2 ) + // InternalBehaviorAnnexParser.g:10709:2: rule__PropertyReferenceTail__Group__1__Impl rule__PropertyReferenceTail__Group__2 { pushFollow(FollowSets000.FOLLOW_72); rule__PropertyReferenceTail__Group__1__Impl(); @@ -35715,23 +35810,23 @@ public final void rule__PropertyReferenceTail__Group__1() throws RecognitionExce // $ANTLR start "rule__PropertyReferenceTail__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10689:1: rule__PropertyReferenceTail__Group__1__Impl : ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10716:1: rule__PropertyReferenceTail__Group__1__Impl : ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) ; public final void rule__PropertyReferenceTail__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10693:1: ( ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10694:1: ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10720:1: ( ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10721:1: ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10694:1: ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10695:2: ( rule__PropertyReferenceTail__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10721:1: ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10722:2: ( rule__PropertyReferenceTail__PropertyAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getPropertyAssignment_1()); } - // InternalBehaviorAnnexParser.g:10696:2: ( rule__PropertyReferenceTail__PropertyAssignment_1 ) - // InternalBehaviorAnnexParser.g:10696:3: rule__PropertyReferenceTail__PropertyAssignment_1 + // InternalBehaviorAnnexParser.g:10723:2: ( rule__PropertyReferenceTail__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10723:3: rule__PropertyReferenceTail__PropertyAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyReferenceTail__PropertyAssignment_1(); @@ -35766,14 +35861,14 @@ public final void rule__PropertyReferenceTail__Group__1__Impl() throws Recogniti // $ANTLR start "rule__PropertyReferenceTail__Group__2" - // InternalBehaviorAnnexParser.g:10704:1: rule__PropertyReferenceTail__Group__2 : rule__PropertyReferenceTail__Group__2__Impl rule__PropertyReferenceTail__Group__3 ; + // InternalBehaviorAnnexParser.g:10731:1: rule__PropertyReferenceTail__Group__2 : rule__PropertyReferenceTail__Group__2__Impl rule__PropertyReferenceTail__Group__3 ; public final void rule__PropertyReferenceTail__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10708:1: ( rule__PropertyReferenceTail__Group__2__Impl rule__PropertyReferenceTail__Group__3 ) - // InternalBehaviorAnnexParser.g:10709:2: rule__PropertyReferenceTail__Group__2__Impl rule__PropertyReferenceTail__Group__3 + // InternalBehaviorAnnexParser.g:10735:1: ( rule__PropertyReferenceTail__Group__2__Impl rule__PropertyReferenceTail__Group__3 ) + // InternalBehaviorAnnexParser.g:10736:2: rule__PropertyReferenceTail__Group__2__Impl rule__PropertyReferenceTail__Group__3 { pushFollow(FollowSets000.FOLLOW_72); rule__PropertyReferenceTail__Group__2__Impl(); @@ -35804,35 +35899,35 @@ public final void rule__PropertyReferenceTail__Group__2() throws RecognitionExce // $ANTLR start "rule__PropertyReferenceTail__Group__2__Impl" - // InternalBehaviorAnnexParser.g:10716:1: rule__PropertyReferenceTail__Group__2__Impl : ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) ; + // InternalBehaviorAnnexParser.g:10743:1: rule__PropertyReferenceTail__Group__2__Impl : ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) ; public final void rule__PropertyReferenceTail__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10720:1: ( ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) ) - // InternalBehaviorAnnexParser.g:10721:1: ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10747:1: ( ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) ) + // InternalBehaviorAnnexParser.g:10748:1: ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) { - // InternalBehaviorAnnexParser.g:10721:1: ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) - // InternalBehaviorAnnexParser.g:10722:2: ( rule__PropertyReferenceTail__IndexesAssignment_2 )* + // InternalBehaviorAnnexParser.g:10748:1: ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10749:2: ( rule__PropertyReferenceTail__IndexesAssignment_2 )* { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getIndexesAssignment_2()); } - // InternalBehaviorAnnexParser.g:10723:2: ( rule__PropertyReferenceTail__IndexesAssignment_2 )* - loop93: + // InternalBehaviorAnnexParser.g:10750:2: ( rule__PropertyReferenceTail__IndexesAssignment_2 )* + loop94: do { - int alt93=2; - int LA93_0 = input.LA(1); + int alt94=2; + int LA94_0 = input.LA(1); - if ( (LA93_0==LeftSquareBracket) ) { - alt93=1; + if ( (LA94_0==LeftSquareBracket) ) { + alt94=1; } - switch (alt93) { + switch (alt94) { case 1 : - // InternalBehaviorAnnexParser.g:10723:3: rule__PropertyReferenceTail__IndexesAssignment_2 + // InternalBehaviorAnnexParser.g:10750:3: rule__PropertyReferenceTail__IndexesAssignment_2 { pushFollow(FollowSets000.FOLLOW_12); rule__PropertyReferenceTail__IndexesAssignment_2(); @@ -35844,7 +35939,7 @@ public final void rule__PropertyReferenceTail__Group__2__Impl() throws Recogniti break; default : - break loop93; + break loop94; } } while (true); @@ -35873,14 +35968,14 @@ public final void rule__PropertyReferenceTail__Group__2__Impl() throws Recogniti // $ANTLR start "rule__PropertyReferenceTail__Group__3" - // InternalBehaviorAnnexParser.g:10731:1: rule__PropertyReferenceTail__Group__3 : rule__PropertyReferenceTail__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:10758:1: rule__PropertyReferenceTail__Group__3 : rule__PropertyReferenceTail__Group__3__Impl ; public final void rule__PropertyReferenceTail__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10735:1: ( rule__PropertyReferenceTail__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:10736:2: rule__PropertyReferenceTail__Group__3__Impl + // InternalBehaviorAnnexParser.g:10762:1: ( rule__PropertyReferenceTail__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:10763:2: rule__PropertyReferenceTail__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyReferenceTail__Group__3__Impl(); @@ -35906,35 +36001,35 @@ public final void rule__PropertyReferenceTail__Group__3() throws RecognitionExce // $ANTLR start "rule__PropertyReferenceTail__Group__3__Impl" - // InternalBehaviorAnnexParser.g:10742:1: rule__PropertyReferenceTail__Group__3__Impl : ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) ; + // InternalBehaviorAnnexParser.g:10769:1: rule__PropertyReferenceTail__Group__3__Impl : ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) ; public final void rule__PropertyReferenceTail__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10746:1: ( ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) ) - // InternalBehaviorAnnexParser.g:10747:1: ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) + // InternalBehaviorAnnexParser.g:10773:1: ( ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) ) + // InternalBehaviorAnnexParser.g:10774:1: ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) { - // InternalBehaviorAnnexParser.g:10747:1: ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) - // InternalBehaviorAnnexParser.g:10748:2: ( rule__PropertyReferenceTail__FieldsAssignment_3 )* + // InternalBehaviorAnnexParser.g:10774:1: ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) + // InternalBehaviorAnnexParser.g:10775:2: ( rule__PropertyReferenceTail__FieldsAssignment_3 )* { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getFieldsAssignment_3()); } - // InternalBehaviorAnnexParser.g:10749:2: ( rule__PropertyReferenceTail__FieldsAssignment_3 )* - loop94: + // InternalBehaviorAnnexParser.g:10776:2: ( rule__PropertyReferenceTail__FieldsAssignment_3 )* + loop95: do { - int alt94=2; - int LA94_0 = input.LA(1); + int alt95=2; + int LA95_0 = input.LA(1); - if ( (LA94_0==FullStop) ) { - alt94=1; + if ( (LA95_0==FullStop) ) { + alt95=1; } - switch (alt94) { + switch (alt95) { case 1 : - // InternalBehaviorAnnexParser.g:10749:3: rule__PropertyReferenceTail__FieldsAssignment_3 + // InternalBehaviorAnnexParser.g:10776:3: rule__PropertyReferenceTail__FieldsAssignment_3 { pushFollow(FollowSets000.FOLLOW_73); rule__PropertyReferenceTail__FieldsAssignment_3(); @@ -35946,7 +36041,7 @@ public final void rule__PropertyReferenceTail__Group__3__Impl() throws Recogniti break; default : - break loop94; + break loop95; } } while (true); @@ -35975,14 +36070,14 @@ public final void rule__PropertyReferenceTail__Group__3__Impl() throws Recogniti // $ANTLR start "rule__NamedPropertyField__Group__0" - // InternalBehaviorAnnexParser.g:10758:1: rule__NamedPropertyField__Group__0 : rule__NamedPropertyField__Group__0__Impl rule__NamedPropertyField__Group__1 ; + // InternalBehaviorAnnexParser.g:10785:1: rule__NamedPropertyField__Group__0 : rule__NamedPropertyField__Group__0__Impl rule__NamedPropertyField__Group__1 ; public final void rule__NamedPropertyField__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10762:1: ( rule__NamedPropertyField__Group__0__Impl rule__NamedPropertyField__Group__1 ) - // InternalBehaviorAnnexParser.g:10763:2: rule__NamedPropertyField__Group__0__Impl rule__NamedPropertyField__Group__1 + // InternalBehaviorAnnexParser.g:10789:1: ( rule__NamedPropertyField__Group__0__Impl rule__NamedPropertyField__Group__1 ) + // InternalBehaviorAnnexParser.g:10790:2: rule__NamedPropertyField__Group__0__Impl rule__NamedPropertyField__Group__1 { pushFollow(FollowSets000.FOLLOW_4); rule__NamedPropertyField__Group__0__Impl(); @@ -36013,17 +36108,17 @@ public final void rule__NamedPropertyField__Group__0() throws RecognitionExcepti // $ANTLR start "rule__NamedPropertyField__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10770:1: rule__NamedPropertyField__Group__0__Impl : ( FullStop ) ; + // InternalBehaviorAnnexParser.g:10797:1: rule__NamedPropertyField__Group__0__Impl : ( FullStop ) ; public final void rule__NamedPropertyField__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10774:1: ( ( FullStop ) ) - // InternalBehaviorAnnexParser.g:10775:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:10801:1: ( ( FullStop ) ) + // InternalBehaviorAnnexParser.g:10802:1: ( FullStop ) { - // InternalBehaviorAnnexParser.g:10775:1: ( FullStop ) - // InternalBehaviorAnnexParser.g:10776:2: FullStop + // InternalBehaviorAnnexParser.g:10802:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:10803:2: FullStop { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getFullStopKeyword_0()); @@ -36054,14 +36149,14 @@ public final void rule__NamedPropertyField__Group__0__Impl() throws RecognitionE // $ANTLR start "rule__NamedPropertyField__Group__1" - // InternalBehaviorAnnexParser.g:10785:1: rule__NamedPropertyField__Group__1 : rule__NamedPropertyField__Group__1__Impl rule__NamedPropertyField__Group__2 ; + // InternalBehaviorAnnexParser.g:10812:1: rule__NamedPropertyField__Group__1 : rule__NamedPropertyField__Group__1__Impl rule__NamedPropertyField__Group__2 ; public final void rule__NamedPropertyField__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10789:1: ( rule__NamedPropertyField__Group__1__Impl rule__NamedPropertyField__Group__2 ) - // InternalBehaviorAnnexParser.g:10790:2: rule__NamedPropertyField__Group__1__Impl rule__NamedPropertyField__Group__2 + // InternalBehaviorAnnexParser.g:10816:1: ( rule__NamedPropertyField__Group__1__Impl rule__NamedPropertyField__Group__2 ) + // InternalBehaviorAnnexParser.g:10817:2: rule__NamedPropertyField__Group__1__Impl rule__NamedPropertyField__Group__2 { pushFollow(FollowSets000.FOLLOW_11); rule__NamedPropertyField__Group__1__Impl(); @@ -36092,23 +36187,23 @@ public final void rule__NamedPropertyField__Group__1() throws RecognitionExcepti // $ANTLR start "rule__NamedPropertyField__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10797:1: rule__NamedPropertyField__Group__1__Impl : ( ( rule__NamedPropertyField__NameAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10824:1: rule__NamedPropertyField__Group__1__Impl : ( ( rule__NamedPropertyField__NameAssignment_1 ) ) ; public final void rule__NamedPropertyField__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10801:1: ( ( ( rule__NamedPropertyField__NameAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10802:1: ( ( rule__NamedPropertyField__NameAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10828:1: ( ( ( rule__NamedPropertyField__NameAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10829:1: ( ( rule__NamedPropertyField__NameAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10802:1: ( ( rule__NamedPropertyField__NameAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10803:2: ( rule__NamedPropertyField__NameAssignment_1 ) + // InternalBehaviorAnnexParser.g:10829:1: ( ( rule__NamedPropertyField__NameAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10830:2: ( rule__NamedPropertyField__NameAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getNameAssignment_1()); } - // InternalBehaviorAnnexParser.g:10804:2: ( rule__NamedPropertyField__NameAssignment_1 ) - // InternalBehaviorAnnexParser.g:10804:3: rule__NamedPropertyField__NameAssignment_1 + // InternalBehaviorAnnexParser.g:10831:2: ( rule__NamedPropertyField__NameAssignment_1 ) + // InternalBehaviorAnnexParser.g:10831:3: rule__NamedPropertyField__NameAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__NamedPropertyField__NameAssignment_1(); @@ -36143,14 +36238,14 @@ public final void rule__NamedPropertyField__Group__1__Impl() throws RecognitionE // $ANTLR start "rule__NamedPropertyField__Group__2" - // InternalBehaviorAnnexParser.g:10812:1: rule__NamedPropertyField__Group__2 : rule__NamedPropertyField__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:10839:1: rule__NamedPropertyField__Group__2 : rule__NamedPropertyField__Group__2__Impl ; public final void rule__NamedPropertyField__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10816:1: ( rule__NamedPropertyField__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:10817:2: rule__NamedPropertyField__Group__2__Impl + // InternalBehaviorAnnexParser.g:10843:1: ( rule__NamedPropertyField__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:10844:2: rule__NamedPropertyField__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__NamedPropertyField__Group__2__Impl(); @@ -36176,35 +36271,35 @@ public final void rule__NamedPropertyField__Group__2() throws RecognitionExcepti // $ANTLR start "rule__NamedPropertyField__Group__2__Impl" - // InternalBehaviorAnnexParser.g:10823:1: rule__NamedPropertyField__Group__2__Impl : ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) ; + // InternalBehaviorAnnexParser.g:10850:1: rule__NamedPropertyField__Group__2__Impl : ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) ; public final void rule__NamedPropertyField__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10827:1: ( ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) ) - // InternalBehaviorAnnexParser.g:10828:1: ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10854:1: ( ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) ) + // InternalBehaviorAnnexParser.g:10855:1: ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) { - // InternalBehaviorAnnexParser.g:10828:1: ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) - // InternalBehaviorAnnexParser.g:10829:2: ( rule__NamedPropertyField__IndexesAssignment_2 )* + // InternalBehaviorAnnexParser.g:10855:1: ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10856:2: ( rule__NamedPropertyField__IndexesAssignment_2 )* { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getIndexesAssignment_2()); } - // InternalBehaviorAnnexParser.g:10830:2: ( rule__NamedPropertyField__IndexesAssignment_2 )* - loop95: + // InternalBehaviorAnnexParser.g:10857:2: ( rule__NamedPropertyField__IndexesAssignment_2 )* + loop96: do { - int alt95=2; - int LA95_0 = input.LA(1); + int alt96=2; + int LA96_0 = input.LA(1); - if ( (LA95_0==LeftSquareBracket) ) { - alt95=1; + if ( (LA96_0==LeftSquareBracket) ) { + alt96=1; } - switch (alt95) { + switch (alt96) { case 1 : - // InternalBehaviorAnnexParser.g:10830:3: rule__NamedPropertyField__IndexesAssignment_2 + // InternalBehaviorAnnexParser.g:10857:3: rule__NamedPropertyField__IndexesAssignment_2 { pushFollow(FollowSets000.FOLLOW_12); rule__NamedPropertyField__IndexesAssignment_2(); @@ -36216,7 +36311,7 @@ public final void rule__NamedPropertyField__Group__2__Impl() throws RecognitionE break; default : - break loop95; + break loop96; } } while (true); @@ -36245,14 +36340,14 @@ public final void rule__NamedPropertyField__Group__2__Impl() throws RecognitionE // $ANTLR start "rule__PropertyArrayIndex__Group__0" - // InternalBehaviorAnnexParser.g:10839:1: rule__PropertyArrayIndex__Group__0 : rule__PropertyArrayIndex__Group__0__Impl rule__PropertyArrayIndex__Group__1 ; + // InternalBehaviorAnnexParser.g:10866:1: rule__PropertyArrayIndex__Group__0 : rule__PropertyArrayIndex__Group__0__Impl rule__PropertyArrayIndex__Group__1 ; public final void rule__PropertyArrayIndex__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10843:1: ( rule__PropertyArrayIndex__Group__0__Impl rule__PropertyArrayIndex__Group__1 ) - // InternalBehaviorAnnexParser.g:10844:2: rule__PropertyArrayIndex__Group__0__Impl rule__PropertyArrayIndex__Group__1 + // InternalBehaviorAnnexParser.g:10870:1: ( rule__PropertyArrayIndex__Group__0__Impl rule__PropertyArrayIndex__Group__1 ) + // InternalBehaviorAnnexParser.g:10871:2: rule__PropertyArrayIndex__Group__0__Impl rule__PropertyArrayIndex__Group__1 { pushFollow(FollowSets000.FOLLOW_74); rule__PropertyArrayIndex__Group__0__Impl(); @@ -36283,17 +36378,17 @@ public final void rule__PropertyArrayIndex__Group__0() throws RecognitionExcepti // $ANTLR start "rule__PropertyArrayIndex__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10851:1: rule__PropertyArrayIndex__Group__0__Impl : ( LeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:10878:1: rule__PropertyArrayIndex__Group__0__Impl : ( LeftSquareBracket ) ; public final void rule__PropertyArrayIndex__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10855:1: ( ( LeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:10856:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:10882:1: ( ( LeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:10883:1: ( LeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:10856:1: ( LeftSquareBracket ) - // InternalBehaviorAnnexParser.g:10857:2: LeftSquareBracket + // InternalBehaviorAnnexParser.g:10883:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:10884:2: LeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyArrayIndexAccess().getLeftSquareBracketKeyword_0()); @@ -36324,14 +36419,14 @@ public final void rule__PropertyArrayIndex__Group__0__Impl() throws RecognitionE // $ANTLR start "rule__PropertyArrayIndex__Group__1" - // InternalBehaviorAnnexParser.g:10866:1: rule__PropertyArrayIndex__Group__1 : rule__PropertyArrayIndex__Group__1__Impl rule__PropertyArrayIndex__Group__2 ; + // InternalBehaviorAnnexParser.g:10893:1: rule__PropertyArrayIndex__Group__1 : rule__PropertyArrayIndex__Group__1__Impl rule__PropertyArrayIndex__Group__2 ; public final void rule__PropertyArrayIndex__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10870:1: ( rule__PropertyArrayIndex__Group__1__Impl rule__PropertyArrayIndex__Group__2 ) - // InternalBehaviorAnnexParser.g:10871:2: rule__PropertyArrayIndex__Group__1__Impl rule__PropertyArrayIndex__Group__2 + // InternalBehaviorAnnexParser.g:10897:1: ( rule__PropertyArrayIndex__Group__1__Impl rule__PropertyArrayIndex__Group__2 ) + // InternalBehaviorAnnexParser.g:10898:2: rule__PropertyArrayIndex__Group__1__Impl rule__PropertyArrayIndex__Group__2 { pushFollow(FollowSets000.FOLLOW_14); rule__PropertyArrayIndex__Group__1__Impl(); @@ -36362,23 +36457,23 @@ public final void rule__PropertyArrayIndex__Group__1() throws RecognitionExcepti // $ANTLR start "rule__PropertyArrayIndex__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10878:1: rule__PropertyArrayIndex__Group__1__Impl : ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10905:1: rule__PropertyArrayIndex__Group__1__Impl : ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) ; public final void rule__PropertyArrayIndex__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10882:1: ( ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10883:1: ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10909:1: ( ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10910:1: ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10883:1: ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10884:2: ( rule__PropertyArrayIndex__ValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:10910:1: ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10911:2: ( rule__PropertyArrayIndex__ValueAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyArrayIndexAccess().getValueAssignment_1()); } - // InternalBehaviorAnnexParser.g:10885:2: ( rule__PropertyArrayIndex__ValueAssignment_1 ) - // InternalBehaviorAnnexParser.g:10885:3: rule__PropertyArrayIndex__ValueAssignment_1 + // InternalBehaviorAnnexParser.g:10912:2: ( rule__PropertyArrayIndex__ValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:10912:3: rule__PropertyArrayIndex__ValueAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyArrayIndex__ValueAssignment_1(); @@ -36413,14 +36508,14 @@ public final void rule__PropertyArrayIndex__Group__1__Impl() throws RecognitionE // $ANTLR start "rule__PropertyArrayIndex__Group__2" - // InternalBehaviorAnnexParser.g:10893:1: rule__PropertyArrayIndex__Group__2 : rule__PropertyArrayIndex__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:10920:1: rule__PropertyArrayIndex__Group__2 : rule__PropertyArrayIndex__Group__2__Impl ; public final void rule__PropertyArrayIndex__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10897:1: ( rule__PropertyArrayIndex__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:10898:2: rule__PropertyArrayIndex__Group__2__Impl + // InternalBehaviorAnnexParser.g:10924:1: ( rule__PropertyArrayIndex__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:10925:2: rule__PropertyArrayIndex__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyArrayIndex__Group__2__Impl(); @@ -36446,17 +36541,17 @@ public final void rule__PropertyArrayIndex__Group__2() throws RecognitionExcepti // $ANTLR start "rule__PropertyArrayIndex__Group__2__Impl" - // InternalBehaviorAnnexParser.g:10904:1: rule__PropertyArrayIndex__Group__2__Impl : ( RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:10931:1: rule__PropertyArrayIndex__Group__2__Impl : ( RightSquareBracket ) ; public final void rule__PropertyArrayIndex__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10908:1: ( ( RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:10909:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:10935:1: ( ( RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:10936:1: ( RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:10909:1: ( RightSquareBracket ) - // InternalBehaviorAnnexParser.g:10910:2: RightSquareBracket + // InternalBehaviorAnnexParser.g:10936:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:10937:2: RightSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyArrayIndexAccess().getRightSquareBracketKeyword_2()); @@ -36487,14 +36582,14 @@ public final void rule__PropertyArrayIndex__Group__2__Impl() throws RecognitionE // $ANTLR start "rule__PropertyIndexPropertyReference__Group__0" - // InternalBehaviorAnnexParser.g:10920:1: rule__PropertyIndexPropertyReference__Group__0 : rule__PropertyIndexPropertyReference__Group__0__Impl rule__PropertyIndexPropertyReference__Group__1 ; + // InternalBehaviorAnnexParser.g:10947:1: rule__PropertyIndexPropertyReference__Group__0 : rule__PropertyIndexPropertyReference__Group__0__Impl rule__PropertyIndexPropertyReference__Group__1 ; public final void rule__PropertyIndexPropertyReference__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10924:1: ( rule__PropertyIndexPropertyReference__Group__0__Impl rule__PropertyIndexPropertyReference__Group__1 ) - // InternalBehaviorAnnexParser.g:10925:2: rule__PropertyIndexPropertyReference__Group__0__Impl rule__PropertyIndexPropertyReference__Group__1 + // InternalBehaviorAnnexParser.g:10951:1: ( rule__PropertyIndexPropertyReference__Group__0__Impl rule__PropertyIndexPropertyReference__Group__1 ) + // InternalBehaviorAnnexParser.g:10952:2: rule__PropertyIndexPropertyReference__Group__0__Impl rule__PropertyIndexPropertyReference__Group__1 { pushFollow(FollowSets000.FOLLOW_4); rule__PropertyIndexPropertyReference__Group__0__Impl(); @@ -36525,17 +36620,17 @@ public final void rule__PropertyIndexPropertyReference__Group__0() throws Recogn // $ANTLR start "rule__PropertyIndexPropertyReference__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10932:1: rule__PropertyIndexPropertyReference__Group__0__Impl : ( NumberSign ) ; + // InternalBehaviorAnnexParser.g:10959:1: rule__PropertyIndexPropertyReference__Group__0__Impl : ( NumberSign ) ; public final void rule__PropertyIndexPropertyReference__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10936:1: ( ( NumberSign ) ) - // InternalBehaviorAnnexParser.g:10937:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10963:1: ( ( NumberSign ) ) + // InternalBehaviorAnnexParser.g:10964:1: ( NumberSign ) { - // InternalBehaviorAnnexParser.g:10937:1: ( NumberSign ) - // InternalBehaviorAnnexParser.g:10938:2: NumberSign + // InternalBehaviorAnnexParser.g:10964:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10965:2: NumberSign { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexPropertyReferenceAccess().getNumberSignKeyword_0()); @@ -36566,14 +36661,14 @@ public final void rule__PropertyIndexPropertyReference__Group__0__Impl() throws // $ANTLR start "rule__PropertyIndexPropertyReference__Group__1" - // InternalBehaviorAnnexParser.g:10947:1: rule__PropertyIndexPropertyReference__Group__1 : rule__PropertyIndexPropertyReference__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:10974:1: rule__PropertyIndexPropertyReference__Group__1 : rule__PropertyIndexPropertyReference__Group__1__Impl ; public final void rule__PropertyIndexPropertyReference__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10951:1: ( rule__PropertyIndexPropertyReference__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:10952:2: rule__PropertyIndexPropertyReference__Group__1__Impl + // InternalBehaviorAnnexParser.g:10978:1: ( rule__PropertyIndexPropertyReference__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:10979:2: rule__PropertyIndexPropertyReference__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyIndexPropertyReference__Group__1__Impl(); @@ -36599,23 +36694,23 @@ public final void rule__PropertyIndexPropertyReference__Group__1() throws Recogn // $ANTLR start "rule__PropertyIndexPropertyReference__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10958:1: rule__PropertyIndexPropertyReference__Group__1__Impl : ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10985:1: rule__PropertyIndexPropertyReference__Group__1__Impl : ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) ; public final void rule__PropertyIndexPropertyReference__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10962:1: ( ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10963:1: ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10989:1: ( ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10990:1: ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10963:1: ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10964:2: ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10990:1: ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10991:2: ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexPropertyReferenceAccess().getPropertyAssignment_1()); } - // InternalBehaviorAnnexParser.g:10965:2: ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) - // InternalBehaviorAnnexParser.g:10965:3: rule__PropertyIndexPropertyReference__PropertyAssignment_1 + // InternalBehaviorAnnexParser.g:10992:2: ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10992:3: rule__PropertyIndexPropertyReference__PropertyAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyIndexPropertyReference__PropertyAssignment_1(); @@ -36650,14 +36745,14 @@ public final void rule__PropertyIndexPropertyReference__Group__1__Impl() throws // $ANTLR start "rule__UnindexedReferenceExpression__Group__0" - // InternalBehaviorAnnexParser.g:10974:1: rule__UnindexedReferenceExpression__Group__0 : rule__UnindexedReferenceExpression__Group__0__Impl rule__UnindexedReferenceExpression__Group__1 ; + // InternalBehaviorAnnexParser.g:11001:1: rule__UnindexedReferenceExpression__Group__0 : rule__UnindexedReferenceExpression__Group__0__Impl rule__UnindexedReferenceExpression__Group__1 ; public final void rule__UnindexedReferenceExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10978:1: ( rule__UnindexedReferenceExpression__Group__0__Impl rule__UnindexedReferenceExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:10979:2: rule__UnindexedReferenceExpression__Group__0__Impl rule__UnindexedReferenceExpression__Group__1 + // InternalBehaviorAnnexParser.g:11005:1: ( rule__UnindexedReferenceExpression__Group__0__Impl rule__UnindexedReferenceExpression__Group__1 ) + // InternalBehaviorAnnexParser.g:11006:2: rule__UnindexedReferenceExpression__Group__0__Impl rule__UnindexedReferenceExpression__Group__1 { pushFollow(FollowSets000.FOLLOW_75); rule__UnindexedReferenceExpression__Group__0__Impl(); @@ -36688,23 +36783,23 @@ public final void rule__UnindexedReferenceExpression__Group__0() throws Recognit // $ANTLR start "rule__UnindexedReferenceExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10986:1: rule__UnindexedReferenceExpression__Group__0__Impl : ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11013:1: rule__UnindexedReferenceExpression__Group__0__Impl : ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) ; public final void rule__UnindexedReferenceExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10990:1: ( ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:10991:1: ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11017:1: ( ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11018:1: ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:10991:1: ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:10992:2: ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) + // InternalBehaviorAnnexParser.g:11018:1: ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11019:2: ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getReferenceAssignment_0()); } - // InternalBehaviorAnnexParser.g:10993:2: ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) - // InternalBehaviorAnnexParser.g:10993:3: rule__UnindexedReferenceExpression__ReferenceAssignment_0 + // InternalBehaviorAnnexParser.g:11020:2: ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) + // InternalBehaviorAnnexParser.g:11020:3: rule__UnindexedReferenceExpression__ReferenceAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__ReferenceAssignment_0(); @@ -36739,14 +36834,14 @@ public final void rule__UnindexedReferenceExpression__Group__0__Impl() throws Re // $ANTLR start "rule__UnindexedReferenceExpression__Group__1" - // InternalBehaviorAnnexParser.g:11001:1: rule__UnindexedReferenceExpression__Group__1 : rule__UnindexedReferenceExpression__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11028:1: rule__UnindexedReferenceExpression__Group__1 : rule__UnindexedReferenceExpression__Group__1__Impl ; public final void rule__UnindexedReferenceExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11005:1: ( rule__UnindexedReferenceExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11006:2: rule__UnindexedReferenceExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:11032:1: ( rule__UnindexedReferenceExpression__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11033:2: rule__UnindexedReferenceExpression__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__Group__1__Impl(); @@ -36772,31 +36867,31 @@ public final void rule__UnindexedReferenceExpression__Group__1() throws Recognit // $ANTLR start "rule__UnindexedReferenceExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11012:1: rule__UnindexedReferenceExpression__Group__1__Impl : ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) ; + // InternalBehaviorAnnexParser.g:11039:1: rule__UnindexedReferenceExpression__Group__1__Impl : ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) ; public final void rule__UnindexedReferenceExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11016:1: ( ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) ) - // InternalBehaviorAnnexParser.g:11017:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) + // InternalBehaviorAnnexParser.g:11043:1: ( ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) ) + // InternalBehaviorAnnexParser.g:11044:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) { - // InternalBehaviorAnnexParser.g:11017:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) - // InternalBehaviorAnnexParser.g:11018:2: ( rule__UnindexedReferenceExpression__Alternatives_1 )? + // InternalBehaviorAnnexParser.g:11044:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) + // InternalBehaviorAnnexParser.g:11045:2: ( rule__UnindexedReferenceExpression__Alternatives_1 )? { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:11019:2: ( rule__UnindexedReferenceExpression__Alternatives_1 )? - int alt96=2; - int LA96_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:11046:2: ( rule__UnindexedReferenceExpression__Alternatives_1 )? + int alt97=2; + int LA97_0 = input.LA(1); - if ( (LA96_0==Apostrophe||LA96_0==QuestionMark) ) { - alt96=1; + if ( (LA97_0==Apostrophe||LA97_0==QuestionMark) ) { + alt97=1; } - switch (alt96) { + switch (alt97) { case 1 : - // InternalBehaviorAnnexParser.g:11019:3: rule__UnindexedReferenceExpression__Alternatives_1 + // InternalBehaviorAnnexParser.g:11046:3: rule__UnindexedReferenceExpression__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__Alternatives_1(); @@ -36834,14 +36929,14 @@ public final void rule__UnindexedReferenceExpression__Group__1__Impl() throws Re // $ANTLR start "rule__UnindexedReferenceExpression__Group_1_1__0" - // InternalBehaviorAnnexParser.g:11028:1: rule__UnindexedReferenceExpression__Group_1_1__0 : rule__UnindexedReferenceExpression__Group_1_1__0__Impl rule__UnindexedReferenceExpression__Group_1_1__1 ; + // InternalBehaviorAnnexParser.g:11055:1: rule__UnindexedReferenceExpression__Group_1_1__0 : rule__UnindexedReferenceExpression__Group_1_1__0__Impl rule__UnindexedReferenceExpression__Group_1_1__1 ; public final void rule__UnindexedReferenceExpression__Group_1_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11032:1: ( rule__UnindexedReferenceExpression__Group_1_1__0__Impl rule__UnindexedReferenceExpression__Group_1_1__1 ) - // InternalBehaviorAnnexParser.g:11033:2: rule__UnindexedReferenceExpression__Group_1_1__0__Impl rule__UnindexedReferenceExpression__Group_1_1__1 + // InternalBehaviorAnnexParser.g:11059:1: ( rule__UnindexedReferenceExpression__Group_1_1__0__Impl rule__UnindexedReferenceExpression__Group_1_1__1 ) + // InternalBehaviorAnnexParser.g:11060:2: rule__UnindexedReferenceExpression__Group_1_1__0__Impl rule__UnindexedReferenceExpression__Group_1_1__1 { pushFollow(FollowSets000.FOLLOW_71); rule__UnindexedReferenceExpression__Group_1_1__0__Impl(); @@ -36872,17 +36967,17 @@ public final void rule__UnindexedReferenceExpression__Group_1_1__0() throws Reco // $ANTLR start "rule__UnindexedReferenceExpression__Group_1_1__0__Impl" - // InternalBehaviorAnnexParser.g:11040:1: rule__UnindexedReferenceExpression__Group_1_1__0__Impl : ( Apostrophe ) ; + // InternalBehaviorAnnexParser.g:11067:1: rule__UnindexedReferenceExpression__Group_1_1__0__Impl : ( Apostrophe ) ; public final void rule__UnindexedReferenceExpression__Group_1_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11044:1: ( ( Apostrophe ) ) - // InternalBehaviorAnnexParser.g:11045:1: ( Apostrophe ) + // InternalBehaviorAnnexParser.g:11071:1: ( ( Apostrophe ) ) + // InternalBehaviorAnnexParser.g:11072:1: ( Apostrophe ) { - // InternalBehaviorAnnexParser.g:11045:1: ( Apostrophe ) - // InternalBehaviorAnnexParser.g:11046:2: Apostrophe + // InternalBehaviorAnnexParser.g:11072:1: ( Apostrophe ) + // InternalBehaviorAnnexParser.g:11073:2: Apostrophe { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getApostropheKeyword_1_1_0()); @@ -36913,14 +37008,14 @@ public final void rule__UnindexedReferenceExpression__Group_1_1__0__Impl() throw // $ANTLR start "rule__UnindexedReferenceExpression__Group_1_1__1" - // InternalBehaviorAnnexParser.g:11055:1: rule__UnindexedReferenceExpression__Group_1_1__1 : rule__UnindexedReferenceExpression__Group_1_1__1__Impl ; + // InternalBehaviorAnnexParser.g:11082:1: rule__UnindexedReferenceExpression__Group_1_1__1 : rule__UnindexedReferenceExpression__Group_1_1__1__Impl ; public final void rule__UnindexedReferenceExpression__Group_1_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11059:1: ( rule__UnindexedReferenceExpression__Group_1_1__1__Impl ) - // InternalBehaviorAnnexParser.g:11060:2: rule__UnindexedReferenceExpression__Group_1_1__1__Impl + // InternalBehaviorAnnexParser.g:11086:1: ( rule__UnindexedReferenceExpression__Group_1_1__1__Impl ) + // InternalBehaviorAnnexParser.g:11087:2: rule__UnindexedReferenceExpression__Group_1_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__Group_1_1__1__Impl(); @@ -36946,23 +37041,23 @@ public final void rule__UnindexedReferenceExpression__Group_1_1__1() throws Reco // $ANTLR start "rule__UnindexedReferenceExpression__Group_1_1__1__Impl" - // InternalBehaviorAnnexParser.g:11066:1: rule__UnindexedReferenceExpression__Group_1_1__1__Impl : ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:11093:1: rule__UnindexedReferenceExpression__Group_1_1__1__Impl : ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) ; public final void rule__UnindexedReferenceExpression__Group_1_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11070:1: ( ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:11071:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:11097:1: ( ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:11098:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) { - // InternalBehaviorAnnexParser.g:11071:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) - // InternalBehaviorAnnexParser.g:11072:2: ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) + // InternalBehaviorAnnexParser.g:11098:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:11099:2: ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getAlternatives_1_1_1()); } - // InternalBehaviorAnnexParser.g:11073:2: ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) - // InternalBehaviorAnnexParser.g:11073:3: rule__UnindexedReferenceExpression__Alternatives_1_1_1 + // InternalBehaviorAnnexParser.g:11100:2: ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) + // InternalBehaviorAnnexParser.g:11100:3: rule__UnindexedReferenceExpression__Alternatives_1_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__Alternatives_1_1_1(); @@ -36997,14 +37092,14 @@ public final void rule__UnindexedReferenceExpression__Group_1_1__1__Impl() throw // $ANTLR start "rule__UnindexedReference__Group__0" - // InternalBehaviorAnnexParser.g:11082:1: rule__UnindexedReference__Group__0 : rule__UnindexedReference__Group__0__Impl rule__UnindexedReference__Group__1 ; + // InternalBehaviorAnnexParser.g:11109:1: rule__UnindexedReference__Group__0 : rule__UnindexedReference__Group__0__Impl rule__UnindexedReference__Group__1 ; public final void rule__UnindexedReference__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11086:1: ( rule__UnindexedReference__Group__0__Impl rule__UnindexedReference__Group__1 ) - // InternalBehaviorAnnexParser.g:11087:2: rule__UnindexedReference__Group__0__Impl rule__UnindexedReference__Group__1 + // InternalBehaviorAnnexParser.g:11113:1: ( rule__UnindexedReference__Group__0__Impl rule__UnindexedReference__Group__1 ) + // InternalBehaviorAnnexParser.g:11114:2: rule__UnindexedReference__Group__0__Impl rule__UnindexedReference__Group__1 { pushFollow(FollowSets000.FOLLOW_76); rule__UnindexedReference__Group__0__Impl(); @@ -37035,23 +37130,23 @@ public final void rule__UnindexedReference__Group__0() throws RecognitionExcepti // $ANTLR start "rule__UnindexedReference__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11094:1: rule__UnindexedReference__Group__0__Impl : ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11121:1: rule__UnindexedReference__Group__0__Impl : ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) ; public final void rule__UnindexedReference__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11098:1: ( ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11099:1: ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11125:1: ( ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11126:1: ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11099:1: ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11100:2: ( rule__UnindexedReference__SegmentsAssignment_0 ) + // InternalBehaviorAnnexParser.g:11126:1: ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11127:2: ( rule__UnindexedReference__SegmentsAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceAccess().getSegmentsAssignment_0()); } - // InternalBehaviorAnnexParser.g:11101:2: ( rule__UnindexedReference__SegmentsAssignment_0 ) - // InternalBehaviorAnnexParser.g:11101:3: rule__UnindexedReference__SegmentsAssignment_0 + // InternalBehaviorAnnexParser.g:11128:2: ( rule__UnindexedReference__SegmentsAssignment_0 ) + // InternalBehaviorAnnexParser.g:11128:3: rule__UnindexedReference__SegmentsAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReference__SegmentsAssignment_0(); @@ -37086,14 +37181,14 @@ public final void rule__UnindexedReference__Group__0__Impl() throws RecognitionE // $ANTLR start "rule__UnindexedReference__Group__1" - // InternalBehaviorAnnexParser.g:11109:1: rule__UnindexedReference__Group__1 : rule__UnindexedReference__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11136:1: rule__UnindexedReference__Group__1 : rule__UnindexedReference__Group__1__Impl ; public final void rule__UnindexedReference__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11113:1: ( rule__UnindexedReference__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11114:2: rule__UnindexedReference__Group__1__Impl + // InternalBehaviorAnnexParser.g:11140:1: ( rule__UnindexedReference__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11141:2: rule__UnindexedReference__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReference__Group__1__Impl(); @@ -37119,35 +37214,35 @@ public final void rule__UnindexedReference__Group__1() throws RecognitionExcepti // $ANTLR start "rule__UnindexedReference__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11120:1: rule__UnindexedReference__Group__1__Impl : ( ( rule__UnindexedReference__TailsAssignment_1 )* ) ; + // InternalBehaviorAnnexParser.g:11147:1: rule__UnindexedReference__Group__1__Impl : ( ( rule__UnindexedReference__TailsAssignment_1 )* ) ; public final void rule__UnindexedReference__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11124:1: ( ( ( rule__UnindexedReference__TailsAssignment_1 )* ) ) - // InternalBehaviorAnnexParser.g:11125:1: ( ( rule__UnindexedReference__TailsAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11151:1: ( ( ( rule__UnindexedReference__TailsAssignment_1 )* ) ) + // InternalBehaviorAnnexParser.g:11152:1: ( ( rule__UnindexedReference__TailsAssignment_1 )* ) { - // InternalBehaviorAnnexParser.g:11125:1: ( ( rule__UnindexedReference__TailsAssignment_1 )* ) - // InternalBehaviorAnnexParser.g:11126:2: ( rule__UnindexedReference__TailsAssignment_1 )* + // InternalBehaviorAnnexParser.g:11152:1: ( ( rule__UnindexedReference__TailsAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11153:2: ( rule__UnindexedReference__TailsAssignment_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceAccess().getTailsAssignment_1()); } - // InternalBehaviorAnnexParser.g:11127:2: ( rule__UnindexedReference__TailsAssignment_1 )* - loop97: + // InternalBehaviorAnnexParser.g:11154:2: ( rule__UnindexedReference__TailsAssignment_1 )* + loop98: do { - int alt97=2; - int LA97_0 = input.LA(1); + int alt98=2; + int LA98_0 = input.LA(1); - if ( (LA97_0==ColonColon||LA97_0==FullStop) ) { - alt97=1; + if ( (LA98_0==ColonColon||LA98_0==FullStop) ) { + alt98=1; } - switch (alt97) { + switch (alt98) { case 1 : - // InternalBehaviorAnnexParser.g:11127:3: rule__UnindexedReference__TailsAssignment_1 + // InternalBehaviorAnnexParser.g:11154:3: rule__UnindexedReference__TailsAssignment_1 { pushFollow(FollowSets000.FOLLOW_77); rule__UnindexedReference__TailsAssignment_1(); @@ -37159,7 +37254,7 @@ public final void rule__UnindexedReference__Group__1__Impl() throws RecognitionE break; default : - break loop97; + break loop98; } } while (true); @@ -37188,14 +37283,14 @@ public final void rule__UnindexedReference__Group__1__Impl() throws RecognitionE // $ANTLR start "rule__UnindexedReferenceTail__Group__0" - // InternalBehaviorAnnexParser.g:11136:1: rule__UnindexedReferenceTail__Group__0 : rule__UnindexedReferenceTail__Group__0__Impl rule__UnindexedReferenceTail__Group__1 ; + // InternalBehaviorAnnexParser.g:11163:1: rule__UnindexedReferenceTail__Group__0 : rule__UnindexedReferenceTail__Group__0__Impl rule__UnindexedReferenceTail__Group__1 ; public final void rule__UnindexedReferenceTail__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11140:1: ( rule__UnindexedReferenceTail__Group__0__Impl rule__UnindexedReferenceTail__Group__1 ) - // InternalBehaviorAnnexParser.g:11141:2: rule__UnindexedReferenceTail__Group__0__Impl rule__UnindexedReferenceTail__Group__1 + // InternalBehaviorAnnexParser.g:11167:1: ( rule__UnindexedReferenceTail__Group__0__Impl rule__UnindexedReferenceTail__Group__1 ) + // InternalBehaviorAnnexParser.g:11168:2: rule__UnindexedReferenceTail__Group__0__Impl rule__UnindexedReferenceTail__Group__1 { pushFollow(FollowSets000.FOLLOW_74); rule__UnindexedReferenceTail__Group__0__Impl(); @@ -37226,23 +37321,23 @@ public final void rule__UnindexedReferenceTail__Group__0() throws RecognitionExc // $ANTLR start "rule__UnindexedReferenceTail__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11148:1: rule__UnindexedReferenceTail__Group__0__Impl : ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11175:1: rule__UnindexedReferenceTail__Group__0__Impl : ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) ; public final void rule__UnindexedReferenceTail__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11152:1: ( ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11153:1: ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11179:1: ( ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11180:1: ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11153:1: ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11154:2: ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) + // InternalBehaviorAnnexParser.g:11180:1: ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11181:2: ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceTailAccess().getSeparatorAssignment_0()); } - // InternalBehaviorAnnexParser.g:11155:2: ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) - // InternalBehaviorAnnexParser.g:11155:3: rule__UnindexedReferenceTail__SeparatorAssignment_0 + // InternalBehaviorAnnexParser.g:11182:2: ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) + // InternalBehaviorAnnexParser.g:11182:3: rule__UnindexedReferenceTail__SeparatorAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceTail__SeparatorAssignment_0(); @@ -37277,14 +37372,14 @@ public final void rule__UnindexedReferenceTail__Group__0__Impl() throws Recognit // $ANTLR start "rule__UnindexedReferenceTail__Group__1" - // InternalBehaviorAnnexParser.g:11163:1: rule__UnindexedReferenceTail__Group__1 : rule__UnindexedReferenceTail__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11190:1: rule__UnindexedReferenceTail__Group__1 : rule__UnindexedReferenceTail__Group__1__Impl ; public final void rule__UnindexedReferenceTail__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11167:1: ( rule__UnindexedReferenceTail__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11168:2: rule__UnindexedReferenceTail__Group__1__Impl + // InternalBehaviorAnnexParser.g:11194:1: ( rule__UnindexedReferenceTail__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11195:2: rule__UnindexedReferenceTail__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceTail__Group__1__Impl(); @@ -37310,23 +37405,23 @@ public final void rule__UnindexedReferenceTail__Group__1() throws RecognitionExc // $ANTLR start "rule__UnindexedReferenceTail__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11174:1: rule__UnindexedReferenceTail__Group__1__Impl : ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:11201:1: rule__UnindexedReferenceTail__Group__1__Impl : ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) ; public final void rule__UnindexedReferenceTail__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11178:1: ( ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:11179:1: ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11205:1: ( ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:11206:1: ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:11179:1: ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:11180:2: ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) + // InternalBehaviorAnnexParser.g:11206:1: ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11207:2: ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceTailAccess().getSegmentAssignment_1()); } - // InternalBehaviorAnnexParser.g:11181:2: ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) - // InternalBehaviorAnnexParser.g:11181:3: rule__UnindexedReferenceTail__SegmentAssignment_1 + // InternalBehaviorAnnexParser.g:11208:2: ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) + // InternalBehaviorAnnexParser.g:11208:3: rule__UnindexedReferenceTail__SegmentAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceTail__SegmentAssignment_1(); @@ -37361,14 +37456,14 @@ public final void rule__UnindexedReferenceTail__Group__1__Impl() throws Recognit // $ANTLR start "rule__QualifiedName__Group__0" - // InternalBehaviorAnnexParser.g:11190:1: rule__QualifiedName__Group__0 : rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ; + // InternalBehaviorAnnexParser.g:11217:1: rule__QualifiedName__Group__0 : rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ; public final void rule__QualifiedName__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11194:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ) - // InternalBehaviorAnnexParser.g:11195:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 + // InternalBehaviorAnnexParser.g:11221:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ) + // InternalBehaviorAnnexParser.g:11222:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 { pushFollow(FollowSets000.FOLLOW_78); rule__QualifiedName__Group__0__Impl(); @@ -37399,17 +37494,17 @@ public final void rule__QualifiedName__Group__0() throws RecognitionException { // $ANTLR start "rule__QualifiedName__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11202:1: rule__QualifiedName__Group__0__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:11229:1: rule__QualifiedName__Group__0__Impl : ( RULE_ID ) ; public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11206:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:11207:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:11233:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:11234:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:11207:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:11208:2: RULE_ID + // InternalBehaviorAnnexParser.g:11234:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:11235:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); @@ -37440,14 +37535,14 @@ public final void rule__QualifiedName__Group__0__Impl() throws RecognitionExcept // $ANTLR start "rule__QualifiedName__Group__1" - // InternalBehaviorAnnexParser.g:11217:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11244:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ; public final void rule__QualifiedName__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11221:1: ( rule__QualifiedName__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11222:2: rule__QualifiedName__Group__1__Impl + // InternalBehaviorAnnexParser.g:11248:1: ( rule__QualifiedName__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11249:2: rule__QualifiedName__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QualifiedName__Group__1__Impl(); @@ -37473,35 +37568,35 @@ public final void rule__QualifiedName__Group__1() throws RecognitionException { // $ANTLR start "rule__QualifiedName__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11228:1: rule__QualifiedName__Group__1__Impl : ( ( rule__QualifiedName__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:11255:1: rule__QualifiedName__Group__1__Impl : ( ( rule__QualifiedName__Group_1__0 )* ) ; public final void rule__QualifiedName__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11232:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:11233:1: ( ( rule__QualifiedName__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:11259:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:11260:1: ( ( rule__QualifiedName__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:11233:1: ( ( rule__QualifiedName__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:11234:2: ( rule__QualifiedName__Group_1__0 )* + // InternalBehaviorAnnexParser.g:11260:1: ( ( rule__QualifiedName__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:11261:2: ( rule__QualifiedName__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:11235:2: ( rule__QualifiedName__Group_1__0 )* - loop98: + // InternalBehaviorAnnexParser.g:11262:2: ( rule__QualifiedName__Group_1__0 )* + loop99: do { - int alt98=2; - int LA98_0 = input.LA(1); + int alt99=2; + int LA99_0 = input.LA(1); - if ( (LA98_0==ColonColon) ) { - alt98=1; + if ( (LA99_0==ColonColon) ) { + alt99=1; } - switch (alt98) { + switch (alt99) { case 1 : - // InternalBehaviorAnnexParser.g:11235:3: rule__QualifiedName__Group_1__0 + // InternalBehaviorAnnexParser.g:11262:3: rule__QualifiedName__Group_1__0 { pushFollow(FollowSets000.FOLLOW_79); rule__QualifiedName__Group_1__0(); @@ -37513,7 +37608,7 @@ public final void rule__QualifiedName__Group__1__Impl() throws RecognitionExcept break; default : - break loop98; + break loop99; } } while (true); @@ -37542,14 +37637,14 @@ public final void rule__QualifiedName__Group__1__Impl() throws RecognitionExcept // $ANTLR start "rule__QualifiedName__Group_1__0" - // InternalBehaviorAnnexParser.g:11244:1: rule__QualifiedName__Group_1__0 : rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ; + // InternalBehaviorAnnexParser.g:11271:1: rule__QualifiedName__Group_1__0 : rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ; public final void rule__QualifiedName__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11248:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ) - // InternalBehaviorAnnexParser.g:11249:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 + // InternalBehaviorAnnexParser.g:11275:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ) + // InternalBehaviorAnnexParser.g:11276:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 { pushFollow(FollowSets000.FOLLOW_4); rule__QualifiedName__Group_1__0__Impl(); @@ -37580,17 +37675,17 @@ public final void rule__QualifiedName__Group_1__0() throws RecognitionException // $ANTLR start "rule__QualifiedName__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:11256:1: rule__QualifiedName__Group_1__0__Impl : ( ColonColon ) ; + // InternalBehaviorAnnexParser.g:11283:1: rule__QualifiedName__Group_1__0__Impl : ( ColonColon ) ; public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11260:1: ( ( ColonColon ) ) - // InternalBehaviorAnnexParser.g:11261:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:11287:1: ( ( ColonColon ) ) + // InternalBehaviorAnnexParser.g:11288:1: ( ColonColon ) { - // InternalBehaviorAnnexParser.g:11261:1: ( ColonColon ) - // InternalBehaviorAnnexParser.g:11262:2: ColonColon + // InternalBehaviorAnnexParser.g:11288:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:11289:2: ColonColon { if ( state.backtracking==0 ) { before(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); @@ -37621,14 +37716,14 @@ public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionExce // $ANTLR start "rule__QualifiedName__Group_1__1" - // InternalBehaviorAnnexParser.g:11271:1: rule__QualifiedName__Group_1__1 : rule__QualifiedName__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:11298:1: rule__QualifiedName__Group_1__1 : rule__QualifiedName__Group_1__1__Impl ; public final void rule__QualifiedName__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11275:1: ( rule__QualifiedName__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:11276:2: rule__QualifiedName__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:11302:1: ( rule__QualifiedName__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:11303:2: rule__QualifiedName__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QualifiedName__Group_1__1__Impl(); @@ -37654,17 +37749,17 @@ public final void rule__QualifiedName__Group_1__1() throws RecognitionException // $ANTLR start "rule__QualifiedName__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:11282:1: rule__QualifiedName__Group_1__1__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:11309:1: rule__QualifiedName__Group_1__1__Impl : ( RULE_ID ) ; public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11286:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:11287:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:11313:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:11314:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:11287:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:11288:2: RULE_ID + // InternalBehaviorAnnexParser.g:11314:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:11315:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); @@ -37695,14 +37790,14 @@ public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionExce // $ANTLR start "rule__Reference__Group__0" - // InternalBehaviorAnnexParser.g:11298:1: rule__Reference__Group__0 : rule__Reference__Group__0__Impl rule__Reference__Group__1 ; + // InternalBehaviorAnnexParser.g:11325:1: rule__Reference__Group__0 : rule__Reference__Group__0__Impl rule__Reference__Group__1 ; public final void rule__Reference__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11302:1: ( rule__Reference__Group__0__Impl rule__Reference__Group__1 ) - // InternalBehaviorAnnexParser.g:11303:2: rule__Reference__Group__0__Impl rule__Reference__Group__1 + // InternalBehaviorAnnexParser.g:11329:1: ( rule__Reference__Group__0__Impl rule__Reference__Group__1 ) + // InternalBehaviorAnnexParser.g:11330:2: rule__Reference__Group__0__Impl rule__Reference__Group__1 { pushFollow(FollowSets000.FOLLOW_76); rule__Reference__Group__0__Impl(); @@ -37733,23 +37828,23 @@ public final void rule__Reference__Group__0() throws RecognitionException { // $ANTLR start "rule__Reference__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11310:1: rule__Reference__Group__0__Impl : ( ( rule__Reference__SegmentsAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11337:1: rule__Reference__Group__0__Impl : ( ( rule__Reference__SegmentsAssignment_0 ) ) ; public final void rule__Reference__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11314:1: ( ( ( rule__Reference__SegmentsAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11315:1: ( ( rule__Reference__SegmentsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11341:1: ( ( ( rule__Reference__SegmentsAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11342:1: ( ( rule__Reference__SegmentsAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11315:1: ( ( rule__Reference__SegmentsAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11316:2: ( rule__Reference__SegmentsAssignment_0 ) + // InternalBehaviorAnnexParser.g:11342:1: ( ( rule__Reference__SegmentsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11343:2: ( rule__Reference__SegmentsAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceAccess().getSegmentsAssignment_0()); } - // InternalBehaviorAnnexParser.g:11317:2: ( rule__Reference__SegmentsAssignment_0 ) - // InternalBehaviorAnnexParser.g:11317:3: rule__Reference__SegmentsAssignment_0 + // InternalBehaviorAnnexParser.g:11344:2: ( rule__Reference__SegmentsAssignment_0 ) + // InternalBehaviorAnnexParser.g:11344:3: rule__Reference__SegmentsAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__Reference__SegmentsAssignment_0(); @@ -37784,14 +37879,14 @@ public final void rule__Reference__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__Reference__Group__1" - // InternalBehaviorAnnexParser.g:11325:1: rule__Reference__Group__1 : rule__Reference__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11352:1: rule__Reference__Group__1 : rule__Reference__Group__1__Impl ; public final void rule__Reference__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11329:1: ( rule__Reference__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11330:2: rule__Reference__Group__1__Impl + // InternalBehaviorAnnexParser.g:11356:1: ( rule__Reference__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11357:2: rule__Reference__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__Reference__Group__1__Impl(); @@ -37817,35 +37912,35 @@ public final void rule__Reference__Group__1() throws RecognitionException { // $ANTLR start "rule__Reference__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11336:1: rule__Reference__Group__1__Impl : ( ( rule__Reference__TailsAssignment_1 )* ) ; + // InternalBehaviorAnnexParser.g:11363:1: rule__Reference__Group__1__Impl : ( ( rule__Reference__TailsAssignment_1 )* ) ; public final void rule__Reference__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11340:1: ( ( ( rule__Reference__TailsAssignment_1 )* ) ) - // InternalBehaviorAnnexParser.g:11341:1: ( ( rule__Reference__TailsAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11367:1: ( ( ( rule__Reference__TailsAssignment_1 )* ) ) + // InternalBehaviorAnnexParser.g:11368:1: ( ( rule__Reference__TailsAssignment_1 )* ) { - // InternalBehaviorAnnexParser.g:11341:1: ( ( rule__Reference__TailsAssignment_1 )* ) - // InternalBehaviorAnnexParser.g:11342:2: ( rule__Reference__TailsAssignment_1 )* + // InternalBehaviorAnnexParser.g:11368:1: ( ( rule__Reference__TailsAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11369:2: ( rule__Reference__TailsAssignment_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceAccess().getTailsAssignment_1()); } - // InternalBehaviorAnnexParser.g:11343:2: ( rule__Reference__TailsAssignment_1 )* - loop99: + // InternalBehaviorAnnexParser.g:11370:2: ( rule__Reference__TailsAssignment_1 )* + loop100: do { - int alt99=2; - int LA99_0 = input.LA(1); + int alt100=2; + int LA100_0 = input.LA(1); - if ( (LA99_0==ColonColon||LA99_0==FullStop) ) { - alt99=1; + if ( (LA100_0==ColonColon||LA100_0==FullStop) ) { + alt100=1; } - switch (alt99) { + switch (alt100) { case 1 : - // InternalBehaviorAnnexParser.g:11343:3: rule__Reference__TailsAssignment_1 + // InternalBehaviorAnnexParser.g:11370:3: rule__Reference__TailsAssignment_1 { pushFollow(FollowSets000.FOLLOW_77); rule__Reference__TailsAssignment_1(); @@ -37857,7 +37952,7 @@ public final void rule__Reference__Group__1__Impl() throws RecognitionException break; default : - break loop99; + break loop100; } } while (true); @@ -37886,14 +37981,14 @@ public final void rule__Reference__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__ReferenceTail__Group__0" - // InternalBehaviorAnnexParser.g:11352:1: rule__ReferenceTail__Group__0 : rule__ReferenceTail__Group__0__Impl rule__ReferenceTail__Group__1 ; + // InternalBehaviorAnnexParser.g:11379:1: rule__ReferenceTail__Group__0 : rule__ReferenceTail__Group__0__Impl rule__ReferenceTail__Group__1 ; public final void rule__ReferenceTail__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11356:1: ( rule__ReferenceTail__Group__0__Impl rule__ReferenceTail__Group__1 ) - // InternalBehaviorAnnexParser.g:11357:2: rule__ReferenceTail__Group__0__Impl rule__ReferenceTail__Group__1 + // InternalBehaviorAnnexParser.g:11383:1: ( rule__ReferenceTail__Group__0__Impl rule__ReferenceTail__Group__1 ) + // InternalBehaviorAnnexParser.g:11384:2: rule__ReferenceTail__Group__0__Impl rule__ReferenceTail__Group__1 { pushFollow(FollowSets000.FOLLOW_13); rule__ReferenceTail__Group__0__Impl(); @@ -37924,23 +38019,23 @@ public final void rule__ReferenceTail__Group__0() throws RecognitionException { // $ANTLR start "rule__ReferenceTail__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11364:1: rule__ReferenceTail__Group__0__Impl : ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11391:1: rule__ReferenceTail__Group__0__Impl : ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) ; public final void rule__ReferenceTail__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11368:1: ( ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11369:1: ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11395:1: ( ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11396:1: ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11369:1: ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11370:2: ( rule__ReferenceTail__SeparatorAssignment_0 ) + // InternalBehaviorAnnexParser.g:11396:1: ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11397:2: ( rule__ReferenceTail__SeparatorAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTailAccess().getSeparatorAssignment_0()); } - // InternalBehaviorAnnexParser.g:11371:2: ( rule__ReferenceTail__SeparatorAssignment_0 ) - // InternalBehaviorAnnexParser.g:11371:3: rule__ReferenceTail__SeparatorAssignment_0 + // InternalBehaviorAnnexParser.g:11398:2: ( rule__ReferenceTail__SeparatorAssignment_0 ) + // InternalBehaviorAnnexParser.g:11398:3: rule__ReferenceTail__SeparatorAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTail__SeparatorAssignment_0(); @@ -37975,14 +38070,14 @@ public final void rule__ReferenceTail__Group__0__Impl() throws RecognitionExcept // $ANTLR start "rule__ReferenceTail__Group__1" - // InternalBehaviorAnnexParser.g:11379:1: rule__ReferenceTail__Group__1 : rule__ReferenceTail__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11406:1: rule__ReferenceTail__Group__1 : rule__ReferenceTail__Group__1__Impl ; public final void rule__ReferenceTail__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11383:1: ( rule__ReferenceTail__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11384:2: rule__ReferenceTail__Group__1__Impl + // InternalBehaviorAnnexParser.g:11410:1: ( rule__ReferenceTail__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11411:2: rule__ReferenceTail__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTail__Group__1__Impl(); @@ -38008,23 +38103,23 @@ public final void rule__ReferenceTail__Group__1() throws RecognitionException { // $ANTLR start "rule__ReferenceTail__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11390:1: rule__ReferenceTail__Group__1__Impl : ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:11417:1: rule__ReferenceTail__Group__1__Impl : ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) ; public final void rule__ReferenceTail__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11394:1: ( ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:11395:1: ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11421:1: ( ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:11422:1: ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:11395:1: ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:11396:2: ( rule__ReferenceTail__SegmentAssignment_1 ) + // InternalBehaviorAnnexParser.g:11422:1: ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11423:2: ( rule__ReferenceTail__SegmentAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTailAccess().getSegmentAssignment_1()); } - // InternalBehaviorAnnexParser.g:11397:2: ( rule__ReferenceTail__SegmentAssignment_1 ) - // InternalBehaviorAnnexParser.g:11397:3: rule__ReferenceTail__SegmentAssignment_1 + // InternalBehaviorAnnexParser.g:11424:2: ( rule__ReferenceTail__SegmentAssignment_1 ) + // InternalBehaviorAnnexParser.g:11424:3: rule__ReferenceTail__SegmentAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTail__SegmentAssignment_1(); @@ -38059,14 +38154,14 @@ public final void rule__ReferenceTail__Group__1__Impl() throws RecognitionExcept // $ANTLR start "rule__ReferenceSegment__Group__0" - // InternalBehaviorAnnexParser.g:11406:1: rule__ReferenceSegment__Group__0 : rule__ReferenceSegment__Group__0__Impl rule__ReferenceSegment__Group__1 ; + // InternalBehaviorAnnexParser.g:11433:1: rule__ReferenceSegment__Group__0 : rule__ReferenceSegment__Group__0__Impl rule__ReferenceSegment__Group__1 ; public final void rule__ReferenceSegment__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11410:1: ( rule__ReferenceSegment__Group__0__Impl rule__ReferenceSegment__Group__1 ) - // InternalBehaviorAnnexParser.g:11411:2: rule__ReferenceSegment__Group__0__Impl rule__ReferenceSegment__Group__1 + // InternalBehaviorAnnexParser.g:11437:1: ( rule__ReferenceSegment__Group__0__Impl rule__ReferenceSegment__Group__1 ) + // InternalBehaviorAnnexParser.g:11438:2: rule__ReferenceSegment__Group__0__Impl rule__ReferenceSegment__Group__1 { pushFollow(FollowSets000.FOLLOW_11); rule__ReferenceSegment__Group__0__Impl(); @@ -38097,23 +38192,23 @@ public final void rule__ReferenceSegment__Group__0() throws RecognitionException // $ANTLR start "rule__ReferenceSegment__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11418:1: rule__ReferenceSegment__Group__0__Impl : ( ( rule__ReferenceSegment__NameAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11445:1: rule__ReferenceSegment__Group__0__Impl : ( ( rule__ReferenceSegment__NameAssignment_0 ) ) ; public final void rule__ReferenceSegment__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11422:1: ( ( ( rule__ReferenceSegment__NameAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11423:1: ( ( rule__ReferenceSegment__NameAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11449:1: ( ( ( rule__ReferenceSegment__NameAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11450:1: ( ( rule__ReferenceSegment__NameAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11423:1: ( ( rule__ReferenceSegment__NameAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11424:2: ( rule__ReferenceSegment__NameAssignment_0 ) + // InternalBehaviorAnnexParser.g:11450:1: ( ( rule__ReferenceSegment__NameAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11451:2: ( rule__ReferenceSegment__NameAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSegmentAccess().getNameAssignment_0()); } - // InternalBehaviorAnnexParser.g:11425:2: ( rule__ReferenceSegment__NameAssignment_0 ) - // InternalBehaviorAnnexParser.g:11425:3: rule__ReferenceSegment__NameAssignment_0 + // InternalBehaviorAnnexParser.g:11452:2: ( rule__ReferenceSegment__NameAssignment_0 ) + // InternalBehaviorAnnexParser.g:11452:3: rule__ReferenceSegment__NameAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceSegment__NameAssignment_0(); @@ -38148,14 +38243,14 @@ public final void rule__ReferenceSegment__Group__0__Impl() throws RecognitionExc // $ANTLR start "rule__ReferenceSegment__Group__1" - // InternalBehaviorAnnexParser.g:11433:1: rule__ReferenceSegment__Group__1 : rule__ReferenceSegment__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11460:1: rule__ReferenceSegment__Group__1 : rule__ReferenceSegment__Group__1__Impl ; public final void rule__ReferenceSegment__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11437:1: ( rule__ReferenceSegment__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11438:2: rule__ReferenceSegment__Group__1__Impl + // InternalBehaviorAnnexParser.g:11464:1: ( rule__ReferenceSegment__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11465:2: rule__ReferenceSegment__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceSegment__Group__1__Impl(); @@ -38181,35 +38276,35 @@ public final void rule__ReferenceSegment__Group__1() throws RecognitionException // $ANTLR start "rule__ReferenceSegment__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11444:1: rule__ReferenceSegment__Group__1__Impl : ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) ; + // InternalBehaviorAnnexParser.g:11471:1: rule__ReferenceSegment__Group__1__Impl : ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) ; public final void rule__ReferenceSegment__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11448:1: ( ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) ) - // InternalBehaviorAnnexParser.g:11449:1: ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11475:1: ( ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) ) + // InternalBehaviorAnnexParser.g:11476:1: ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) { - // InternalBehaviorAnnexParser.g:11449:1: ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) - // InternalBehaviorAnnexParser.g:11450:2: ( rule__ReferenceSegment__IndexesAssignment_1 )* + // InternalBehaviorAnnexParser.g:11476:1: ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11477:2: ( rule__ReferenceSegment__IndexesAssignment_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSegmentAccess().getIndexesAssignment_1()); } - // InternalBehaviorAnnexParser.g:11451:2: ( rule__ReferenceSegment__IndexesAssignment_1 )* - loop100: + // InternalBehaviorAnnexParser.g:11478:2: ( rule__ReferenceSegment__IndexesAssignment_1 )* + loop101: do { - int alt100=2; - int LA100_0 = input.LA(1); + int alt101=2; + int LA101_0 = input.LA(1); - if ( (LA100_0==LeftSquareBracket) ) { - alt100=1; + if ( (LA101_0==LeftSquareBracket) ) { + alt101=1; } - switch (alt100) { + switch (alt101) { case 1 : - // InternalBehaviorAnnexParser.g:11451:3: rule__ReferenceSegment__IndexesAssignment_1 + // InternalBehaviorAnnexParser.g:11478:3: rule__ReferenceSegment__IndexesAssignment_1 { pushFollow(FollowSets000.FOLLOW_12); rule__ReferenceSegment__IndexesAssignment_1(); @@ -38221,7 +38316,7 @@ public final void rule__ReferenceSegment__Group__1__Impl() throws RecognitionExc break; default : - break loop100; + break loop101; } } while (true); @@ -38250,14 +38345,14 @@ public final void rule__ReferenceSegment__Group__1__Impl() throws RecognitionExc // $ANTLR start "rule__ArrayIndex__Group__0" - // InternalBehaviorAnnexParser.g:11460:1: rule__ArrayIndex__Group__0 : rule__ArrayIndex__Group__0__Impl rule__ArrayIndex__Group__1 ; + // InternalBehaviorAnnexParser.g:11487:1: rule__ArrayIndex__Group__0 : rule__ArrayIndex__Group__0__Impl rule__ArrayIndex__Group__1 ; public final void rule__ArrayIndex__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11464:1: ( rule__ArrayIndex__Group__0__Impl rule__ArrayIndex__Group__1 ) - // InternalBehaviorAnnexParser.g:11465:2: rule__ArrayIndex__Group__0__Impl rule__ArrayIndex__Group__1 + // InternalBehaviorAnnexParser.g:11491:1: ( rule__ArrayIndex__Group__0__Impl rule__ArrayIndex__Group__1 ) + // InternalBehaviorAnnexParser.g:11492:2: rule__ArrayIndex__Group__0__Impl rule__ArrayIndex__Group__1 { pushFollow(FollowSets000.FOLLOW_13); rule__ArrayIndex__Group__0__Impl(); @@ -38288,17 +38383,17 @@ public final void rule__ArrayIndex__Group__0() throws RecognitionException { // $ANTLR start "rule__ArrayIndex__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11472:1: rule__ArrayIndex__Group__0__Impl : ( LeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:11499:1: rule__ArrayIndex__Group__0__Impl : ( LeftSquareBracket ) ; public final void rule__ArrayIndex__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11476:1: ( ( LeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:11477:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:11503:1: ( ( LeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:11504:1: ( LeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:11477:1: ( LeftSquareBracket ) - // InternalBehaviorAnnexParser.g:11478:2: LeftSquareBracket + // InternalBehaviorAnnexParser.g:11504:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:11505:2: LeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getArrayIndexAccess().getLeftSquareBracketKeyword_0()); @@ -38329,14 +38424,14 @@ public final void rule__ArrayIndex__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__ArrayIndex__Group__1" - // InternalBehaviorAnnexParser.g:11487:1: rule__ArrayIndex__Group__1 : rule__ArrayIndex__Group__1__Impl rule__ArrayIndex__Group__2 ; + // InternalBehaviorAnnexParser.g:11514:1: rule__ArrayIndex__Group__1 : rule__ArrayIndex__Group__1__Impl rule__ArrayIndex__Group__2 ; public final void rule__ArrayIndex__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11491:1: ( rule__ArrayIndex__Group__1__Impl rule__ArrayIndex__Group__2 ) - // InternalBehaviorAnnexParser.g:11492:2: rule__ArrayIndex__Group__1__Impl rule__ArrayIndex__Group__2 + // InternalBehaviorAnnexParser.g:11518:1: ( rule__ArrayIndex__Group__1__Impl rule__ArrayIndex__Group__2 ) + // InternalBehaviorAnnexParser.g:11519:2: rule__ArrayIndex__Group__1__Impl rule__ArrayIndex__Group__2 { pushFollow(FollowSets000.FOLLOW_14); rule__ArrayIndex__Group__1__Impl(); @@ -38367,23 +38462,23 @@ public final void rule__ArrayIndex__Group__1() throws RecognitionException { // $ANTLR start "rule__ArrayIndex__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11499:1: rule__ArrayIndex__Group__1__Impl : ( ( rule__ArrayIndex__ValueAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:11526:1: rule__ArrayIndex__Group__1__Impl : ( ( rule__ArrayIndex__ValueAssignment_1 ) ) ; public final void rule__ArrayIndex__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11503:1: ( ( ( rule__ArrayIndex__ValueAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:11504:1: ( ( rule__ArrayIndex__ValueAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11530:1: ( ( ( rule__ArrayIndex__ValueAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:11531:1: ( ( rule__ArrayIndex__ValueAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:11504:1: ( ( rule__ArrayIndex__ValueAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:11505:2: ( rule__ArrayIndex__ValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:11531:1: ( ( rule__ArrayIndex__ValueAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11532:2: ( rule__ArrayIndex__ValueAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getArrayIndexAccess().getValueAssignment_1()); } - // InternalBehaviorAnnexParser.g:11506:2: ( rule__ArrayIndex__ValueAssignment_1 ) - // InternalBehaviorAnnexParser.g:11506:3: rule__ArrayIndex__ValueAssignment_1 + // InternalBehaviorAnnexParser.g:11533:2: ( rule__ArrayIndex__ValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:11533:3: rule__ArrayIndex__ValueAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayIndex__ValueAssignment_1(); @@ -38418,14 +38513,14 @@ public final void rule__ArrayIndex__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__ArrayIndex__Group__2" - // InternalBehaviorAnnexParser.g:11514:1: rule__ArrayIndex__Group__2 : rule__ArrayIndex__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:11541:1: rule__ArrayIndex__Group__2 : rule__ArrayIndex__Group__2__Impl ; public final void rule__ArrayIndex__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11518:1: ( rule__ArrayIndex__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:11519:2: rule__ArrayIndex__Group__2__Impl + // InternalBehaviorAnnexParser.g:11545:1: ( rule__ArrayIndex__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:11546:2: rule__ArrayIndex__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayIndex__Group__2__Impl(); @@ -38451,17 +38546,17 @@ public final void rule__ArrayIndex__Group__2() throws RecognitionException { // $ANTLR start "rule__ArrayIndex__Group__2__Impl" - // InternalBehaviorAnnexParser.g:11525:1: rule__ArrayIndex__Group__2__Impl : ( RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:11552:1: rule__ArrayIndex__Group__2__Impl : ( RightSquareBracket ) ; public final void rule__ArrayIndex__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11529:1: ( ( RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:11530:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:11556:1: ( ( RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:11557:1: ( RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:11530:1: ( RightSquareBracket ) - // InternalBehaviorAnnexParser.g:11531:2: RightSquareBracket + // InternalBehaviorAnnexParser.g:11557:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:11558:2: RightSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getArrayIndexAccess().getRightSquareBracketKeyword_2()); @@ -38492,14 +38587,14 @@ public final void rule__ArrayIndex__Group__2__Impl() throws RecognitionException // $ANTLR start "rule__ContainedPropertyAssociation__Group__0" - // InternalBehaviorAnnexParser.g:11541:1: rule__ContainedPropertyAssociation__Group__0 : rule__ContainedPropertyAssociation__Group__0__Impl rule__ContainedPropertyAssociation__Group__1 ; + // InternalBehaviorAnnexParser.g:11568:1: rule__ContainedPropertyAssociation__Group__0 : rule__ContainedPropertyAssociation__Group__0__Impl rule__ContainedPropertyAssociation__Group__1 ; public final void rule__ContainedPropertyAssociation__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11545:1: ( rule__ContainedPropertyAssociation__Group__0__Impl rule__ContainedPropertyAssociation__Group__1 ) - // InternalBehaviorAnnexParser.g:11546:2: rule__ContainedPropertyAssociation__Group__0__Impl rule__ContainedPropertyAssociation__Group__1 + // InternalBehaviorAnnexParser.g:11572:1: ( rule__ContainedPropertyAssociation__Group__0__Impl rule__ContainedPropertyAssociation__Group__1 ) + // InternalBehaviorAnnexParser.g:11573:2: rule__ContainedPropertyAssociation__Group__0__Impl rule__ContainedPropertyAssociation__Group__1 { pushFollow(FollowSets000.FOLLOW_80); rule__ContainedPropertyAssociation__Group__0__Impl(); @@ -38530,23 +38625,23 @@ public final void rule__ContainedPropertyAssociation__Group__0() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11553:1: rule__ContainedPropertyAssociation__Group__0__Impl : ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11580:1: rule__ContainedPropertyAssociation__Group__0__Impl : ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) ; public final void rule__ContainedPropertyAssociation__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11557:1: ( ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11558:1: ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11584:1: ( ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11585:1: ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11558:1: ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11559:2: ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) + // InternalBehaviorAnnexParser.g:11585:1: ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11586:2: ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getPropertyAssignment_0()); } - // InternalBehaviorAnnexParser.g:11560:2: ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) - // InternalBehaviorAnnexParser.g:11560:3: rule__ContainedPropertyAssociation__PropertyAssignment_0 + // InternalBehaviorAnnexParser.g:11587:2: ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) + // InternalBehaviorAnnexParser.g:11587:3: rule__ContainedPropertyAssociation__PropertyAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__PropertyAssignment_0(); @@ -38581,14 +38676,14 @@ public final void rule__ContainedPropertyAssociation__Group__0__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__1" - // InternalBehaviorAnnexParser.g:11568:1: rule__ContainedPropertyAssociation__Group__1 : rule__ContainedPropertyAssociation__Group__1__Impl rule__ContainedPropertyAssociation__Group__2 ; + // InternalBehaviorAnnexParser.g:11595:1: rule__ContainedPropertyAssociation__Group__1 : rule__ContainedPropertyAssociation__Group__1__Impl rule__ContainedPropertyAssociation__Group__2 ; public final void rule__ContainedPropertyAssociation__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11572:1: ( rule__ContainedPropertyAssociation__Group__1__Impl rule__ContainedPropertyAssociation__Group__2 ) - // InternalBehaviorAnnexParser.g:11573:2: rule__ContainedPropertyAssociation__Group__1__Impl rule__ContainedPropertyAssociation__Group__2 + // InternalBehaviorAnnexParser.g:11599:1: ( rule__ContainedPropertyAssociation__Group__1__Impl rule__ContainedPropertyAssociation__Group__2 ) + // InternalBehaviorAnnexParser.g:11600:2: rule__ContainedPropertyAssociation__Group__1__Impl rule__ContainedPropertyAssociation__Group__2 { pushFollow(FollowSets000.FOLLOW_81); rule__ContainedPropertyAssociation__Group__1__Impl(); @@ -38619,23 +38714,23 @@ public final void rule__ContainedPropertyAssociation__Group__1() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11580:1: rule__ContainedPropertyAssociation__Group__1__Impl : ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) ; + // InternalBehaviorAnnexParser.g:11607:1: rule__ContainedPropertyAssociation__Group__1__Impl : ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) ; public final void rule__ContainedPropertyAssociation__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11584:1: ( ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) ) - // InternalBehaviorAnnexParser.g:11585:1: ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:11611:1: ( ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) ) + // InternalBehaviorAnnexParser.g:11612:1: ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) { - // InternalBehaviorAnnexParser.g:11585:1: ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) - // InternalBehaviorAnnexParser.g:11586:2: ( rule__ContainedPropertyAssociation__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:11612:1: ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:11613:2: ( rule__ContainedPropertyAssociation__Alternatives_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:11587:2: ( rule__ContainedPropertyAssociation__Alternatives_1 ) - // InternalBehaviorAnnexParser.g:11587:3: rule__ContainedPropertyAssociation__Alternatives_1 + // InternalBehaviorAnnexParser.g:11614:2: ( rule__ContainedPropertyAssociation__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:11614:3: rule__ContainedPropertyAssociation__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Alternatives_1(); @@ -38670,14 +38765,14 @@ public final void rule__ContainedPropertyAssociation__Group__1__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__2" - // InternalBehaviorAnnexParser.g:11595:1: rule__ContainedPropertyAssociation__Group__2 : rule__ContainedPropertyAssociation__Group__2__Impl rule__ContainedPropertyAssociation__Group__3 ; + // InternalBehaviorAnnexParser.g:11622:1: rule__ContainedPropertyAssociation__Group__2 : rule__ContainedPropertyAssociation__Group__2__Impl rule__ContainedPropertyAssociation__Group__3 ; public final void rule__ContainedPropertyAssociation__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11599:1: ( rule__ContainedPropertyAssociation__Group__2__Impl rule__ContainedPropertyAssociation__Group__3 ) - // InternalBehaviorAnnexParser.g:11600:2: rule__ContainedPropertyAssociation__Group__2__Impl rule__ContainedPropertyAssociation__Group__3 + // InternalBehaviorAnnexParser.g:11626:1: ( rule__ContainedPropertyAssociation__Group__2__Impl rule__ContainedPropertyAssociation__Group__3 ) + // InternalBehaviorAnnexParser.g:11627:2: rule__ContainedPropertyAssociation__Group__2__Impl rule__ContainedPropertyAssociation__Group__3 { pushFollow(FollowSets000.FOLLOW_81); rule__ContainedPropertyAssociation__Group__2__Impl(); @@ -38708,31 +38803,31 @@ public final void rule__ContainedPropertyAssociation__Group__2() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__2__Impl" - // InternalBehaviorAnnexParser.g:11607:1: rule__ContainedPropertyAssociation__Group__2__Impl : ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) ; + // InternalBehaviorAnnexParser.g:11634:1: rule__ContainedPropertyAssociation__Group__2__Impl : ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) ; public final void rule__ContainedPropertyAssociation__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11611:1: ( ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) ) - // InternalBehaviorAnnexParser.g:11612:1: ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) + // InternalBehaviorAnnexParser.g:11638:1: ( ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) ) + // InternalBehaviorAnnexParser.g:11639:1: ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) { - // InternalBehaviorAnnexParser.g:11612:1: ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) - // InternalBehaviorAnnexParser.g:11613:2: ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? + // InternalBehaviorAnnexParser.g:11639:1: ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) + // InternalBehaviorAnnexParser.g:11640:2: ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getConstantAssignment_2()); } - // InternalBehaviorAnnexParser.g:11614:2: ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? - int alt101=2; - int LA101_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:11641:2: ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? + int alt102=2; + int LA102_0 = input.LA(1); - if ( (LA101_0==Constant) ) { - alt101=1; + if ( (LA102_0==Constant) ) { + alt102=1; } - switch (alt101) { + switch (alt102) { case 1 : - // InternalBehaviorAnnexParser.g:11614:3: rule__ContainedPropertyAssociation__ConstantAssignment_2 + // InternalBehaviorAnnexParser.g:11641:3: rule__ContainedPropertyAssociation__ConstantAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__ConstantAssignment_2(); @@ -38770,14 +38865,14 @@ public final void rule__ContainedPropertyAssociation__Group__2__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__3" - // InternalBehaviorAnnexParser.g:11622:1: rule__ContainedPropertyAssociation__Group__3 : rule__ContainedPropertyAssociation__Group__3__Impl rule__ContainedPropertyAssociation__Group__4 ; + // InternalBehaviorAnnexParser.g:11649:1: rule__ContainedPropertyAssociation__Group__3 : rule__ContainedPropertyAssociation__Group__3__Impl rule__ContainedPropertyAssociation__Group__4 ; public final void rule__ContainedPropertyAssociation__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11626:1: ( rule__ContainedPropertyAssociation__Group__3__Impl rule__ContainedPropertyAssociation__Group__4 ) - // InternalBehaviorAnnexParser.g:11627:2: rule__ContainedPropertyAssociation__Group__3__Impl rule__ContainedPropertyAssociation__Group__4 + // InternalBehaviorAnnexParser.g:11653:1: ( rule__ContainedPropertyAssociation__Group__3__Impl rule__ContainedPropertyAssociation__Group__4 ) + // InternalBehaviorAnnexParser.g:11654:2: rule__ContainedPropertyAssociation__Group__3__Impl rule__ContainedPropertyAssociation__Group__4 { pushFollow(FollowSets000.FOLLOW_82); rule__ContainedPropertyAssociation__Group__3__Impl(); @@ -38808,23 +38903,23 @@ public final void rule__ContainedPropertyAssociation__Group__3() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__3__Impl" - // InternalBehaviorAnnexParser.g:11634:1: rule__ContainedPropertyAssociation__Group__3__Impl : ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) ; + // InternalBehaviorAnnexParser.g:11661:1: rule__ContainedPropertyAssociation__Group__3__Impl : ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) ; public final void rule__ContainedPropertyAssociation__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11638:1: ( ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) ) - // InternalBehaviorAnnexParser.g:11639:1: ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) + // InternalBehaviorAnnexParser.g:11665:1: ( ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) ) + // InternalBehaviorAnnexParser.g:11666:1: ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) { - // InternalBehaviorAnnexParser.g:11639:1: ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) - // InternalBehaviorAnnexParser.g:11640:2: ( rule__ContainedPropertyAssociation__Group_3__0 ) + // InternalBehaviorAnnexParser.g:11666:1: ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) + // InternalBehaviorAnnexParser.g:11667:2: ( rule__ContainedPropertyAssociation__Group_3__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup_3()); } - // InternalBehaviorAnnexParser.g:11641:2: ( rule__ContainedPropertyAssociation__Group_3__0 ) - // InternalBehaviorAnnexParser.g:11641:3: rule__ContainedPropertyAssociation__Group_3__0 + // InternalBehaviorAnnexParser.g:11668:2: ( rule__ContainedPropertyAssociation__Group_3__0 ) + // InternalBehaviorAnnexParser.g:11668:3: rule__ContainedPropertyAssociation__Group_3__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_3__0(); @@ -38859,14 +38954,14 @@ public final void rule__ContainedPropertyAssociation__Group__3__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__4" - // InternalBehaviorAnnexParser.g:11649:1: rule__ContainedPropertyAssociation__Group__4 : rule__ContainedPropertyAssociation__Group__4__Impl rule__ContainedPropertyAssociation__Group__5 ; + // InternalBehaviorAnnexParser.g:11676:1: rule__ContainedPropertyAssociation__Group__4 : rule__ContainedPropertyAssociation__Group__4__Impl rule__ContainedPropertyAssociation__Group__5 ; public final void rule__ContainedPropertyAssociation__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11653:1: ( rule__ContainedPropertyAssociation__Group__4__Impl rule__ContainedPropertyAssociation__Group__5 ) - // InternalBehaviorAnnexParser.g:11654:2: rule__ContainedPropertyAssociation__Group__4__Impl rule__ContainedPropertyAssociation__Group__5 + // InternalBehaviorAnnexParser.g:11680:1: ( rule__ContainedPropertyAssociation__Group__4__Impl rule__ContainedPropertyAssociation__Group__5 ) + // InternalBehaviorAnnexParser.g:11681:2: rule__ContainedPropertyAssociation__Group__4__Impl rule__ContainedPropertyAssociation__Group__5 { pushFollow(FollowSets000.FOLLOW_82); rule__ContainedPropertyAssociation__Group__4__Impl(); @@ -38897,31 +38992,31 @@ public final void rule__ContainedPropertyAssociation__Group__4() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__4__Impl" - // InternalBehaviorAnnexParser.g:11661:1: rule__ContainedPropertyAssociation__Group__4__Impl : ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) ; + // InternalBehaviorAnnexParser.g:11688:1: rule__ContainedPropertyAssociation__Group__4__Impl : ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) ; public final void rule__ContainedPropertyAssociation__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11665:1: ( ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) ) - // InternalBehaviorAnnexParser.g:11666:1: ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) + // InternalBehaviorAnnexParser.g:11692:1: ( ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) ) + // InternalBehaviorAnnexParser.g:11693:1: ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) { - // InternalBehaviorAnnexParser.g:11666:1: ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) - // InternalBehaviorAnnexParser.g:11667:2: ( rule__ContainedPropertyAssociation__Group_4__0 )? + // InternalBehaviorAnnexParser.g:11693:1: ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) + // InternalBehaviorAnnexParser.g:11694:2: ( rule__ContainedPropertyAssociation__Group_4__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup_4()); } - // InternalBehaviorAnnexParser.g:11668:2: ( rule__ContainedPropertyAssociation__Group_4__0 )? - int alt102=2; - int LA102_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:11695:2: ( rule__ContainedPropertyAssociation__Group_4__0 )? + int alt103=2; + int LA103_0 = input.LA(1); - if ( (LA102_0==Applies) ) { - alt102=1; + if ( (LA103_0==Applies) ) { + alt103=1; } - switch (alt102) { + switch (alt103) { case 1 : - // InternalBehaviorAnnexParser.g:11668:3: rule__ContainedPropertyAssociation__Group_4__0 + // InternalBehaviorAnnexParser.g:11695:3: rule__ContainedPropertyAssociation__Group_4__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_4__0(); @@ -38959,14 +39054,14 @@ public final void rule__ContainedPropertyAssociation__Group__4__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__5" - // InternalBehaviorAnnexParser.g:11676:1: rule__ContainedPropertyAssociation__Group__5 : rule__ContainedPropertyAssociation__Group__5__Impl rule__ContainedPropertyAssociation__Group__6 ; + // InternalBehaviorAnnexParser.g:11703:1: rule__ContainedPropertyAssociation__Group__5 : rule__ContainedPropertyAssociation__Group__5__Impl rule__ContainedPropertyAssociation__Group__6 ; public final void rule__ContainedPropertyAssociation__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11680:1: ( rule__ContainedPropertyAssociation__Group__5__Impl rule__ContainedPropertyAssociation__Group__6 ) - // InternalBehaviorAnnexParser.g:11681:2: rule__ContainedPropertyAssociation__Group__5__Impl rule__ContainedPropertyAssociation__Group__6 + // InternalBehaviorAnnexParser.g:11707:1: ( rule__ContainedPropertyAssociation__Group__5__Impl rule__ContainedPropertyAssociation__Group__6 ) + // InternalBehaviorAnnexParser.g:11708:2: rule__ContainedPropertyAssociation__Group__5__Impl rule__ContainedPropertyAssociation__Group__6 { pushFollow(FollowSets000.FOLLOW_82); rule__ContainedPropertyAssociation__Group__5__Impl(); @@ -38997,31 +39092,31 @@ public final void rule__ContainedPropertyAssociation__Group__5() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__5__Impl" - // InternalBehaviorAnnexParser.g:11688:1: rule__ContainedPropertyAssociation__Group__5__Impl : ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) ; + // InternalBehaviorAnnexParser.g:11715:1: rule__ContainedPropertyAssociation__Group__5__Impl : ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) ; public final void rule__ContainedPropertyAssociation__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11692:1: ( ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) ) - // InternalBehaviorAnnexParser.g:11693:1: ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) + // InternalBehaviorAnnexParser.g:11719:1: ( ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) ) + // InternalBehaviorAnnexParser.g:11720:1: ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) { - // InternalBehaviorAnnexParser.g:11693:1: ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) - // InternalBehaviorAnnexParser.g:11694:2: ( rule__ContainedPropertyAssociation__Group_5__0 )? + // InternalBehaviorAnnexParser.g:11720:1: ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) + // InternalBehaviorAnnexParser.g:11721:2: ( rule__ContainedPropertyAssociation__Group_5__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup_5()); } - // InternalBehaviorAnnexParser.g:11695:2: ( rule__ContainedPropertyAssociation__Group_5__0 )? - int alt103=2; - int LA103_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:11722:2: ( rule__ContainedPropertyAssociation__Group_5__0 )? + int alt104=2; + int LA104_0 = input.LA(1); - if ( (LA103_0==In) ) { - alt103=1; + if ( (LA104_0==In) ) { + alt104=1; } - switch (alt103) { + switch (alt104) { case 1 : - // InternalBehaviorAnnexParser.g:11695:3: rule__ContainedPropertyAssociation__Group_5__0 + // InternalBehaviorAnnexParser.g:11722:3: rule__ContainedPropertyAssociation__Group_5__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_5__0(); @@ -39059,14 +39154,14 @@ public final void rule__ContainedPropertyAssociation__Group__5__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__6" - // InternalBehaviorAnnexParser.g:11703:1: rule__ContainedPropertyAssociation__Group__6 : rule__ContainedPropertyAssociation__Group__6__Impl ; + // InternalBehaviorAnnexParser.g:11730:1: rule__ContainedPropertyAssociation__Group__6 : rule__ContainedPropertyAssociation__Group__6__Impl ; public final void rule__ContainedPropertyAssociation__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11707:1: ( rule__ContainedPropertyAssociation__Group__6__Impl ) - // InternalBehaviorAnnexParser.g:11708:2: rule__ContainedPropertyAssociation__Group__6__Impl + // InternalBehaviorAnnexParser.g:11734:1: ( rule__ContainedPropertyAssociation__Group__6__Impl ) + // InternalBehaviorAnnexParser.g:11735:2: rule__ContainedPropertyAssociation__Group__6__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group__6__Impl(); @@ -39092,17 +39187,17 @@ public final void rule__ContainedPropertyAssociation__Group__6() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__6__Impl" - // InternalBehaviorAnnexParser.g:11714:1: rule__ContainedPropertyAssociation__Group__6__Impl : ( Semicolon ) ; + // InternalBehaviorAnnexParser.g:11741:1: rule__ContainedPropertyAssociation__Group__6__Impl : ( Semicolon ) ; public final void rule__ContainedPropertyAssociation__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11718:1: ( ( Semicolon ) ) - // InternalBehaviorAnnexParser.g:11719:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:11745:1: ( ( Semicolon ) ) + // InternalBehaviorAnnexParser.g:11746:1: ( Semicolon ) { - // InternalBehaviorAnnexParser.g:11719:1: ( Semicolon ) - // InternalBehaviorAnnexParser.g:11720:2: Semicolon + // InternalBehaviorAnnexParser.g:11746:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:11747:2: Semicolon { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getSemicolonKeyword_6()); @@ -39133,14 +39228,14 @@ public final void rule__ContainedPropertyAssociation__Group__6__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group_3__0" - // InternalBehaviorAnnexParser.g:11730:1: rule__ContainedPropertyAssociation__Group_3__0 : rule__ContainedPropertyAssociation__Group_3__0__Impl rule__ContainedPropertyAssociation__Group_3__1 ; + // InternalBehaviorAnnexParser.g:11757:1: rule__ContainedPropertyAssociation__Group_3__0 : rule__ContainedPropertyAssociation__Group_3__0__Impl rule__ContainedPropertyAssociation__Group_3__1 ; public final void rule__ContainedPropertyAssociation__Group_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11734:1: ( rule__ContainedPropertyAssociation__Group_3__0__Impl rule__ContainedPropertyAssociation__Group_3__1 ) - // InternalBehaviorAnnexParser.g:11735:2: rule__ContainedPropertyAssociation__Group_3__0__Impl rule__ContainedPropertyAssociation__Group_3__1 + // InternalBehaviorAnnexParser.g:11761:1: ( rule__ContainedPropertyAssociation__Group_3__0__Impl rule__ContainedPropertyAssociation__Group_3__1 ) + // InternalBehaviorAnnexParser.g:11762:2: rule__ContainedPropertyAssociation__Group_3__0__Impl rule__ContainedPropertyAssociation__Group_3__1 { pushFollow(FollowSets000.FOLLOW_83); rule__ContainedPropertyAssociation__Group_3__0__Impl(); @@ -39171,23 +39266,23 @@ public final void rule__ContainedPropertyAssociation__Group_3__0() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_3__0__Impl" - // InternalBehaviorAnnexParser.g:11742:1: rule__ContainedPropertyAssociation__Group_3__0__Impl : ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) ; + // InternalBehaviorAnnexParser.g:11769:1: rule__ContainedPropertyAssociation__Group_3__0__Impl : ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) ; public final void rule__ContainedPropertyAssociation__Group_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11746:1: ( ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) ) - // InternalBehaviorAnnexParser.g:11747:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) + // InternalBehaviorAnnexParser.g:11773:1: ( ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) ) + // InternalBehaviorAnnexParser.g:11774:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) { - // InternalBehaviorAnnexParser.g:11747:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) - // InternalBehaviorAnnexParser.g:11748:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) + // InternalBehaviorAnnexParser.g:11774:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) + // InternalBehaviorAnnexParser.g:11775:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueAssignment_3_0()); } - // InternalBehaviorAnnexParser.g:11749:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) - // InternalBehaviorAnnexParser.g:11749:3: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 + // InternalBehaviorAnnexParser.g:11776:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) + // InternalBehaviorAnnexParser.g:11776:3: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0(); @@ -39222,14 +39317,14 @@ public final void rule__ContainedPropertyAssociation__Group_3__0__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_3__1" - // InternalBehaviorAnnexParser.g:11757:1: rule__ContainedPropertyAssociation__Group_3__1 : rule__ContainedPropertyAssociation__Group_3__1__Impl ; + // InternalBehaviorAnnexParser.g:11784:1: rule__ContainedPropertyAssociation__Group_3__1 : rule__ContainedPropertyAssociation__Group_3__1__Impl ; public final void rule__ContainedPropertyAssociation__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11761:1: ( rule__ContainedPropertyAssociation__Group_3__1__Impl ) - // InternalBehaviorAnnexParser.g:11762:2: rule__ContainedPropertyAssociation__Group_3__1__Impl + // InternalBehaviorAnnexParser.g:11788:1: ( rule__ContainedPropertyAssociation__Group_3__1__Impl ) + // InternalBehaviorAnnexParser.g:11789:2: rule__ContainedPropertyAssociation__Group_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_3__1__Impl(); @@ -39255,35 +39350,35 @@ public final void rule__ContainedPropertyAssociation__Group_3__1() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_3__1__Impl" - // InternalBehaviorAnnexParser.g:11768:1: rule__ContainedPropertyAssociation__Group_3__1__Impl : ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:11795:1: rule__ContainedPropertyAssociation__Group_3__1__Impl : ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) ; public final void rule__ContainedPropertyAssociation__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11772:1: ( ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:11773:1: ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) + // InternalBehaviorAnnexParser.g:11799:1: ( ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:11800:1: ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) { - // InternalBehaviorAnnexParser.g:11773:1: ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) - // InternalBehaviorAnnexParser.g:11774:2: ( rule__ContainedPropertyAssociation__Group_3_1__0 )* + // InternalBehaviorAnnexParser.g:11800:1: ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) + // InternalBehaviorAnnexParser.g:11801:2: ( rule__ContainedPropertyAssociation__Group_3_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup_3_1()); } - // InternalBehaviorAnnexParser.g:11775:2: ( rule__ContainedPropertyAssociation__Group_3_1__0 )* - loop104: + // InternalBehaviorAnnexParser.g:11802:2: ( rule__ContainedPropertyAssociation__Group_3_1__0 )* + loop105: do { - int alt104=2; - int LA104_0 = input.LA(1); + int alt105=2; + int LA105_0 = input.LA(1); - if ( (LA104_0==Comma) ) { - alt104=1; + if ( (LA105_0==Comma) ) { + alt105=1; } - switch (alt104) { + switch (alt105) { case 1 : - // InternalBehaviorAnnexParser.g:11775:3: rule__ContainedPropertyAssociation__Group_3_1__0 + // InternalBehaviorAnnexParser.g:11802:3: rule__ContainedPropertyAssociation__Group_3_1__0 { pushFollow(FollowSets000.FOLLOW_7); rule__ContainedPropertyAssociation__Group_3_1__0(); @@ -39295,7 +39390,7 @@ public final void rule__ContainedPropertyAssociation__Group_3__1__Impl() throws break; default : - break loop104; + break loop105; } } while (true); @@ -39324,14 +39419,14 @@ public final void rule__ContainedPropertyAssociation__Group_3__1__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_3_1__0" - // InternalBehaviorAnnexParser.g:11784:1: rule__ContainedPropertyAssociation__Group_3_1__0 : rule__ContainedPropertyAssociation__Group_3_1__0__Impl rule__ContainedPropertyAssociation__Group_3_1__1 ; + // InternalBehaviorAnnexParser.g:11811:1: rule__ContainedPropertyAssociation__Group_3_1__0 : rule__ContainedPropertyAssociation__Group_3_1__0__Impl rule__ContainedPropertyAssociation__Group_3_1__1 ; public final void rule__ContainedPropertyAssociation__Group_3_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11788:1: ( rule__ContainedPropertyAssociation__Group_3_1__0__Impl rule__ContainedPropertyAssociation__Group_3_1__1 ) - // InternalBehaviorAnnexParser.g:11789:2: rule__ContainedPropertyAssociation__Group_3_1__0__Impl rule__ContainedPropertyAssociation__Group_3_1__1 + // InternalBehaviorAnnexParser.g:11815:1: ( rule__ContainedPropertyAssociation__Group_3_1__0__Impl rule__ContainedPropertyAssociation__Group_3_1__1 ) + // InternalBehaviorAnnexParser.g:11816:2: rule__ContainedPropertyAssociation__Group_3_1__0__Impl rule__ContainedPropertyAssociation__Group_3_1__1 { pushFollow(FollowSets000.FOLLOW_81); rule__ContainedPropertyAssociation__Group_3_1__0__Impl(); @@ -39362,17 +39457,17 @@ public final void rule__ContainedPropertyAssociation__Group_3_1__0() throws Reco // $ANTLR start "rule__ContainedPropertyAssociation__Group_3_1__0__Impl" - // InternalBehaviorAnnexParser.g:11796:1: rule__ContainedPropertyAssociation__Group_3_1__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:11823:1: rule__ContainedPropertyAssociation__Group_3_1__0__Impl : ( Comma ) ; public final void rule__ContainedPropertyAssociation__Group_3_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11800:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:11801:1: ( Comma ) + // InternalBehaviorAnnexParser.g:11827:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:11828:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:11801:1: ( Comma ) - // InternalBehaviorAnnexParser.g:11802:2: Comma + // InternalBehaviorAnnexParser.g:11828:1: ( Comma ) + // InternalBehaviorAnnexParser.g:11829:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getCommaKeyword_3_1_0()); @@ -39403,14 +39498,14 @@ public final void rule__ContainedPropertyAssociation__Group_3_1__0__Impl() throw // $ANTLR start "rule__ContainedPropertyAssociation__Group_3_1__1" - // InternalBehaviorAnnexParser.g:11811:1: rule__ContainedPropertyAssociation__Group_3_1__1 : rule__ContainedPropertyAssociation__Group_3_1__1__Impl ; + // InternalBehaviorAnnexParser.g:11838:1: rule__ContainedPropertyAssociation__Group_3_1__1 : rule__ContainedPropertyAssociation__Group_3_1__1__Impl ; public final void rule__ContainedPropertyAssociation__Group_3_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11815:1: ( rule__ContainedPropertyAssociation__Group_3_1__1__Impl ) - // InternalBehaviorAnnexParser.g:11816:2: rule__ContainedPropertyAssociation__Group_3_1__1__Impl + // InternalBehaviorAnnexParser.g:11842:1: ( rule__ContainedPropertyAssociation__Group_3_1__1__Impl ) + // InternalBehaviorAnnexParser.g:11843:2: rule__ContainedPropertyAssociation__Group_3_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_3_1__1__Impl(); @@ -39436,23 +39531,23 @@ public final void rule__ContainedPropertyAssociation__Group_3_1__1() throws Reco // $ANTLR start "rule__ContainedPropertyAssociation__Group_3_1__1__Impl" - // InternalBehaviorAnnexParser.g:11822:1: rule__ContainedPropertyAssociation__Group_3_1__1__Impl : ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:11849:1: rule__ContainedPropertyAssociation__Group_3_1__1__Impl : ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) ; public final void rule__ContainedPropertyAssociation__Group_3_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11826:1: ( ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:11827:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) + // InternalBehaviorAnnexParser.g:11853:1: ( ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:11854:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) { - // InternalBehaviorAnnexParser.g:11827:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) - // InternalBehaviorAnnexParser.g:11828:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) + // InternalBehaviorAnnexParser.g:11854:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) + // InternalBehaviorAnnexParser.g:11855:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueAssignment_3_1_1()); } - // InternalBehaviorAnnexParser.g:11829:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) - // InternalBehaviorAnnexParser.g:11829:3: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 + // InternalBehaviorAnnexParser.g:11856:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) + // InternalBehaviorAnnexParser.g:11856:3: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1(); @@ -39487,14 +39582,14 @@ public final void rule__ContainedPropertyAssociation__Group_3_1__1__Impl() throw // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__0" - // InternalBehaviorAnnexParser.g:11838:1: rule__ContainedPropertyAssociation__Group_4__0 : rule__ContainedPropertyAssociation__Group_4__0__Impl rule__ContainedPropertyAssociation__Group_4__1 ; + // InternalBehaviorAnnexParser.g:11865:1: rule__ContainedPropertyAssociation__Group_4__0 : rule__ContainedPropertyAssociation__Group_4__0__Impl rule__ContainedPropertyAssociation__Group_4__1 ; public final void rule__ContainedPropertyAssociation__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11842:1: ( rule__ContainedPropertyAssociation__Group_4__0__Impl rule__ContainedPropertyAssociation__Group_4__1 ) - // InternalBehaviorAnnexParser.g:11843:2: rule__ContainedPropertyAssociation__Group_4__0__Impl rule__ContainedPropertyAssociation__Group_4__1 + // InternalBehaviorAnnexParser.g:11869:1: ( rule__ContainedPropertyAssociation__Group_4__0__Impl rule__ContainedPropertyAssociation__Group_4__1 ) + // InternalBehaviorAnnexParser.g:11870:2: rule__ContainedPropertyAssociation__Group_4__0__Impl rule__ContainedPropertyAssociation__Group_4__1 { pushFollow(FollowSets000.FOLLOW_84); rule__ContainedPropertyAssociation__Group_4__0__Impl(); @@ -39525,17 +39620,17 @@ public final void rule__ContainedPropertyAssociation__Group_4__0() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__0__Impl" - // InternalBehaviorAnnexParser.g:11850:1: rule__ContainedPropertyAssociation__Group_4__0__Impl : ( Applies ) ; + // InternalBehaviorAnnexParser.g:11877:1: rule__ContainedPropertyAssociation__Group_4__0__Impl : ( Applies ) ; public final void rule__ContainedPropertyAssociation__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11854:1: ( ( Applies ) ) - // InternalBehaviorAnnexParser.g:11855:1: ( Applies ) + // InternalBehaviorAnnexParser.g:11881:1: ( ( Applies ) ) + // InternalBehaviorAnnexParser.g:11882:1: ( Applies ) { - // InternalBehaviorAnnexParser.g:11855:1: ( Applies ) - // InternalBehaviorAnnexParser.g:11856:2: Applies + // InternalBehaviorAnnexParser.g:11882:1: ( Applies ) + // InternalBehaviorAnnexParser.g:11883:2: Applies { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppliesKeyword_4_0()); @@ -39566,14 +39661,14 @@ public final void rule__ContainedPropertyAssociation__Group_4__0__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__1" - // InternalBehaviorAnnexParser.g:11865:1: rule__ContainedPropertyAssociation__Group_4__1 : rule__ContainedPropertyAssociation__Group_4__1__Impl rule__ContainedPropertyAssociation__Group_4__2 ; + // InternalBehaviorAnnexParser.g:11892:1: rule__ContainedPropertyAssociation__Group_4__1 : rule__ContainedPropertyAssociation__Group_4__1__Impl rule__ContainedPropertyAssociation__Group_4__2 ; public final void rule__ContainedPropertyAssociation__Group_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11869:1: ( rule__ContainedPropertyAssociation__Group_4__1__Impl rule__ContainedPropertyAssociation__Group_4__2 ) - // InternalBehaviorAnnexParser.g:11870:2: rule__ContainedPropertyAssociation__Group_4__1__Impl rule__ContainedPropertyAssociation__Group_4__2 + // InternalBehaviorAnnexParser.g:11896:1: ( rule__ContainedPropertyAssociation__Group_4__1__Impl rule__ContainedPropertyAssociation__Group_4__2 ) + // InternalBehaviorAnnexParser.g:11897:2: rule__ContainedPropertyAssociation__Group_4__1__Impl rule__ContainedPropertyAssociation__Group_4__2 { pushFollow(FollowSets000.FOLLOW_4); rule__ContainedPropertyAssociation__Group_4__1__Impl(); @@ -39604,17 +39699,17 @@ public final void rule__ContainedPropertyAssociation__Group_4__1() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__1__Impl" - // InternalBehaviorAnnexParser.g:11877:1: rule__ContainedPropertyAssociation__Group_4__1__Impl : ( To ) ; + // InternalBehaviorAnnexParser.g:11904:1: rule__ContainedPropertyAssociation__Group_4__1__Impl : ( To ) ; public final void rule__ContainedPropertyAssociation__Group_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11881:1: ( ( To ) ) - // InternalBehaviorAnnexParser.g:11882:1: ( To ) + // InternalBehaviorAnnexParser.g:11908:1: ( ( To ) ) + // InternalBehaviorAnnexParser.g:11909:1: ( To ) { - // InternalBehaviorAnnexParser.g:11882:1: ( To ) - // InternalBehaviorAnnexParser.g:11883:2: To + // InternalBehaviorAnnexParser.g:11909:1: ( To ) + // InternalBehaviorAnnexParser.g:11910:2: To { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getToKeyword_4_1()); @@ -39645,14 +39740,14 @@ public final void rule__ContainedPropertyAssociation__Group_4__1__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__2" - // InternalBehaviorAnnexParser.g:11892:1: rule__ContainedPropertyAssociation__Group_4__2 : rule__ContainedPropertyAssociation__Group_4__2__Impl rule__ContainedPropertyAssociation__Group_4__3 ; + // InternalBehaviorAnnexParser.g:11919:1: rule__ContainedPropertyAssociation__Group_4__2 : rule__ContainedPropertyAssociation__Group_4__2__Impl rule__ContainedPropertyAssociation__Group_4__3 ; public final void rule__ContainedPropertyAssociation__Group_4__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11896:1: ( rule__ContainedPropertyAssociation__Group_4__2__Impl rule__ContainedPropertyAssociation__Group_4__3 ) - // InternalBehaviorAnnexParser.g:11897:2: rule__ContainedPropertyAssociation__Group_4__2__Impl rule__ContainedPropertyAssociation__Group_4__3 + // InternalBehaviorAnnexParser.g:11923:1: ( rule__ContainedPropertyAssociation__Group_4__2__Impl rule__ContainedPropertyAssociation__Group_4__3 ) + // InternalBehaviorAnnexParser.g:11924:2: rule__ContainedPropertyAssociation__Group_4__2__Impl rule__ContainedPropertyAssociation__Group_4__3 { pushFollow(FollowSets000.FOLLOW_83); rule__ContainedPropertyAssociation__Group_4__2__Impl(); @@ -39683,23 +39778,23 @@ public final void rule__ContainedPropertyAssociation__Group_4__2() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__2__Impl" - // InternalBehaviorAnnexParser.g:11904:1: rule__ContainedPropertyAssociation__Group_4__2__Impl : ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) ; + // InternalBehaviorAnnexParser.g:11931:1: rule__ContainedPropertyAssociation__Group_4__2__Impl : ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) ; public final void rule__ContainedPropertyAssociation__Group_4__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11908:1: ( ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) ) - // InternalBehaviorAnnexParser.g:11909:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) + // InternalBehaviorAnnexParser.g:11935:1: ( ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) ) + // InternalBehaviorAnnexParser.g:11936:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) { - // InternalBehaviorAnnexParser.g:11909:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) - // InternalBehaviorAnnexParser.g:11910:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) + // InternalBehaviorAnnexParser.g:11936:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) + // InternalBehaviorAnnexParser.g:11937:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToAssignment_4_2()); } - // InternalBehaviorAnnexParser.g:11911:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) - // InternalBehaviorAnnexParser.g:11911:3: rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 + // InternalBehaviorAnnexParser.g:11938:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) + // InternalBehaviorAnnexParser.g:11938:3: rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__AppliesToAssignment_4_2(); @@ -39734,14 +39829,14 @@ public final void rule__ContainedPropertyAssociation__Group_4__2__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__3" - // InternalBehaviorAnnexParser.g:11919:1: rule__ContainedPropertyAssociation__Group_4__3 : rule__ContainedPropertyAssociation__Group_4__3__Impl ; + // InternalBehaviorAnnexParser.g:11946:1: rule__ContainedPropertyAssociation__Group_4__3 : rule__ContainedPropertyAssociation__Group_4__3__Impl ; public final void rule__ContainedPropertyAssociation__Group_4__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11923:1: ( rule__ContainedPropertyAssociation__Group_4__3__Impl ) - // InternalBehaviorAnnexParser.g:11924:2: rule__ContainedPropertyAssociation__Group_4__3__Impl + // InternalBehaviorAnnexParser.g:11950:1: ( rule__ContainedPropertyAssociation__Group_4__3__Impl ) + // InternalBehaviorAnnexParser.g:11951:2: rule__ContainedPropertyAssociation__Group_4__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_4__3__Impl(); @@ -39767,35 +39862,35 @@ public final void rule__ContainedPropertyAssociation__Group_4__3() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__3__Impl" - // InternalBehaviorAnnexParser.g:11930:1: rule__ContainedPropertyAssociation__Group_4__3__Impl : ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) ; + // InternalBehaviorAnnexParser.g:11957:1: rule__ContainedPropertyAssociation__Group_4__3__Impl : ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) ; public final void rule__ContainedPropertyAssociation__Group_4__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11934:1: ( ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) ) - // InternalBehaviorAnnexParser.g:11935:1: ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) + // InternalBehaviorAnnexParser.g:11961:1: ( ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) ) + // InternalBehaviorAnnexParser.g:11962:1: ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) { - // InternalBehaviorAnnexParser.g:11935:1: ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) - // InternalBehaviorAnnexParser.g:11936:2: ( rule__ContainedPropertyAssociation__Group_4_3__0 )* + // InternalBehaviorAnnexParser.g:11962:1: ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) + // InternalBehaviorAnnexParser.g:11963:2: ( rule__ContainedPropertyAssociation__Group_4_3__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup_4_3()); } - // InternalBehaviorAnnexParser.g:11937:2: ( rule__ContainedPropertyAssociation__Group_4_3__0 )* - loop105: + // InternalBehaviorAnnexParser.g:11964:2: ( rule__ContainedPropertyAssociation__Group_4_3__0 )* + loop106: do { - int alt105=2; - int LA105_0 = input.LA(1); + int alt106=2; + int LA106_0 = input.LA(1); - if ( (LA105_0==Comma) ) { - alt105=1; + if ( (LA106_0==Comma) ) { + alt106=1; } - switch (alt105) { + switch (alt106) { case 1 : - // InternalBehaviorAnnexParser.g:11937:3: rule__ContainedPropertyAssociation__Group_4_3__0 + // InternalBehaviorAnnexParser.g:11964:3: rule__ContainedPropertyAssociation__Group_4_3__0 { pushFollow(FollowSets000.FOLLOW_7); rule__ContainedPropertyAssociation__Group_4_3__0(); @@ -39807,7 +39902,7 @@ public final void rule__ContainedPropertyAssociation__Group_4__3__Impl() throws break; default : - break loop105; + break loop106; } } while (true); @@ -39836,14 +39931,14 @@ public final void rule__ContainedPropertyAssociation__Group_4__3__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_4_3__0" - // InternalBehaviorAnnexParser.g:11946:1: rule__ContainedPropertyAssociation__Group_4_3__0 : rule__ContainedPropertyAssociation__Group_4_3__0__Impl rule__ContainedPropertyAssociation__Group_4_3__1 ; + // InternalBehaviorAnnexParser.g:11973:1: rule__ContainedPropertyAssociation__Group_4_3__0 : rule__ContainedPropertyAssociation__Group_4_3__0__Impl rule__ContainedPropertyAssociation__Group_4_3__1 ; public final void rule__ContainedPropertyAssociation__Group_4_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11950:1: ( rule__ContainedPropertyAssociation__Group_4_3__0__Impl rule__ContainedPropertyAssociation__Group_4_3__1 ) - // InternalBehaviorAnnexParser.g:11951:2: rule__ContainedPropertyAssociation__Group_4_3__0__Impl rule__ContainedPropertyAssociation__Group_4_3__1 + // InternalBehaviorAnnexParser.g:11977:1: ( rule__ContainedPropertyAssociation__Group_4_3__0__Impl rule__ContainedPropertyAssociation__Group_4_3__1 ) + // InternalBehaviorAnnexParser.g:11978:2: rule__ContainedPropertyAssociation__Group_4_3__0__Impl rule__ContainedPropertyAssociation__Group_4_3__1 { pushFollow(FollowSets000.FOLLOW_4); rule__ContainedPropertyAssociation__Group_4_3__0__Impl(); @@ -39874,17 +39969,17 @@ public final void rule__ContainedPropertyAssociation__Group_4_3__0() throws Reco // $ANTLR start "rule__ContainedPropertyAssociation__Group_4_3__0__Impl" - // InternalBehaviorAnnexParser.g:11958:1: rule__ContainedPropertyAssociation__Group_4_3__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:11985:1: rule__ContainedPropertyAssociation__Group_4_3__0__Impl : ( Comma ) ; public final void rule__ContainedPropertyAssociation__Group_4_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11962:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:11963:1: ( Comma ) + // InternalBehaviorAnnexParser.g:11989:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:11990:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:11963:1: ( Comma ) - // InternalBehaviorAnnexParser.g:11964:2: Comma + // InternalBehaviorAnnexParser.g:11990:1: ( Comma ) + // InternalBehaviorAnnexParser.g:11991:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getCommaKeyword_4_3_0()); @@ -39915,14 +40010,14 @@ public final void rule__ContainedPropertyAssociation__Group_4_3__0__Impl() throw // $ANTLR start "rule__ContainedPropertyAssociation__Group_4_3__1" - // InternalBehaviorAnnexParser.g:11973:1: rule__ContainedPropertyAssociation__Group_4_3__1 : rule__ContainedPropertyAssociation__Group_4_3__1__Impl ; + // InternalBehaviorAnnexParser.g:12000:1: rule__ContainedPropertyAssociation__Group_4_3__1 : rule__ContainedPropertyAssociation__Group_4_3__1__Impl ; public final void rule__ContainedPropertyAssociation__Group_4_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11977:1: ( rule__ContainedPropertyAssociation__Group_4_3__1__Impl ) - // InternalBehaviorAnnexParser.g:11978:2: rule__ContainedPropertyAssociation__Group_4_3__1__Impl + // InternalBehaviorAnnexParser.g:12004:1: ( rule__ContainedPropertyAssociation__Group_4_3__1__Impl ) + // InternalBehaviorAnnexParser.g:12005:2: rule__ContainedPropertyAssociation__Group_4_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_4_3__1__Impl(); @@ -39948,23 +40043,23 @@ public final void rule__ContainedPropertyAssociation__Group_4_3__1() throws Reco // $ANTLR start "rule__ContainedPropertyAssociation__Group_4_3__1__Impl" - // InternalBehaviorAnnexParser.g:11984:1: rule__ContainedPropertyAssociation__Group_4_3__1__Impl : ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:12011:1: rule__ContainedPropertyAssociation__Group_4_3__1__Impl : ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) ; public final void rule__ContainedPropertyAssociation__Group_4_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11988:1: ( ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:11989:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) + // InternalBehaviorAnnexParser.g:12015:1: ( ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:12016:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) { - // InternalBehaviorAnnexParser.g:11989:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) - // InternalBehaviorAnnexParser.g:11990:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) + // InternalBehaviorAnnexParser.g:12016:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) + // InternalBehaviorAnnexParser.g:12017:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToAssignment_4_3_1()); } - // InternalBehaviorAnnexParser.g:11991:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) - // InternalBehaviorAnnexParser.g:11991:3: rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 + // InternalBehaviorAnnexParser.g:12018:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) + // InternalBehaviorAnnexParser.g:12018:3: rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1(); @@ -39999,14 +40094,14 @@ public final void rule__ContainedPropertyAssociation__Group_4_3__1__Impl() throw // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__0" - // InternalBehaviorAnnexParser.g:12000:1: rule__ContainedPropertyAssociation__Group_5__0 : rule__ContainedPropertyAssociation__Group_5__0__Impl rule__ContainedPropertyAssociation__Group_5__1 ; + // InternalBehaviorAnnexParser.g:12027:1: rule__ContainedPropertyAssociation__Group_5__0 : rule__ContainedPropertyAssociation__Group_5__0__Impl rule__ContainedPropertyAssociation__Group_5__1 ; public final void rule__ContainedPropertyAssociation__Group_5__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12004:1: ( rule__ContainedPropertyAssociation__Group_5__0__Impl rule__ContainedPropertyAssociation__Group_5__1 ) - // InternalBehaviorAnnexParser.g:12005:2: rule__ContainedPropertyAssociation__Group_5__0__Impl rule__ContainedPropertyAssociation__Group_5__1 + // InternalBehaviorAnnexParser.g:12031:1: ( rule__ContainedPropertyAssociation__Group_5__0__Impl rule__ContainedPropertyAssociation__Group_5__1 ) + // InternalBehaviorAnnexParser.g:12032:2: rule__ContainedPropertyAssociation__Group_5__0__Impl rule__ContainedPropertyAssociation__Group_5__1 { pushFollow(FollowSets000.FOLLOW_51); rule__ContainedPropertyAssociation__Group_5__0__Impl(); @@ -40037,17 +40132,17 @@ public final void rule__ContainedPropertyAssociation__Group_5__0() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__0__Impl" - // InternalBehaviorAnnexParser.g:12012:1: rule__ContainedPropertyAssociation__Group_5__0__Impl : ( In ) ; + // InternalBehaviorAnnexParser.g:12039:1: rule__ContainedPropertyAssociation__Group_5__0__Impl : ( In ) ; public final void rule__ContainedPropertyAssociation__Group_5__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12016:1: ( ( In ) ) - // InternalBehaviorAnnexParser.g:12017:1: ( In ) + // InternalBehaviorAnnexParser.g:12043:1: ( ( In ) ) + // InternalBehaviorAnnexParser.g:12044:1: ( In ) { - // InternalBehaviorAnnexParser.g:12017:1: ( In ) - // InternalBehaviorAnnexParser.g:12018:2: In + // InternalBehaviorAnnexParser.g:12044:1: ( In ) + // InternalBehaviorAnnexParser.g:12045:2: In { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getInKeyword_5_0()); @@ -40078,14 +40173,14 @@ public final void rule__ContainedPropertyAssociation__Group_5__0__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__1" - // InternalBehaviorAnnexParser.g:12027:1: rule__ContainedPropertyAssociation__Group_5__1 : rule__ContainedPropertyAssociation__Group_5__1__Impl rule__ContainedPropertyAssociation__Group_5__2 ; + // InternalBehaviorAnnexParser.g:12054:1: rule__ContainedPropertyAssociation__Group_5__1 : rule__ContainedPropertyAssociation__Group_5__1__Impl rule__ContainedPropertyAssociation__Group_5__2 ; public final void rule__ContainedPropertyAssociation__Group_5__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12031:1: ( rule__ContainedPropertyAssociation__Group_5__1__Impl rule__ContainedPropertyAssociation__Group_5__2 ) - // InternalBehaviorAnnexParser.g:12032:2: rule__ContainedPropertyAssociation__Group_5__1__Impl rule__ContainedPropertyAssociation__Group_5__2 + // InternalBehaviorAnnexParser.g:12058:1: ( rule__ContainedPropertyAssociation__Group_5__1__Impl rule__ContainedPropertyAssociation__Group_5__2 ) + // InternalBehaviorAnnexParser.g:12059:2: rule__ContainedPropertyAssociation__Group_5__1__Impl rule__ContainedPropertyAssociation__Group_5__2 { pushFollow(FollowSets000.FOLLOW_27); rule__ContainedPropertyAssociation__Group_5__1__Impl(); @@ -40116,17 +40211,17 @@ public final void rule__ContainedPropertyAssociation__Group_5__1() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__1__Impl" - // InternalBehaviorAnnexParser.g:12039:1: rule__ContainedPropertyAssociation__Group_5__1__Impl : ( Binding ) ; + // InternalBehaviorAnnexParser.g:12066:1: rule__ContainedPropertyAssociation__Group_5__1__Impl : ( Binding ) ; public final void rule__ContainedPropertyAssociation__Group_5__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12043:1: ( ( Binding ) ) - // InternalBehaviorAnnexParser.g:12044:1: ( Binding ) + // InternalBehaviorAnnexParser.g:12070:1: ( ( Binding ) ) + // InternalBehaviorAnnexParser.g:12071:1: ( Binding ) { - // InternalBehaviorAnnexParser.g:12044:1: ( Binding ) - // InternalBehaviorAnnexParser.g:12045:2: Binding + // InternalBehaviorAnnexParser.g:12071:1: ( Binding ) + // InternalBehaviorAnnexParser.g:12072:2: Binding { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getBindingKeyword_5_1()); @@ -40157,14 +40252,14 @@ public final void rule__ContainedPropertyAssociation__Group_5__1__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__2" - // InternalBehaviorAnnexParser.g:12054:1: rule__ContainedPropertyAssociation__Group_5__2 : rule__ContainedPropertyAssociation__Group_5__2__Impl rule__ContainedPropertyAssociation__Group_5__3 ; + // InternalBehaviorAnnexParser.g:12081:1: rule__ContainedPropertyAssociation__Group_5__2 : rule__ContainedPropertyAssociation__Group_5__2__Impl rule__ContainedPropertyAssociation__Group_5__3 ; public final void rule__ContainedPropertyAssociation__Group_5__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12058:1: ( rule__ContainedPropertyAssociation__Group_5__2__Impl rule__ContainedPropertyAssociation__Group_5__3 ) - // InternalBehaviorAnnexParser.g:12059:2: rule__ContainedPropertyAssociation__Group_5__2__Impl rule__ContainedPropertyAssociation__Group_5__3 + // InternalBehaviorAnnexParser.g:12085:1: ( rule__ContainedPropertyAssociation__Group_5__2__Impl rule__ContainedPropertyAssociation__Group_5__3 ) + // InternalBehaviorAnnexParser.g:12086:2: rule__ContainedPropertyAssociation__Group_5__2__Impl rule__ContainedPropertyAssociation__Group_5__3 { pushFollow(FollowSets000.FOLLOW_4); rule__ContainedPropertyAssociation__Group_5__2__Impl(); @@ -40195,17 +40290,17 @@ public final void rule__ContainedPropertyAssociation__Group_5__2() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__2__Impl" - // InternalBehaviorAnnexParser.g:12066:1: rule__ContainedPropertyAssociation__Group_5__2__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12093:1: rule__ContainedPropertyAssociation__Group_5__2__Impl : ( LeftParenthesis ) ; public final void rule__ContainedPropertyAssociation__Group_5__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12070:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12071:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12097:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12098:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12071:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12072:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12098:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12099:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getLeftParenthesisKeyword_5_2()); @@ -40236,14 +40331,14 @@ public final void rule__ContainedPropertyAssociation__Group_5__2__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__3" - // InternalBehaviorAnnexParser.g:12081:1: rule__ContainedPropertyAssociation__Group_5__3 : rule__ContainedPropertyAssociation__Group_5__3__Impl rule__ContainedPropertyAssociation__Group_5__4 ; + // InternalBehaviorAnnexParser.g:12108:1: rule__ContainedPropertyAssociation__Group_5__3 : rule__ContainedPropertyAssociation__Group_5__3__Impl rule__ContainedPropertyAssociation__Group_5__4 ; public final void rule__ContainedPropertyAssociation__Group_5__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12085:1: ( rule__ContainedPropertyAssociation__Group_5__3__Impl rule__ContainedPropertyAssociation__Group_5__4 ) - // InternalBehaviorAnnexParser.g:12086:2: rule__ContainedPropertyAssociation__Group_5__3__Impl rule__ContainedPropertyAssociation__Group_5__4 + // InternalBehaviorAnnexParser.g:12112:1: ( rule__ContainedPropertyAssociation__Group_5__3__Impl rule__ContainedPropertyAssociation__Group_5__4 ) + // InternalBehaviorAnnexParser.g:12113:2: rule__ContainedPropertyAssociation__Group_5__3__Impl rule__ContainedPropertyAssociation__Group_5__4 { pushFollow(FollowSets000.FOLLOW_37); rule__ContainedPropertyAssociation__Group_5__3__Impl(); @@ -40274,23 +40369,23 @@ public final void rule__ContainedPropertyAssociation__Group_5__3() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__3__Impl" - // InternalBehaviorAnnexParser.g:12093:1: rule__ContainedPropertyAssociation__Group_5__3__Impl : ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) ; + // InternalBehaviorAnnexParser.g:12120:1: rule__ContainedPropertyAssociation__Group_5__3__Impl : ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) ; public final void rule__ContainedPropertyAssociation__Group_5__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12097:1: ( ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) ) - // InternalBehaviorAnnexParser.g:12098:1: ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) + // InternalBehaviorAnnexParser.g:12124:1: ( ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) ) + // InternalBehaviorAnnexParser.g:12125:1: ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) { - // InternalBehaviorAnnexParser.g:12098:1: ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) - // InternalBehaviorAnnexParser.g:12099:2: ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) + // InternalBehaviorAnnexParser.g:12125:1: ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) + // InternalBehaviorAnnexParser.g:12126:2: ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getInBindingAssignment_5_3()); } - // InternalBehaviorAnnexParser.g:12100:2: ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) - // InternalBehaviorAnnexParser.g:12100:3: rule__ContainedPropertyAssociation__InBindingAssignment_5_3 + // InternalBehaviorAnnexParser.g:12127:2: ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) + // InternalBehaviorAnnexParser.g:12127:3: rule__ContainedPropertyAssociation__InBindingAssignment_5_3 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__InBindingAssignment_5_3(); @@ -40325,14 +40420,14 @@ public final void rule__ContainedPropertyAssociation__Group_5__3__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__4" - // InternalBehaviorAnnexParser.g:12108:1: rule__ContainedPropertyAssociation__Group_5__4 : rule__ContainedPropertyAssociation__Group_5__4__Impl ; + // InternalBehaviorAnnexParser.g:12135:1: rule__ContainedPropertyAssociation__Group_5__4 : rule__ContainedPropertyAssociation__Group_5__4__Impl ; public final void rule__ContainedPropertyAssociation__Group_5__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12112:1: ( rule__ContainedPropertyAssociation__Group_5__4__Impl ) - // InternalBehaviorAnnexParser.g:12113:2: rule__ContainedPropertyAssociation__Group_5__4__Impl + // InternalBehaviorAnnexParser.g:12139:1: ( rule__ContainedPropertyAssociation__Group_5__4__Impl ) + // InternalBehaviorAnnexParser.g:12140:2: rule__ContainedPropertyAssociation__Group_5__4__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_5__4__Impl(); @@ -40358,17 +40453,17 @@ public final void rule__ContainedPropertyAssociation__Group_5__4() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__4__Impl" - // InternalBehaviorAnnexParser.g:12119:1: rule__ContainedPropertyAssociation__Group_5__4__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12146:1: rule__ContainedPropertyAssociation__Group_5__4__Impl : ( RightParenthesis ) ; public final void rule__ContainedPropertyAssociation__Group_5__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12123:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12124:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12150:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12151:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12124:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12125:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12151:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12152:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getRightParenthesisKeyword_5_4()); @@ -40399,14 +40494,14 @@ public final void rule__ContainedPropertyAssociation__Group_5__4__Impl() throws // $ANTLR start "rule__OptionalModalPropertyValue__Group__0" - // InternalBehaviorAnnexParser.g:12135:1: rule__OptionalModalPropertyValue__Group__0 : rule__OptionalModalPropertyValue__Group__0__Impl rule__OptionalModalPropertyValue__Group__1 ; + // InternalBehaviorAnnexParser.g:12162:1: rule__OptionalModalPropertyValue__Group__0 : rule__OptionalModalPropertyValue__Group__0__Impl rule__OptionalModalPropertyValue__Group__1 ; public final void rule__OptionalModalPropertyValue__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12139:1: ( rule__OptionalModalPropertyValue__Group__0__Impl rule__OptionalModalPropertyValue__Group__1 ) - // InternalBehaviorAnnexParser.g:12140:2: rule__OptionalModalPropertyValue__Group__0__Impl rule__OptionalModalPropertyValue__Group__1 + // InternalBehaviorAnnexParser.g:12166:1: ( rule__OptionalModalPropertyValue__Group__0__Impl rule__OptionalModalPropertyValue__Group__1 ) + // InternalBehaviorAnnexParser.g:12167:2: rule__OptionalModalPropertyValue__Group__0__Impl rule__OptionalModalPropertyValue__Group__1 { pushFollow(FollowSets000.FOLLOW_50); rule__OptionalModalPropertyValue__Group__0__Impl(); @@ -40437,23 +40532,23 @@ public final void rule__OptionalModalPropertyValue__Group__0() throws Recognitio // $ANTLR start "rule__OptionalModalPropertyValue__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12147:1: rule__OptionalModalPropertyValue__Group__0__Impl : ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:12174:1: rule__OptionalModalPropertyValue__Group__0__Impl : ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) ; public final void rule__OptionalModalPropertyValue__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12151:1: ( ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:12152:1: ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:12178:1: ( ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:12179:1: ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:12152:1: ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:12153:2: ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:12179:1: ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:12180:2: ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getOwnedValueAssignment_0()); } - // InternalBehaviorAnnexParser.g:12154:2: ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) - // InternalBehaviorAnnexParser.g:12154:3: rule__OptionalModalPropertyValue__OwnedValueAssignment_0 + // InternalBehaviorAnnexParser.g:12181:2: ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:12181:3: rule__OptionalModalPropertyValue__OwnedValueAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__OwnedValueAssignment_0(); @@ -40488,14 +40583,14 @@ public final void rule__OptionalModalPropertyValue__Group__0__Impl() throws Reco // $ANTLR start "rule__OptionalModalPropertyValue__Group__1" - // InternalBehaviorAnnexParser.g:12162:1: rule__OptionalModalPropertyValue__Group__1 : rule__OptionalModalPropertyValue__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:12189:1: rule__OptionalModalPropertyValue__Group__1 : rule__OptionalModalPropertyValue__Group__1__Impl ; public final void rule__OptionalModalPropertyValue__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12166:1: ( rule__OptionalModalPropertyValue__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:12167:2: rule__OptionalModalPropertyValue__Group__1__Impl + // InternalBehaviorAnnexParser.g:12193:1: ( rule__OptionalModalPropertyValue__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:12194:2: rule__OptionalModalPropertyValue__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__Group__1__Impl(); @@ -40521,35 +40616,35 @@ public final void rule__OptionalModalPropertyValue__Group__1() throws Recognitio // $ANTLR start "rule__OptionalModalPropertyValue__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12173:1: rule__OptionalModalPropertyValue__Group__1__Impl : ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:12200:1: rule__OptionalModalPropertyValue__Group__1__Impl : ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) ; public final void rule__OptionalModalPropertyValue__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12177:1: ( ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:12178:1: ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:12204:1: ( ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:12205:1: ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:12178:1: ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:12179:2: ( rule__OptionalModalPropertyValue__Group_1__0 )? + // InternalBehaviorAnnexParser.g:12205:1: ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:12206:2: ( rule__OptionalModalPropertyValue__Group_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:12180:2: ( rule__OptionalModalPropertyValue__Group_1__0 )? - int alt106=2; - int LA106_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:12207:2: ( rule__OptionalModalPropertyValue__Group_1__0 )? + int alt107=2; + int LA107_0 = input.LA(1); - if ( (LA106_0==In) ) { - int LA106_1 = input.LA(2); + if ( (LA107_0==In) ) { + int LA107_1 = input.LA(2); - if ( (LA106_1==Modes) ) { - alt106=1; + if ( (LA107_1==Modes) ) { + alt107=1; } } - switch (alt106) { + switch (alt107) { case 1 : - // InternalBehaviorAnnexParser.g:12180:3: rule__OptionalModalPropertyValue__Group_1__0 + // InternalBehaviorAnnexParser.g:12207:3: rule__OptionalModalPropertyValue__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__Group_1__0(); @@ -40587,14 +40682,14 @@ public final void rule__OptionalModalPropertyValue__Group__1__Impl() throws Reco // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__0" - // InternalBehaviorAnnexParser.g:12189:1: rule__OptionalModalPropertyValue__Group_1__0 : rule__OptionalModalPropertyValue__Group_1__0__Impl rule__OptionalModalPropertyValue__Group_1__1 ; + // InternalBehaviorAnnexParser.g:12216:1: rule__OptionalModalPropertyValue__Group_1__0 : rule__OptionalModalPropertyValue__Group_1__0__Impl rule__OptionalModalPropertyValue__Group_1__1 ; public final void rule__OptionalModalPropertyValue__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12193:1: ( rule__OptionalModalPropertyValue__Group_1__0__Impl rule__OptionalModalPropertyValue__Group_1__1 ) - // InternalBehaviorAnnexParser.g:12194:2: rule__OptionalModalPropertyValue__Group_1__0__Impl rule__OptionalModalPropertyValue__Group_1__1 + // InternalBehaviorAnnexParser.g:12220:1: ( rule__OptionalModalPropertyValue__Group_1__0__Impl rule__OptionalModalPropertyValue__Group_1__1 ) + // InternalBehaviorAnnexParser.g:12221:2: rule__OptionalModalPropertyValue__Group_1__0__Impl rule__OptionalModalPropertyValue__Group_1__1 { pushFollow(FollowSets000.FOLLOW_85); rule__OptionalModalPropertyValue__Group_1__0__Impl(); @@ -40625,17 +40720,17 @@ public final void rule__OptionalModalPropertyValue__Group_1__0() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:12201:1: rule__OptionalModalPropertyValue__Group_1__0__Impl : ( In ) ; + // InternalBehaviorAnnexParser.g:12228:1: rule__OptionalModalPropertyValue__Group_1__0__Impl : ( In ) ; public final void rule__OptionalModalPropertyValue__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12205:1: ( ( In ) ) - // InternalBehaviorAnnexParser.g:12206:1: ( In ) + // InternalBehaviorAnnexParser.g:12232:1: ( ( In ) ) + // InternalBehaviorAnnexParser.g:12233:1: ( In ) { - // InternalBehaviorAnnexParser.g:12206:1: ( In ) - // InternalBehaviorAnnexParser.g:12207:2: In + // InternalBehaviorAnnexParser.g:12233:1: ( In ) + // InternalBehaviorAnnexParser.g:12234:2: In { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInKeyword_1_0()); @@ -40666,14 +40761,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__0__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__1" - // InternalBehaviorAnnexParser.g:12216:1: rule__OptionalModalPropertyValue__Group_1__1 : rule__OptionalModalPropertyValue__Group_1__1__Impl rule__OptionalModalPropertyValue__Group_1__2 ; + // InternalBehaviorAnnexParser.g:12243:1: rule__OptionalModalPropertyValue__Group_1__1 : rule__OptionalModalPropertyValue__Group_1__1__Impl rule__OptionalModalPropertyValue__Group_1__2 ; public final void rule__OptionalModalPropertyValue__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12220:1: ( rule__OptionalModalPropertyValue__Group_1__1__Impl rule__OptionalModalPropertyValue__Group_1__2 ) - // InternalBehaviorAnnexParser.g:12221:2: rule__OptionalModalPropertyValue__Group_1__1__Impl rule__OptionalModalPropertyValue__Group_1__2 + // InternalBehaviorAnnexParser.g:12247:1: ( rule__OptionalModalPropertyValue__Group_1__1__Impl rule__OptionalModalPropertyValue__Group_1__2 ) + // InternalBehaviorAnnexParser.g:12248:2: rule__OptionalModalPropertyValue__Group_1__1__Impl rule__OptionalModalPropertyValue__Group_1__2 { pushFollow(FollowSets000.FOLLOW_27); rule__OptionalModalPropertyValue__Group_1__1__Impl(); @@ -40704,17 +40799,17 @@ public final void rule__OptionalModalPropertyValue__Group_1__1() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:12228:1: rule__OptionalModalPropertyValue__Group_1__1__Impl : ( Modes ) ; + // InternalBehaviorAnnexParser.g:12255:1: rule__OptionalModalPropertyValue__Group_1__1__Impl : ( Modes ) ; public final void rule__OptionalModalPropertyValue__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12232:1: ( ( Modes ) ) - // InternalBehaviorAnnexParser.g:12233:1: ( Modes ) + // InternalBehaviorAnnexParser.g:12259:1: ( ( Modes ) ) + // InternalBehaviorAnnexParser.g:12260:1: ( Modes ) { - // InternalBehaviorAnnexParser.g:12233:1: ( Modes ) - // InternalBehaviorAnnexParser.g:12234:2: Modes + // InternalBehaviorAnnexParser.g:12260:1: ( Modes ) + // InternalBehaviorAnnexParser.g:12261:2: Modes { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getModesKeyword_1_1()); @@ -40745,14 +40840,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__1__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__2" - // InternalBehaviorAnnexParser.g:12243:1: rule__OptionalModalPropertyValue__Group_1__2 : rule__OptionalModalPropertyValue__Group_1__2__Impl rule__OptionalModalPropertyValue__Group_1__3 ; + // InternalBehaviorAnnexParser.g:12270:1: rule__OptionalModalPropertyValue__Group_1__2 : rule__OptionalModalPropertyValue__Group_1__2__Impl rule__OptionalModalPropertyValue__Group_1__3 ; public final void rule__OptionalModalPropertyValue__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12247:1: ( rule__OptionalModalPropertyValue__Group_1__2__Impl rule__OptionalModalPropertyValue__Group_1__3 ) - // InternalBehaviorAnnexParser.g:12248:2: rule__OptionalModalPropertyValue__Group_1__2__Impl rule__OptionalModalPropertyValue__Group_1__3 + // InternalBehaviorAnnexParser.g:12274:1: ( rule__OptionalModalPropertyValue__Group_1__2__Impl rule__OptionalModalPropertyValue__Group_1__3 ) + // InternalBehaviorAnnexParser.g:12275:2: rule__OptionalModalPropertyValue__Group_1__2__Impl rule__OptionalModalPropertyValue__Group_1__3 { pushFollow(FollowSets000.FOLLOW_4); rule__OptionalModalPropertyValue__Group_1__2__Impl(); @@ -40783,17 +40878,17 @@ public final void rule__OptionalModalPropertyValue__Group_1__2() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:12255:1: rule__OptionalModalPropertyValue__Group_1__2__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12282:1: rule__OptionalModalPropertyValue__Group_1__2__Impl : ( LeftParenthesis ) ; public final void rule__OptionalModalPropertyValue__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12259:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12260:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12286:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12287:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12260:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12261:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12287:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12288:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getLeftParenthesisKeyword_1_2()); @@ -40824,14 +40919,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__2__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__3" - // InternalBehaviorAnnexParser.g:12270:1: rule__OptionalModalPropertyValue__Group_1__3 : rule__OptionalModalPropertyValue__Group_1__3__Impl rule__OptionalModalPropertyValue__Group_1__4 ; + // InternalBehaviorAnnexParser.g:12297:1: rule__OptionalModalPropertyValue__Group_1__3 : rule__OptionalModalPropertyValue__Group_1__3__Impl rule__OptionalModalPropertyValue__Group_1__4 ; public final void rule__OptionalModalPropertyValue__Group_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12274:1: ( rule__OptionalModalPropertyValue__Group_1__3__Impl rule__OptionalModalPropertyValue__Group_1__4 ) - // InternalBehaviorAnnexParser.g:12275:2: rule__OptionalModalPropertyValue__Group_1__3__Impl rule__OptionalModalPropertyValue__Group_1__4 + // InternalBehaviorAnnexParser.g:12301:1: ( rule__OptionalModalPropertyValue__Group_1__3__Impl rule__OptionalModalPropertyValue__Group_1__4 ) + // InternalBehaviorAnnexParser.g:12302:2: rule__OptionalModalPropertyValue__Group_1__3__Impl rule__OptionalModalPropertyValue__Group_1__4 { pushFollow(FollowSets000.FOLLOW_28); rule__OptionalModalPropertyValue__Group_1__3__Impl(); @@ -40862,23 +40957,23 @@ public final void rule__OptionalModalPropertyValue__Group_1__3() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__3__Impl" - // InternalBehaviorAnnexParser.g:12282:1: rule__OptionalModalPropertyValue__Group_1__3__Impl : ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) ; + // InternalBehaviorAnnexParser.g:12309:1: rule__OptionalModalPropertyValue__Group_1__3__Impl : ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) ; public final void rule__OptionalModalPropertyValue__Group_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12286:1: ( ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) ) - // InternalBehaviorAnnexParser.g:12287:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) + // InternalBehaviorAnnexParser.g:12313:1: ( ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) ) + // InternalBehaviorAnnexParser.g:12314:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) { - // InternalBehaviorAnnexParser.g:12287:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) - // InternalBehaviorAnnexParser.g:12288:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) + // InternalBehaviorAnnexParser.g:12314:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) + // InternalBehaviorAnnexParser.g:12315:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeAssignment_1_3()); } - // InternalBehaviorAnnexParser.g:12289:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) - // InternalBehaviorAnnexParser.g:12289:3: rule__OptionalModalPropertyValue__InModeAssignment_1_3 + // InternalBehaviorAnnexParser.g:12316:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) + // InternalBehaviorAnnexParser.g:12316:3: rule__OptionalModalPropertyValue__InModeAssignment_1_3 { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__InModeAssignment_1_3(); @@ -40913,14 +41008,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__3__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__4" - // InternalBehaviorAnnexParser.g:12297:1: rule__OptionalModalPropertyValue__Group_1__4 : rule__OptionalModalPropertyValue__Group_1__4__Impl rule__OptionalModalPropertyValue__Group_1__5 ; + // InternalBehaviorAnnexParser.g:12324:1: rule__OptionalModalPropertyValue__Group_1__4 : rule__OptionalModalPropertyValue__Group_1__4__Impl rule__OptionalModalPropertyValue__Group_1__5 ; public final void rule__OptionalModalPropertyValue__Group_1__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12301:1: ( rule__OptionalModalPropertyValue__Group_1__4__Impl rule__OptionalModalPropertyValue__Group_1__5 ) - // InternalBehaviorAnnexParser.g:12302:2: rule__OptionalModalPropertyValue__Group_1__4__Impl rule__OptionalModalPropertyValue__Group_1__5 + // InternalBehaviorAnnexParser.g:12328:1: ( rule__OptionalModalPropertyValue__Group_1__4__Impl rule__OptionalModalPropertyValue__Group_1__5 ) + // InternalBehaviorAnnexParser.g:12329:2: rule__OptionalModalPropertyValue__Group_1__4__Impl rule__OptionalModalPropertyValue__Group_1__5 { pushFollow(FollowSets000.FOLLOW_28); rule__OptionalModalPropertyValue__Group_1__4__Impl(); @@ -40951,35 +41046,35 @@ public final void rule__OptionalModalPropertyValue__Group_1__4() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__4__Impl" - // InternalBehaviorAnnexParser.g:12309:1: rule__OptionalModalPropertyValue__Group_1__4__Impl : ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) ; + // InternalBehaviorAnnexParser.g:12336:1: rule__OptionalModalPropertyValue__Group_1__4__Impl : ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) ; public final void rule__OptionalModalPropertyValue__Group_1__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12313:1: ( ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) ) - // InternalBehaviorAnnexParser.g:12314:1: ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) + // InternalBehaviorAnnexParser.g:12340:1: ( ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) ) + // InternalBehaviorAnnexParser.g:12341:1: ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) { - // InternalBehaviorAnnexParser.g:12314:1: ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) - // InternalBehaviorAnnexParser.g:12315:2: ( rule__OptionalModalPropertyValue__Group_1_4__0 )* + // InternalBehaviorAnnexParser.g:12341:1: ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) + // InternalBehaviorAnnexParser.g:12342:2: ( rule__OptionalModalPropertyValue__Group_1_4__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getGroup_1_4()); } - // InternalBehaviorAnnexParser.g:12316:2: ( rule__OptionalModalPropertyValue__Group_1_4__0 )* - loop107: + // InternalBehaviorAnnexParser.g:12343:2: ( rule__OptionalModalPropertyValue__Group_1_4__0 )* + loop108: do { - int alt107=2; - int LA107_0 = input.LA(1); + int alt108=2; + int LA108_0 = input.LA(1); - if ( (LA107_0==Comma) ) { - alt107=1; + if ( (LA108_0==Comma) ) { + alt108=1; } - switch (alt107) { + switch (alt108) { case 1 : - // InternalBehaviorAnnexParser.g:12316:3: rule__OptionalModalPropertyValue__Group_1_4__0 + // InternalBehaviorAnnexParser.g:12343:3: rule__OptionalModalPropertyValue__Group_1_4__0 { pushFollow(FollowSets000.FOLLOW_7); rule__OptionalModalPropertyValue__Group_1_4__0(); @@ -40991,7 +41086,7 @@ public final void rule__OptionalModalPropertyValue__Group_1__4__Impl() throws Re break; default : - break loop107; + break loop108; } } while (true); @@ -41020,14 +41115,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__4__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__5" - // InternalBehaviorAnnexParser.g:12324:1: rule__OptionalModalPropertyValue__Group_1__5 : rule__OptionalModalPropertyValue__Group_1__5__Impl ; + // InternalBehaviorAnnexParser.g:12351:1: rule__OptionalModalPropertyValue__Group_1__5 : rule__OptionalModalPropertyValue__Group_1__5__Impl ; public final void rule__OptionalModalPropertyValue__Group_1__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12328:1: ( rule__OptionalModalPropertyValue__Group_1__5__Impl ) - // InternalBehaviorAnnexParser.g:12329:2: rule__OptionalModalPropertyValue__Group_1__5__Impl + // InternalBehaviorAnnexParser.g:12355:1: ( rule__OptionalModalPropertyValue__Group_1__5__Impl ) + // InternalBehaviorAnnexParser.g:12356:2: rule__OptionalModalPropertyValue__Group_1__5__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__Group_1__5__Impl(); @@ -41053,17 +41148,17 @@ public final void rule__OptionalModalPropertyValue__Group_1__5() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__5__Impl" - // InternalBehaviorAnnexParser.g:12335:1: rule__OptionalModalPropertyValue__Group_1__5__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12362:1: rule__OptionalModalPropertyValue__Group_1__5__Impl : ( RightParenthesis ) ; public final void rule__OptionalModalPropertyValue__Group_1__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12339:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12340:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12366:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12367:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12340:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12341:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12367:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12368:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getRightParenthesisKeyword_1_5()); @@ -41094,14 +41189,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__5__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1_4__0" - // InternalBehaviorAnnexParser.g:12351:1: rule__OptionalModalPropertyValue__Group_1_4__0 : rule__OptionalModalPropertyValue__Group_1_4__0__Impl rule__OptionalModalPropertyValue__Group_1_4__1 ; + // InternalBehaviorAnnexParser.g:12378:1: rule__OptionalModalPropertyValue__Group_1_4__0 : rule__OptionalModalPropertyValue__Group_1_4__0__Impl rule__OptionalModalPropertyValue__Group_1_4__1 ; public final void rule__OptionalModalPropertyValue__Group_1_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12355:1: ( rule__OptionalModalPropertyValue__Group_1_4__0__Impl rule__OptionalModalPropertyValue__Group_1_4__1 ) - // InternalBehaviorAnnexParser.g:12356:2: rule__OptionalModalPropertyValue__Group_1_4__0__Impl rule__OptionalModalPropertyValue__Group_1_4__1 + // InternalBehaviorAnnexParser.g:12382:1: ( rule__OptionalModalPropertyValue__Group_1_4__0__Impl rule__OptionalModalPropertyValue__Group_1_4__1 ) + // InternalBehaviorAnnexParser.g:12383:2: rule__OptionalModalPropertyValue__Group_1_4__0__Impl rule__OptionalModalPropertyValue__Group_1_4__1 { pushFollow(FollowSets000.FOLLOW_4); rule__OptionalModalPropertyValue__Group_1_4__0__Impl(); @@ -41132,17 +41227,17 @@ public final void rule__OptionalModalPropertyValue__Group_1_4__0() throws Recogn // $ANTLR start "rule__OptionalModalPropertyValue__Group_1_4__0__Impl" - // InternalBehaviorAnnexParser.g:12363:1: rule__OptionalModalPropertyValue__Group_1_4__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:12390:1: rule__OptionalModalPropertyValue__Group_1_4__0__Impl : ( Comma ) ; public final void rule__OptionalModalPropertyValue__Group_1_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12367:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:12368:1: ( Comma ) + // InternalBehaviorAnnexParser.g:12394:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:12395:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:12368:1: ( Comma ) - // InternalBehaviorAnnexParser.g:12369:2: Comma + // InternalBehaviorAnnexParser.g:12395:1: ( Comma ) + // InternalBehaviorAnnexParser.g:12396:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getCommaKeyword_1_4_0()); @@ -41173,14 +41268,14 @@ public final void rule__OptionalModalPropertyValue__Group_1_4__0__Impl() throws // $ANTLR start "rule__OptionalModalPropertyValue__Group_1_4__1" - // InternalBehaviorAnnexParser.g:12378:1: rule__OptionalModalPropertyValue__Group_1_4__1 : rule__OptionalModalPropertyValue__Group_1_4__1__Impl ; + // InternalBehaviorAnnexParser.g:12405:1: rule__OptionalModalPropertyValue__Group_1_4__1 : rule__OptionalModalPropertyValue__Group_1_4__1__Impl ; public final void rule__OptionalModalPropertyValue__Group_1_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12382:1: ( rule__OptionalModalPropertyValue__Group_1_4__1__Impl ) - // InternalBehaviorAnnexParser.g:12383:2: rule__OptionalModalPropertyValue__Group_1_4__1__Impl + // InternalBehaviorAnnexParser.g:12409:1: ( rule__OptionalModalPropertyValue__Group_1_4__1__Impl ) + // InternalBehaviorAnnexParser.g:12410:2: rule__OptionalModalPropertyValue__Group_1_4__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__Group_1_4__1__Impl(); @@ -41206,23 +41301,23 @@ public final void rule__OptionalModalPropertyValue__Group_1_4__1() throws Recogn // $ANTLR start "rule__OptionalModalPropertyValue__Group_1_4__1__Impl" - // InternalBehaviorAnnexParser.g:12389:1: rule__OptionalModalPropertyValue__Group_1_4__1__Impl : ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) ; + // InternalBehaviorAnnexParser.g:12416:1: rule__OptionalModalPropertyValue__Group_1_4__1__Impl : ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) ; public final void rule__OptionalModalPropertyValue__Group_1_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12393:1: ( ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) ) - // InternalBehaviorAnnexParser.g:12394:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) + // InternalBehaviorAnnexParser.g:12420:1: ( ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) ) + // InternalBehaviorAnnexParser.g:12421:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) { - // InternalBehaviorAnnexParser.g:12394:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) - // InternalBehaviorAnnexParser.g:12395:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) + // InternalBehaviorAnnexParser.g:12421:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) + // InternalBehaviorAnnexParser.g:12422:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeAssignment_1_4_1()); } - // InternalBehaviorAnnexParser.g:12396:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) - // InternalBehaviorAnnexParser.g:12396:3: rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 + // InternalBehaviorAnnexParser.g:12423:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) + // InternalBehaviorAnnexParser.g:12423:3: rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__InModeAssignment_1_4_1(); @@ -41257,14 +41352,14 @@ public final void rule__OptionalModalPropertyValue__Group_1_4__1__Impl() throws // $ANTLR start "rule__BooleanLiteral__Group__0" - // InternalBehaviorAnnexParser.g:12405:1: rule__BooleanLiteral__Group__0 : rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ; + // InternalBehaviorAnnexParser.g:12432:1: rule__BooleanLiteral__Group__0 : rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ; public final void rule__BooleanLiteral__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12409:1: ( rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ) - // InternalBehaviorAnnexParser.g:12410:2: rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 + // InternalBehaviorAnnexParser.g:12436:1: ( rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ) + // InternalBehaviorAnnexParser.g:12437:2: rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 { pushFollow(FollowSets000.FOLLOW_69); rule__BooleanLiteral__Group__0__Impl(); @@ -41295,23 +41390,23 @@ public final void rule__BooleanLiteral__Group__0() throws RecognitionException { // $ANTLR start "rule__BooleanLiteral__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12417:1: rule__BooleanLiteral__Group__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:12444:1: rule__BooleanLiteral__Group__0__Impl : ( () ) ; public final void rule__BooleanLiteral__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12421:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:12422:1: ( () ) + // InternalBehaviorAnnexParser.g:12448:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:12449:1: ( () ) { - // InternalBehaviorAnnexParser.g:12422:1: ( () ) - // InternalBehaviorAnnexParser.g:12423:2: () + // InternalBehaviorAnnexParser.g:12449:1: ( () ) + // InternalBehaviorAnnexParser.g:12450:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); } - // InternalBehaviorAnnexParser.g:12424:2: () - // InternalBehaviorAnnexParser.g:12424:3: + // InternalBehaviorAnnexParser.g:12451:2: () + // InternalBehaviorAnnexParser.g:12451:3: { } @@ -41336,14 +41431,14 @@ public final void rule__BooleanLiteral__Group__0__Impl() throws RecognitionExcep // $ANTLR start "rule__BooleanLiteral__Group__1" - // InternalBehaviorAnnexParser.g:12432:1: rule__BooleanLiteral__Group__1 : rule__BooleanLiteral__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:12459:1: rule__BooleanLiteral__Group__1 : rule__BooleanLiteral__Group__1__Impl ; public final void rule__BooleanLiteral__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12436:1: ( rule__BooleanLiteral__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:12437:2: rule__BooleanLiteral__Group__1__Impl + // InternalBehaviorAnnexParser.g:12463:1: ( rule__BooleanLiteral__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:12464:2: rule__BooleanLiteral__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BooleanLiteral__Group__1__Impl(); @@ -41369,23 +41464,23 @@ public final void rule__BooleanLiteral__Group__1() throws RecognitionException { // $ANTLR start "rule__BooleanLiteral__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12443:1: rule__BooleanLiteral__Group__1__Impl : ( ( rule__BooleanLiteral__Alternatives_1 ) ) ; + // InternalBehaviorAnnexParser.g:12470:1: rule__BooleanLiteral__Group__1__Impl : ( ( rule__BooleanLiteral__Alternatives_1 ) ) ; public final void rule__BooleanLiteral__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12447:1: ( ( ( rule__BooleanLiteral__Alternatives_1 ) ) ) - // InternalBehaviorAnnexParser.g:12448:1: ( ( rule__BooleanLiteral__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:12474:1: ( ( ( rule__BooleanLiteral__Alternatives_1 ) ) ) + // InternalBehaviorAnnexParser.g:12475:1: ( ( rule__BooleanLiteral__Alternatives_1 ) ) { - // InternalBehaviorAnnexParser.g:12448:1: ( ( rule__BooleanLiteral__Alternatives_1 ) ) - // InternalBehaviorAnnexParser.g:12449:2: ( rule__BooleanLiteral__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:12475:1: ( ( rule__BooleanLiteral__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:12476:2: ( rule__BooleanLiteral__Alternatives_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:12450:2: ( rule__BooleanLiteral__Alternatives_1 ) - // InternalBehaviorAnnexParser.g:12450:3: rule__BooleanLiteral__Alternatives_1 + // InternalBehaviorAnnexParser.g:12477:2: ( rule__BooleanLiteral__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:12477:3: rule__BooleanLiteral__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BooleanLiteral__Alternatives_1(); @@ -41420,14 +41515,14 @@ public final void rule__BooleanLiteral__Group__1__Impl() throws RecognitionExcep // $ANTLR start "rule__ReferenceTerm__Group__0" - // InternalBehaviorAnnexParser.g:12459:1: rule__ReferenceTerm__Group__0 : rule__ReferenceTerm__Group__0__Impl rule__ReferenceTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:12486:1: rule__ReferenceTerm__Group__0 : rule__ReferenceTerm__Group__0__Impl rule__ReferenceTerm__Group__1 ; public final void rule__ReferenceTerm__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12463:1: ( rule__ReferenceTerm__Group__0__Impl rule__ReferenceTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:12464:2: rule__ReferenceTerm__Group__0__Impl rule__ReferenceTerm__Group__1 + // InternalBehaviorAnnexParser.g:12490:1: ( rule__ReferenceTerm__Group__0__Impl rule__ReferenceTerm__Group__1 ) + // InternalBehaviorAnnexParser.g:12491:2: rule__ReferenceTerm__Group__0__Impl rule__ReferenceTerm__Group__1 { pushFollow(FollowSets000.FOLLOW_27); rule__ReferenceTerm__Group__0__Impl(); @@ -41458,17 +41553,17 @@ public final void rule__ReferenceTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__ReferenceTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12471:1: rule__ReferenceTerm__Group__0__Impl : ( Reference ) ; + // InternalBehaviorAnnexParser.g:12498:1: rule__ReferenceTerm__Group__0__Impl : ( Reference ) ; public final void rule__ReferenceTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12475:1: ( ( Reference ) ) - // InternalBehaviorAnnexParser.g:12476:1: ( Reference ) + // InternalBehaviorAnnexParser.g:12502:1: ( ( Reference ) ) + // InternalBehaviorAnnexParser.g:12503:1: ( Reference ) { - // InternalBehaviorAnnexParser.g:12476:1: ( Reference ) - // InternalBehaviorAnnexParser.g:12477:2: Reference + // InternalBehaviorAnnexParser.g:12503:1: ( Reference ) + // InternalBehaviorAnnexParser.g:12504:2: Reference { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getReferenceKeyword_0()); @@ -41499,14 +41594,14 @@ public final void rule__ReferenceTerm__Group__0__Impl() throws RecognitionExcept // $ANTLR start "rule__ReferenceTerm__Group__1" - // InternalBehaviorAnnexParser.g:12486:1: rule__ReferenceTerm__Group__1 : rule__ReferenceTerm__Group__1__Impl rule__ReferenceTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:12513:1: rule__ReferenceTerm__Group__1 : rule__ReferenceTerm__Group__1__Impl rule__ReferenceTerm__Group__2 ; public final void rule__ReferenceTerm__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12490:1: ( rule__ReferenceTerm__Group__1__Impl rule__ReferenceTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:12491:2: rule__ReferenceTerm__Group__1__Impl rule__ReferenceTerm__Group__2 + // InternalBehaviorAnnexParser.g:12517:1: ( rule__ReferenceTerm__Group__1__Impl rule__ReferenceTerm__Group__2 ) + // InternalBehaviorAnnexParser.g:12518:2: rule__ReferenceTerm__Group__1__Impl rule__ReferenceTerm__Group__2 { pushFollow(FollowSets000.FOLLOW_4); rule__ReferenceTerm__Group__1__Impl(); @@ -41537,17 +41632,17 @@ public final void rule__ReferenceTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__ReferenceTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12498:1: rule__ReferenceTerm__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12525:1: rule__ReferenceTerm__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__ReferenceTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12502:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12503:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12529:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12530:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12503:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12504:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12530:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12531:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getLeftParenthesisKeyword_1()); @@ -41578,14 +41673,14 @@ public final void rule__ReferenceTerm__Group__1__Impl() throws RecognitionExcept // $ANTLR start "rule__ReferenceTerm__Group__2" - // InternalBehaviorAnnexParser.g:12513:1: rule__ReferenceTerm__Group__2 : rule__ReferenceTerm__Group__2__Impl rule__ReferenceTerm__Group__3 ; + // InternalBehaviorAnnexParser.g:12540:1: rule__ReferenceTerm__Group__2 : rule__ReferenceTerm__Group__2__Impl rule__ReferenceTerm__Group__3 ; public final void rule__ReferenceTerm__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12517:1: ( rule__ReferenceTerm__Group__2__Impl rule__ReferenceTerm__Group__3 ) - // InternalBehaviorAnnexParser.g:12518:2: rule__ReferenceTerm__Group__2__Impl rule__ReferenceTerm__Group__3 + // InternalBehaviorAnnexParser.g:12544:1: ( rule__ReferenceTerm__Group__2__Impl rule__ReferenceTerm__Group__3 ) + // InternalBehaviorAnnexParser.g:12545:2: rule__ReferenceTerm__Group__2__Impl rule__ReferenceTerm__Group__3 { pushFollow(FollowSets000.FOLLOW_37); rule__ReferenceTerm__Group__2__Impl(); @@ -41616,23 +41711,23 @@ public final void rule__ReferenceTerm__Group__2() throws RecognitionException { // $ANTLR start "rule__ReferenceTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:12525:1: rule__ReferenceTerm__Group__2__Impl : ( ( rule__ReferenceTerm__PathAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:12552:1: rule__ReferenceTerm__Group__2__Impl : ( ( rule__ReferenceTerm__PathAssignment_2 ) ) ; public final void rule__ReferenceTerm__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12529:1: ( ( ( rule__ReferenceTerm__PathAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:12530:1: ( ( rule__ReferenceTerm__PathAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12556:1: ( ( ( rule__ReferenceTerm__PathAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:12557:1: ( ( rule__ReferenceTerm__PathAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:12530:1: ( ( rule__ReferenceTerm__PathAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:12531:2: ( rule__ReferenceTerm__PathAssignment_2 ) + // InternalBehaviorAnnexParser.g:12557:1: ( ( rule__ReferenceTerm__PathAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12558:2: ( rule__ReferenceTerm__PathAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getPathAssignment_2()); } - // InternalBehaviorAnnexParser.g:12532:2: ( rule__ReferenceTerm__PathAssignment_2 ) - // InternalBehaviorAnnexParser.g:12532:3: rule__ReferenceTerm__PathAssignment_2 + // InternalBehaviorAnnexParser.g:12559:2: ( rule__ReferenceTerm__PathAssignment_2 ) + // InternalBehaviorAnnexParser.g:12559:3: rule__ReferenceTerm__PathAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTerm__PathAssignment_2(); @@ -41667,14 +41762,14 @@ public final void rule__ReferenceTerm__Group__2__Impl() throws RecognitionExcept // $ANTLR start "rule__ReferenceTerm__Group__3" - // InternalBehaviorAnnexParser.g:12540:1: rule__ReferenceTerm__Group__3 : rule__ReferenceTerm__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:12567:1: rule__ReferenceTerm__Group__3 : rule__ReferenceTerm__Group__3__Impl ; public final void rule__ReferenceTerm__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12544:1: ( rule__ReferenceTerm__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:12545:2: rule__ReferenceTerm__Group__3__Impl + // InternalBehaviorAnnexParser.g:12571:1: ( rule__ReferenceTerm__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:12572:2: rule__ReferenceTerm__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTerm__Group__3__Impl(); @@ -41700,17 +41795,17 @@ public final void rule__ReferenceTerm__Group__3() throws RecognitionException { // $ANTLR start "rule__ReferenceTerm__Group__3__Impl" - // InternalBehaviorAnnexParser.g:12551:1: rule__ReferenceTerm__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12578:1: rule__ReferenceTerm__Group__3__Impl : ( RightParenthesis ) ; public final void rule__ReferenceTerm__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12555:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12556:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12582:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12583:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12556:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12557:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12583:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12584:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getRightParenthesisKeyword_3()); @@ -41741,14 +41836,14 @@ public final void rule__ReferenceTerm__Group__3__Impl() throws RecognitionExcept // $ANTLR start "rule__RecordTerm__Group__0" - // InternalBehaviorAnnexParser.g:12567:1: rule__RecordTerm__Group__0 : rule__RecordTerm__Group__0__Impl rule__RecordTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:12594:1: rule__RecordTerm__Group__0 : rule__RecordTerm__Group__0__Impl rule__RecordTerm__Group__1 ; public final void rule__RecordTerm__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12571:1: ( rule__RecordTerm__Group__0__Impl rule__RecordTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:12572:2: rule__RecordTerm__Group__0__Impl rule__RecordTerm__Group__1 + // InternalBehaviorAnnexParser.g:12598:1: ( rule__RecordTerm__Group__0__Impl rule__RecordTerm__Group__1 ) + // InternalBehaviorAnnexParser.g:12599:2: rule__RecordTerm__Group__0__Impl rule__RecordTerm__Group__1 { pushFollow(FollowSets000.FOLLOW_4); rule__RecordTerm__Group__0__Impl(); @@ -41779,17 +41874,17 @@ public final void rule__RecordTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__RecordTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12579:1: rule__RecordTerm__Group__0__Impl : ( LeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:12606:1: rule__RecordTerm__Group__0__Impl : ( LeftSquareBracket ) ; public final void rule__RecordTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12583:1: ( ( LeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:12584:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:12610:1: ( ( LeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:12611:1: ( LeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:12584:1: ( LeftSquareBracket ) - // InternalBehaviorAnnexParser.g:12585:2: LeftSquareBracket + // InternalBehaviorAnnexParser.g:12611:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:12612:2: LeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getLeftSquareBracketKeyword_0()); @@ -41820,14 +41915,14 @@ public final void rule__RecordTerm__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__RecordTerm__Group__1" - // InternalBehaviorAnnexParser.g:12594:1: rule__RecordTerm__Group__1 : rule__RecordTerm__Group__1__Impl rule__RecordTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:12621:1: rule__RecordTerm__Group__1 : rule__RecordTerm__Group__1__Impl rule__RecordTerm__Group__2 ; public final void rule__RecordTerm__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12598:1: ( rule__RecordTerm__Group__1__Impl rule__RecordTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:12599:2: rule__RecordTerm__Group__1__Impl rule__RecordTerm__Group__2 + // InternalBehaviorAnnexParser.g:12625:1: ( rule__RecordTerm__Group__1__Impl rule__RecordTerm__Group__2 ) + // InternalBehaviorAnnexParser.g:12626:2: rule__RecordTerm__Group__1__Impl rule__RecordTerm__Group__2 { pushFollow(FollowSets000.FOLLOW_14); rule__RecordTerm__Group__1__Impl(); @@ -41858,26 +41953,26 @@ public final void rule__RecordTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__RecordTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12606:1: rule__RecordTerm__Group__1__Impl : ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) ; + // InternalBehaviorAnnexParser.g:12633:1: rule__RecordTerm__Group__1__Impl : ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) ; public final void rule__RecordTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12610:1: ( ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) ) - // InternalBehaviorAnnexParser.g:12611:1: ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) + // InternalBehaviorAnnexParser.g:12637:1: ( ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) ) + // InternalBehaviorAnnexParser.g:12638:1: ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) { - // InternalBehaviorAnnexParser.g:12611:1: ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) - // InternalBehaviorAnnexParser.g:12612:2: ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:12638:1: ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) + // InternalBehaviorAnnexParser.g:12639:2: ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) { - // InternalBehaviorAnnexParser.g:12612:2: ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:12613:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:12639:2: ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:12640:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getOwnedFieldValueAssignment_1()); } - // InternalBehaviorAnnexParser.g:12614:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) - // InternalBehaviorAnnexParser.g:12614:4: rule__RecordTerm__OwnedFieldValueAssignment_1 + // InternalBehaviorAnnexParser.g:12641:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:12641:4: rule__RecordTerm__OwnedFieldValueAssignment_1 { pushFollow(FollowSets000.FOLLOW_5); rule__RecordTerm__OwnedFieldValueAssignment_1(); @@ -41893,26 +41988,26 @@ public final void rule__RecordTerm__Group__1__Impl() throws RecognitionException } - // InternalBehaviorAnnexParser.g:12617:2: ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) - // InternalBehaviorAnnexParser.g:12618:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* + // InternalBehaviorAnnexParser.g:12644:2: ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:12645:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getOwnedFieldValueAssignment_1()); } - // InternalBehaviorAnnexParser.g:12619:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* - loop108: + // InternalBehaviorAnnexParser.g:12646:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* + loop109: do { - int alt108=2; - int LA108_0 = input.LA(1); + int alt109=2; + int LA109_0 = input.LA(1); - if ( (LA108_0==RULE_ID) ) { - alt108=1; + if ( (LA109_0==RULE_ID) ) { + alt109=1; } - switch (alt108) { + switch (alt109) { case 1 : - // InternalBehaviorAnnexParser.g:12619:4: rule__RecordTerm__OwnedFieldValueAssignment_1 + // InternalBehaviorAnnexParser.g:12646:4: rule__RecordTerm__OwnedFieldValueAssignment_1 { pushFollow(FollowSets000.FOLLOW_5); rule__RecordTerm__OwnedFieldValueAssignment_1(); @@ -41924,7 +42019,7 @@ public final void rule__RecordTerm__Group__1__Impl() throws RecognitionException break; default : - break loop108; + break loop109; } } while (true); @@ -41956,14 +42051,14 @@ public final void rule__RecordTerm__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__RecordTerm__Group__2" - // InternalBehaviorAnnexParser.g:12628:1: rule__RecordTerm__Group__2 : rule__RecordTerm__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:12655:1: rule__RecordTerm__Group__2 : rule__RecordTerm__Group__2__Impl ; public final void rule__RecordTerm__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12632:1: ( rule__RecordTerm__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:12633:2: rule__RecordTerm__Group__2__Impl + // InternalBehaviorAnnexParser.g:12659:1: ( rule__RecordTerm__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:12660:2: rule__RecordTerm__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__RecordTerm__Group__2__Impl(); @@ -41989,17 +42084,17 @@ public final void rule__RecordTerm__Group__2() throws RecognitionException { // $ANTLR start "rule__RecordTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:12639:1: rule__RecordTerm__Group__2__Impl : ( RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:12666:1: rule__RecordTerm__Group__2__Impl : ( RightSquareBracket ) ; public final void rule__RecordTerm__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12643:1: ( ( RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:12644:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:12670:1: ( ( RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:12671:1: ( RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:12644:1: ( RightSquareBracket ) - // InternalBehaviorAnnexParser.g:12645:2: RightSquareBracket + // InternalBehaviorAnnexParser.g:12671:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:12672:2: RightSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getRightSquareBracketKeyword_2()); @@ -42030,14 +42125,14 @@ public final void rule__RecordTerm__Group__2__Impl() throws RecognitionException // $ANTLR start "rule__ComputedTerm__Group__0" - // InternalBehaviorAnnexParser.g:12655:1: rule__ComputedTerm__Group__0 : rule__ComputedTerm__Group__0__Impl rule__ComputedTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:12682:1: rule__ComputedTerm__Group__0 : rule__ComputedTerm__Group__0__Impl rule__ComputedTerm__Group__1 ; public final void rule__ComputedTerm__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12659:1: ( rule__ComputedTerm__Group__0__Impl rule__ComputedTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:12660:2: rule__ComputedTerm__Group__0__Impl rule__ComputedTerm__Group__1 + // InternalBehaviorAnnexParser.g:12686:1: ( rule__ComputedTerm__Group__0__Impl rule__ComputedTerm__Group__1 ) + // InternalBehaviorAnnexParser.g:12687:2: rule__ComputedTerm__Group__0__Impl rule__ComputedTerm__Group__1 { pushFollow(FollowSets000.FOLLOW_27); rule__ComputedTerm__Group__0__Impl(); @@ -42068,17 +42163,17 @@ public final void rule__ComputedTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__ComputedTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12667:1: rule__ComputedTerm__Group__0__Impl : ( Compute ) ; + // InternalBehaviorAnnexParser.g:12694:1: rule__ComputedTerm__Group__0__Impl : ( Compute ) ; public final void rule__ComputedTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12671:1: ( ( Compute ) ) - // InternalBehaviorAnnexParser.g:12672:1: ( Compute ) + // InternalBehaviorAnnexParser.g:12698:1: ( ( Compute ) ) + // InternalBehaviorAnnexParser.g:12699:1: ( Compute ) { - // InternalBehaviorAnnexParser.g:12672:1: ( Compute ) - // InternalBehaviorAnnexParser.g:12673:2: Compute + // InternalBehaviorAnnexParser.g:12699:1: ( Compute ) + // InternalBehaviorAnnexParser.g:12700:2: Compute { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getComputeKeyword_0()); @@ -42109,14 +42204,14 @@ public final void rule__ComputedTerm__Group__0__Impl() throws RecognitionExcepti // $ANTLR start "rule__ComputedTerm__Group__1" - // InternalBehaviorAnnexParser.g:12682:1: rule__ComputedTerm__Group__1 : rule__ComputedTerm__Group__1__Impl rule__ComputedTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:12709:1: rule__ComputedTerm__Group__1 : rule__ComputedTerm__Group__1__Impl rule__ComputedTerm__Group__2 ; public final void rule__ComputedTerm__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12686:1: ( rule__ComputedTerm__Group__1__Impl rule__ComputedTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:12687:2: rule__ComputedTerm__Group__1__Impl rule__ComputedTerm__Group__2 + // InternalBehaviorAnnexParser.g:12713:1: ( rule__ComputedTerm__Group__1__Impl rule__ComputedTerm__Group__2 ) + // InternalBehaviorAnnexParser.g:12714:2: rule__ComputedTerm__Group__1__Impl rule__ComputedTerm__Group__2 { pushFollow(FollowSets000.FOLLOW_4); rule__ComputedTerm__Group__1__Impl(); @@ -42147,17 +42242,17 @@ public final void rule__ComputedTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__ComputedTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12694:1: rule__ComputedTerm__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12721:1: rule__ComputedTerm__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__ComputedTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12698:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12699:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12725:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12726:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12699:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12700:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12726:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12727:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getLeftParenthesisKeyword_1()); @@ -42188,14 +42283,14 @@ public final void rule__ComputedTerm__Group__1__Impl() throws RecognitionExcepti // $ANTLR start "rule__ComputedTerm__Group__2" - // InternalBehaviorAnnexParser.g:12709:1: rule__ComputedTerm__Group__2 : rule__ComputedTerm__Group__2__Impl rule__ComputedTerm__Group__3 ; + // InternalBehaviorAnnexParser.g:12736:1: rule__ComputedTerm__Group__2 : rule__ComputedTerm__Group__2__Impl rule__ComputedTerm__Group__3 ; public final void rule__ComputedTerm__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12713:1: ( rule__ComputedTerm__Group__2__Impl rule__ComputedTerm__Group__3 ) - // InternalBehaviorAnnexParser.g:12714:2: rule__ComputedTerm__Group__2__Impl rule__ComputedTerm__Group__3 + // InternalBehaviorAnnexParser.g:12740:1: ( rule__ComputedTerm__Group__2__Impl rule__ComputedTerm__Group__3 ) + // InternalBehaviorAnnexParser.g:12741:2: rule__ComputedTerm__Group__2__Impl rule__ComputedTerm__Group__3 { pushFollow(FollowSets000.FOLLOW_37); rule__ComputedTerm__Group__2__Impl(); @@ -42226,23 +42321,23 @@ public final void rule__ComputedTerm__Group__2() throws RecognitionException { // $ANTLR start "rule__ComputedTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:12721:1: rule__ComputedTerm__Group__2__Impl : ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:12748:1: rule__ComputedTerm__Group__2__Impl : ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) ; public final void rule__ComputedTerm__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12725:1: ( ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:12726:1: ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12752:1: ( ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:12753:1: ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:12726:1: ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:12727:2: ( rule__ComputedTerm__FunctionAssignment_2 ) + // InternalBehaviorAnnexParser.g:12753:1: ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12754:2: ( rule__ComputedTerm__FunctionAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getFunctionAssignment_2()); } - // InternalBehaviorAnnexParser.g:12728:2: ( rule__ComputedTerm__FunctionAssignment_2 ) - // InternalBehaviorAnnexParser.g:12728:3: rule__ComputedTerm__FunctionAssignment_2 + // InternalBehaviorAnnexParser.g:12755:2: ( rule__ComputedTerm__FunctionAssignment_2 ) + // InternalBehaviorAnnexParser.g:12755:3: rule__ComputedTerm__FunctionAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ComputedTerm__FunctionAssignment_2(); @@ -42277,14 +42372,14 @@ public final void rule__ComputedTerm__Group__2__Impl() throws RecognitionExcepti // $ANTLR start "rule__ComputedTerm__Group__3" - // InternalBehaviorAnnexParser.g:12736:1: rule__ComputedTerm__Group__3 : rule__ComputedTerm__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:12763:1: rule__ComputedTerm__Group__3 : rule__ComputedTerm__Group__3__Impl ; public final void rule__ComputedTerm__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12740:1: ( rule__ComputedTerm__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:12741:2: rule__ComputedTerm__Group__3__Impl + // InternalBehaviorAnnexParser.g:12767:1: ( rule__ComputedTerm__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:12768:2: rule__ComputedTerm__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ComputedTerm__Group__3__Impl(); @@ -42310,17 +42405,17 @@ public final void rule__ComputedTerm__Group__3() throws RecognitionException { // $ANTLR start "rule__ComputedTerm__Group__3__Impl" - // InternalBehaviorAnnexParser.g:12747:1: rule__ComputedTerm__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12774:1: rule__ComputedTerm__Group__3__Impl : ( RightParenthesis ) ; public final void rule__ComputedTerm__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12751:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12752:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12778:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12779:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12752:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12753:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12779:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12780:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getRightParenthesisKeyword_3()); @@ -42351,14 +42446,14 @@ public final void rule__ComputedTerm__Group__3__Impl() throws RecognitionExcepti // $ANTLR start "rule__ComponentClassifierTerm__Group__0" - // InternalBehaviorAnnexParser.g:12763:1: rule__ComponentClassifierTerm__Group__0 : rule__ComponentClassifierTerm__Group__0__Impl rule__ComponentClassifierTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:12790:1: rule__ComponentClassifierTerm__Group__0 : rule__ComponentClassifierTerm__Group__0__Impl rule__ComponentClassifierTerm__Group__1 ; public final void rule__ComponentClassifierTerm__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12767:1: ( rule__ComponentClassifierTerm__Group__0__Impl rule__ComponentClassifierTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:12768:2: rule__ComponentClassifierTerm__Group__0__Impl rule__ComponentClassifierTerm__Group__1 + // InternalBehaviorAnnexParser.g:12794:1: ( rule__ComponentClassifierTerm__Group__0__Impl rule__ComponentClassifierTerm__Group__1 ) + // InternalBehaviorAnnexParser.g:12795:2: rule__ComponentClassifierTerm__Group__0__Impl rule__ComponentClassifierTerm__Group__1 { pushFollow(FollowSets000.FOLLOW_27); rule__ComponentClassifierTerm__Group__0__Impl(); @@ -42389,17 +42484,17 @@ public final void rule__ComponentClassifierTerm__Group__0() throws RecognitionEx // $ANTLR start "rule__ComponentClassifierTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12775:1: rule__ComponentClassifierTerm__Group__0__Impl : ( Classifier ) ; + // InternalBehaviorAnnexParser.g:12802:1: rule__ComponentClassifierTerm__Group__0__Impl : ( Classifier ) ; public final void rule__ComponentClassifierTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12779:1: ( ( Classifier ) ) - // InternalBehaviorAnnexParser.g:12780:1: ( Classifier ) + // InternalBehaviorAnnexParser.g:12806:1: ( ( Classifier ) ) + // InternalBehaviorAnnexParser.g:12807:1: ( Classifier ) { - // InternalBehaviorAnnexParser.g:12780:1: ( Classifier ) - // InternalBehaviorAnnexParser.g:12781:2: Classifier + // InternalBehaviorAnnexParser.g:12807:1: ( Classifier ) + // InternalBehaviorAnnexParser.g:12808:2: Classifier { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getClassifierKeyword_0()); @@ -42430,14 +42525,14 @@ public final void rule__ComponentClassifierTerm__Group__0__Impl() throws Recogni // $ANTLR start "rule__ComponentClassifierTerm__Group__1" - // InternalBehaviorAnnexParser.g:12790:1: rule__ComponentClassifierTerm__Group__1 : rule__ComponentClassifierTerm__Group__1__Impl rule__ComponentClassifierTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:12817:1: rule__ComponentClassifierTerm__Group__1 : rule__ComponentClassifierTerm__Group__1__Impl rule__ComponentClassifierTerm__Group__2 ; public final void rule__ComponentClassifierTerm__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12794:1: ( rule__ComponentClassifierTerm__Group__1__Impl rule__ComponentClassifierTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:12795:2: rule__ComponentClassifierTerm__Group__1__Impl rule__ComponentClassifierTerm__Group__2 + // InternalBehaviorAnnexParser.g:12821:1: ( rule__ComponentClassifierTerm__Group__1__Impl rule__ComponentClassifierTerm__Group__2 ) + // InternalBehaviorAnnexParser.g:12822:2: rule__ComponentClassifierTerm__Group__1__Impl rule__ComponentClassifierTerm__Group__2 { pushFollow(FollowSets000.FOLLOW_4); rule__ComponentClassifierTerm__Group__1__Impl(); @@ -42468,17 +42563,17 @@ public final void rule__ComponentClassifierTerm__Group__1() throws RecognitionEx // $ANTLR start "rule__ComponentClassifierTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12802:1: rule__ComponentClassifierTerm__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12829:1: rule__ComponentClassifierTerm__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__ComponentClassifierTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12806:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12807:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12833:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12834:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12807:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12808:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12834:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12835:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getLeftParenthesisKeyword_1()); @@ -42509,14 +42604,14 @@ public final void rule__ComponentClassifierTerm__Group__1__Impl() throws Recogni // $ANTLR start "rule__ComponentClassifierTerm__Group__2" - // InternalBehaviorAnnexParser.g:12817:1: rule__ComponentClassifierTerm__Group__2 : rule__ComponentClassifierTerm__Group__2__Impl rule__ComponentClassifierTerm__Group__3 ; + // InternalBehaviorAnnexParser.g:12844:1: rule__ComponentClassifierTerm__Group__2 : rule__ComponentClassifierTerm__Group__2__Impl rule__ComponentClassifierTerm__Group__3 ; public final void rule__ComponentClassifierTerm__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12821:1: ( rule__ComponentClassifierTerm__Group__2__Impl rule__ComponentClassifierTerm__Group__3 ) - // InternalBehaviorAnnexParser.g:12822:2: rule__ComponentClassifierTerm__Group__2__Impl rule__ComponentClassifierTerm__Group__3 + // InternalBehaviorAnnexParser.g:12848:1: ( rule__ComponentClassifierTerm__Group__2__Impl rule__ComponentClassifierTerm__Group__3 ) + // InternalBehaviorAnnexParser.g:12849:2: rule__ComponentClassifierTerm__Group__2__Impl rule__ComponentClassifierTerm__Group__3 { pushFollow(FollowSets000.FOLLOW_37); rule__ComponentClassifierTerm__Group__2__Impl(); @@ -42547,23 +42642,23 @@ public final void rule__ComponentClassifierTerm__Group__2() throws RecognitionEx // $ANTLR start "rule__ComponentClassifierTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:12829:1: rule__ComponentClassifierTerm__Group__2__Impl : ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:12856:1: rule__ComponentClassifierTerm__Group__2__Impl : ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) ; public final void rule__ComponentClassifierTerm__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12833:1: ( ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:12834:1: ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12860:1: ( ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:12861:1: ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:12834:1: ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:12835:2: ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) + // InternalBehaviorAnnexParser.g:12861:1: ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12862:2: ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getClassifierAssignment_2()); } - // InternalBehaviorAnnexParser.g:12836:2: ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) - // InternalBehaviorAnnexParser.g:12836:3: rule__ComponentClassifierTerm__ClassifierAssignment_2 + // InternalBehaviorAnnexParser.g:12863:2: ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) + // InternalBehaviorAnnexParser.g:12863:3: rule__ComponentClassifierTerm__ClassifierAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ComponentClassifierTerm__ClassifierAssignment_2(); @@ -42598,14 +42693,14 @@ public final void rule__ComponentClassifierTerm__Group__2__Impl() throws Recogni // $ANTLR start "rule__ComponentClassifierTerm__Group__3" - // InternalBehaviorAnnexParser.g:12844:1: rule__ComponentClassifierTerm__Group__3 : rule__ComponentClassifierTerm__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:12871:1: rule__ComponentClassifierTerm__Group__3 : rule__ComponentClassifierTerm__Group__3__Impl ; public final void rule__ComponentClassifierTerm__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12848:1: ( rule__ComponentClassifierTerm__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:12849:2: rule__ComponentClassifierTerm__Group__3__Impl + // InternalBehaviorAnnexParser.g:12875:1: ( rule__ComponentClassifierTerm__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:12876:2: rule__ComponentClassifierTerm__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ComponentClassifierTerm__Group__3__Impl(); @@ -42631,17 +42726,17 @@ public final void rule__ComponentClassifierTerm__Group__3() throws RecognitionEx // $ANTLR start "rule__ComponentClassifierTerm__Group__3__Impl" - // InternalBehaviorAnnexParser.g:12855:1: rule__ComponentClassifierTerm__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12882:1: rule__ComponentClassifierTerm__Group__3__Impl : ( RightParenthesis ) ; public final void rule__ComponentClassifierTerm__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12859:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12860:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12886:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12887:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12860:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12861:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12887:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12888:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getRightParenthesisKeyword_3()); @@ -42672,14 +42767,14 @@ public final void rule__ComponentClassifierTerm__Group__3__Impl() throws Recogni // $ANTLR start "rule__ListTerm__Group__0" - // InternalBehaviorAnnexParser.g:12871:1: rule__ListTerm__Group__0 : rule__ListTerm__Group__0__Impl rule__ListTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:12898:1: rule__ListTerm__Group__0 : rule__ListTerm__Group__0__Impl rule__ListTerm__Group__1 ; public final void rule__ListTerm__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12875:1: ( rule__ListTerm__Group__0__Impl rule__ListTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:12876:2: rule__ListTerm__Group__0__Impl rule__ListTerm__Group__1 + // InternalBehaviorAnnexParser.g:12902:1: ( rule__ListTerm__Group__0__Impl rule__ListTerm__Group__1 ) + // InternalBehaviorAnnexParser.g:12903:2: rule__ListTerm__Group__0__Impl rule__ListTerm__Group__1 { pushFollow(FollowSets000.FOLLOW_27); rule__ListTerm__Group__0__Impl(); @@ -42710,23 +42805,23 @@ public final void rule__ListTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12883:1: rule__ListTerm__Group__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:12910:1: rule__ListTerm__Group__0__Impl : ( () ) ; public final void rule__ListTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12887:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:12888:1: ( () ) + // InternalBehaviorAnnexParser.g:12914:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:12915:1: ( () ) { - // InternalBehaviorAnnexParser.g:12888:1: ( () ) - // InternalBehaviorAnnexParser.g:12889:2: () + // InternalBehaviorAnnexParser.g:12915:1: ( () ) + // InternalBehaviorAnnexParser.g:12916:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getListValueAction_0()); } - // InternalBehaviorAnnexParser.g:12890:2: () - // InternalBehaviorAnnexParser.g:12890:3: + // InternalBehaviorAnnexParser.g:12917:2: () + // InternalBehaviorAnnexParser.g:12917:3: { } @@ -42751,14 +42846,14 @@ public final void rule__ListTerm__Group__0__Impl() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__1" - // InternalBehaviorAnnexParser.g:12898:1: rule__ListTerm__Group__1 : rule__ListTerm__Group__1__Impl rule__ListTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:12925:1: rule__ListTerm__Group__1 : rule__ListTerm__Group__1__Impl rule__ListTerm__Group__2 ; public final void rule__ListTerm__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12902:1: ( rule__ListTerm__Group__1__Impl rule__ListTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:12903:2: rule__ListTerm__Group__1__Impl rule__ListTerm__Group__2 + // InternalBehaviorAnnexParser.g:12929:1: ( rule__ListTerm__Group__1__Impl rule__ListTerm__Group__2 ) + // InternalBehaviorAnnexParser.g:12930:2: rule__ListTerm__Group__1__Impl rule__ListTerm__Group__2 { pushFollow(FollowSets000.FOLLOW_86); rule__ListTerm__Group__1__Impl(); @@ -42789,17 +42884,17 @@ public final void rule__ListTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12910:1: rule__ListTerm__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12937:1: rule__ListTerm__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__ListTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12914:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12915:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12941:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12942:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12915:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12916:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12942:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12943:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getLeftParenthesisKeyword_1()); @@ -42830,14 +42925,14 @@ public final void rule__ListTerm__Group__1__Impl() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__2" - // InternalBehaviorAnnexParser.g:12925:1: rule__ListTerm__Group__2 : rule__ListTerm__Group__2__Impl rule__ListTerm__Group__3 ; + // InternalBehaviorAnnexParser.g:12952:1: rule__ListTerm__Group__2 : rule__ListTerm__Group__2__Impl rule__ListTerm__Group__3 ; public final void rule__ListTerm__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12929:1: ( rule__ListTerm__Group__2__Impl rule__ListTerm__Group__3 ) - // InternalBehaviorAnnexParser.g:12930:2: rule__ListTerm__Group__2__Impl rule__ListTerm__Group__3 + // InternalBehaviorAnnexParser.g:12956:1: ( rule__ListTerm__Group__2__Impl rule__ListTerm__Group__3 ) + // InternalBehaviorAnnexParser.g:12957:2: rule__ListTerm__Group__2__Impl rule__ListTerm__Group__3 { pushFollow(FollowSets000.FOLLOW_86); rule__ListTerm__Group__2__Impl(); @@ -42868,31 +42963,31 @@ public final void rule__ListTerm__Group__2() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:12937:1: rule__ListTerm__Group__2__Impl : ( ( rule__ListTerm__Group_2__0 )? ) ; + // InternalBehaviorAnnexParser.g:12964:1: rule__ListTerm__Group__2__Impl : ( ( rule__ListTerm__Group_2__0 )? ) ; public final void rule__ListTerm__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12941:1: ( ( ( rule__ListTerm__Group_2__0 )? ) ) - // InternalBehaviorAnnexParser.g:12942:1: ( ( rule__ListTerm__Group_2__0 )? ) + // InternalBehaviorAnnexParser.g:12968:1: ( ( ( rule__ListTerm__Group_2__0 )? ) ) + // InternalBehaviorAnnexParser.g:12969:1: ( ( rule__ListTerm__Group_2__0 )? ) { - // InternalBehaviorAnnexParser.g:12942:1: ( ( rule__ListTerm__Group_2__0 )? ) - // InternalBehaviorAnnexParser.g:12943:2: ( rule__ListTerm__Group_2__0 )? + // InternalBehaviorAnnexParser.g:12969:1: ( ( rule__ListTerm__Group_2__0 )? ) + // InternalBehaviorAnnexParser.g:12970:2: ( rule__ListTerm__Group_2__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getGroup_2()); } - // InternalBehaviorAnnexParser.g:12944:2: ( rule__ListTerm__Group_2__0 )? - int alt109=2; - int LA109_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:12971:2: ( rule__ListTerm__Group_2__0 )? + int alt110=2; + int LA110_0 = input.LA(1); - if ( (LA109_0==Classifier||LA109_0==Reference||LA109_0==Compute||LA109_0==False||LA109_0==True||LA109_0==LeftParenthesis||LA109_0==PlusSign||LA109_0==HyphenMinus||LA109_0==LeftSquareBracket||LA109_0==RULE_REAL_LIT||LA109_0==RULE_INTEGER_LIT||(LA109_0>=RULE_STRING && LA109_0<=RULE_ID)) ) { - alt109=1; + if ( (LA110_0==Classifier||LA110_0==Reference||LA110_0==Compute||LA110_0==False||LA110_0==True||LA110_0==LeftParenthesis||LA110_0==PlusSign||LA110_0==HyphenMinus||LA110_0==LeftSquareBracket||LA110_0==RULE_REAL_LIT||LA110_0==RULE_INTEGER_LIT||(LA110_0>=RULE_STRING && LA110_0<=RULE_ID)) ) { + alt110=1; } - switch (alt109) { + switch (alt110) { case 1 : - // InternalBehaviorAnnexParser.g:12944:3: rule__ListTerm__Group_2__0 + // InternalBehaviorAnnexParser.g:12971:3: rule__ListTerm__Group_2__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__Group_2__0(); @@ -42930,14 +43025,14 @@ public final void rule__ListTerm__Group__2__Impl() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__3" - // InternalBehaviorAnnexParser.g:12952:1: rule__ListTerm__Group__3 : rule__ListTerm__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:12979:1: rule__ListTerm__Group__3 : rule__ListTerm__Group__3__Impl ; public final void rule__ListTerm__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12956:1: ( rule__ListTerm__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:12957:2: rule__ListTerm__Group__3__Impl + // InternalBehaviorAnnexParser.g:12983:1: ( rule__ListTerm__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:12984:2: rule__ListTerm__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__Group__3__Impl(); @@ -42963,17 +43058,17 @@ public final void rule__ListTerm__Group__3() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__3__Impl" - // InternalBehaviorAnnexParser.g:12963:1: rule__ListTerm__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12990:1: rule__ListTerm__Group__3__Impl : ( RightParenthesis ) ; public final void rule__ListTerm__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12967:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12968:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12994:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12995:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12968:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12969:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12995:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12996:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getRightParenthesisKeyword_3()); @@ -43004,14 +43099,14 @@ public final void rule__ListTerm__Group__3__Impl() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group_2__0" - // InternalBehaviorAnnexParser.g:12979:1: rule__ListTerm__Group_2__0 : rule__ListTerm__Group_2__0__Impl rule__ListTerm__Group_2__1 ; + // InternalBehaviorAnnexParser.g:13006:1: rule__ListTerm__Group_2__0 : rule__ListTerm__Group_2__0__Impl rule__ListTerm__Group_2__1 ; public final void rule__ListTerm__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12983:1: ( rule__ListTerm__Group_2__0__Impl rule__ListTerm__Group_2__1 ) - // InternalBehaviorAnnexParser.g:12984:2: rule__ListTerm__Group_2__0__Impl rule__ListTerm__Group_2__1 + // InternalBehaviorAnnexParser.g:13010:1: ( rule__ListTerm__Group_2__0__Impl rule__ListTerm__Group_2__1 ) + // InternalBehaviorAnnexParser.g:13011:2: rule__ListTerm__Group_2__0__Impl rule__ListTerm__Group_2__1 { pushFollow(FollowSets000.FOLLOW_83); rule__ListTerm__Group_2__0__Impl(); @@ -43042,23 +43137,23 @@ public final void rule__ListTerm__Group_2__0() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group_2__0__Impl" - // InternalBehaviorAnnexParser.g:12991:1: rule__ListTerm__Group_2__0__Impl : ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) ; + // InternalBehaviorAnnexParser.g:13018:1: rule__ListTerm__Group_2__0__Impl : ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) ; public final void rule__ListTerm__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12995:1: ( ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) ) - // InternalBehaviorAnnexParser.g:12996:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) + // InternalBehaviorAnnexParser.g:13022:1: ( ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) ) + // InternalBehaviorAnnexParser.g:13023:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) { - // InternalBehaviorAnnexParser.g:12996:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) - // InternalBehaviorAnnexParser.g:12997:2: ( rule__ListTerm__OwnedListElementAssignment_2_0 ) + // InternalBehaviorAnnexParser.g:13023:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) + // InternalBehaviorAnnexParser.g:13024:2: ( rule__ListTerm__OwnedListElementAssignment_2_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getOwnedListElementAssignment_2_0()); } - // InternalBehaviorAnnexParser.g:12998:2: ( rule__ListTerm__OwnedListElementAssignment_2_0 ) - // InternalBehaviorAnnexParser.g:12998:3: rule__ListTerm__OwnedListElementAssignment_2_0 + // InternalBehaviorAnnexParser.g:13025:2: ( rule__ListTerm__OwnedListElementAssignment_2_0 ) + // InternalBehaviorAnnexParser.g:13025:3: rule__ListTerm__OwnedListElementAssignment_2_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__OwnedListElementAssignment_2_0(); @@ -43093,14 +43188,14 @@ public final void rule__ListTerm__Group_2__0__Impl() throws RecognitionException // $ANTLR start "rule__ListTerm__Group_2__1" - // InternalBehaviorAnnexParser.g:13006:1: rule__ListTerm__Group_2__1 : rule__ListTerm__Group_2__1__Impl ; + // InternalBehaviorAnnexParser.g:13033:1: rule__ListTerm__Group_2__1 : rule__ListTerm__Group_2__1__Impl ; public final void rule__ListTerm__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13010:1: ( rule__ListTerm__Group_2__1__Impl ) - // InternalBehaviorAnnexParser.g:13011:2: rule__ListTerm__Group_2__1__Impl + // InternalBehaviorAnnexParser.g:13037:1: ( rule__ListTerm__Group_2__1__Impl ) + // InternalBehaviorAnnexParser.g:13038:2: rule__ListTerm__Group_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__Group_2__1__Impl(); @@ -43126,35 +43221,35 @@ public final void rule__ListTerm__Group_2__1() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group_2__1__Impl" - // InternalBehaviorAnnexParser.g:13017:1: rule__ListTerm__Group_2__1__Impl : ( ( rule__ListTerm__Group_2_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:13044:1: rule__ListTerm__Group_2__1__Impl : ( ( rule__ListTerm__Group_2_1__0 )* ) ; public final void rule__ListTerm__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13021:1: ( ( ( rule__ListTerm__Group_2_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:13022:1: ( ( rule__ListTerm__Group_2_1__0 )* ) + // InternalBehaviorAnnexParser.g:13048:1: ( ( ( rule__ListTerm__Group_2_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:13049:1: ( ( rule__ListTerm__Group_2_1__0 )* ) { - // InternalBehaviorAnnexParser.g:13022:1: ( ( rule__ListTerm__Group_2_1__0 )* ) - // InternalBehaviorAnnexParser.g:13023:2: ( rule__ListTerm__Group_2_1__0 )* + // InternalBehaviorAnnexParser.g:13049:1: ( ( rule__ListTerm__Group_2_1__0 )* ) + // InternalBehaviorAnnexParser.g:13050:2: ( rule__ListTerm__Group_2_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getGroup_2_1()); } - // InternalBehaviorAnnexParser.g:13024:2: ( rule__ListTerm__Group_2_1__0 )* - loop110: + // InternalBehaviorAnnexParser.g:13051:2: ( rule__ListTerm__Group_2_1__0 )* + loop111: do { - int alt110=2; - int LA110_0 = input.LA(1); + int alt111=2; + int LA111_0 = input.LA(1); - if ( (LA110_0==Comma) ) { - alt110=1; + if ( (LA111_0==Comma) ) { + alt111=1; } - switch (alt110) { + switch (alt111) { case 1 : - // InternalBehaviorAnnexParser.g:13024:3: rule__ListTerm__Group_2_1__0 + // InternalBehaviorAnnexParser.g:13051:3: rule__ListTerm__Group_2_1__0 { pushFollow(FollowSets000.FOLLOW_7); rule__ListTerm__Group_2_1__0(); @@ -43166,7 +43261,7 @@ public final void rule__ListTerm__Group_2__1__Impl() throws RecognitionException break; default : - break loop110; + break loop111; } } while (true); @@ -43195,14 +43290,14 @@ public final void rule__ListTerm__Group_2__1__Impl() throws RecognitionException // $ANTLR start "rule__ListTerm__Group_2_1__0" - // InternalBehaviorAnnexParser.g:13033:1: rule__ListTerm__Group_2_1__0 : rule__ListTerm__Group_2_1__0__Impl rule__ListTerm__Group_2_1__1 ; + // InternalBehaviorAnnexParser.g:13060:1: rule__ListTerm__Group_2_1__0 : rule__ListTerm__Group_2_1__0__Impl rule__ListTerm__Group_2_1__1 ; public final void rule__ListTerm__Group_2_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13037:1: ( rule__ListTerm__Group_2_1__0__Impl rule__ListTerm__Group_2_1__1 ) - // InternalBehaviorAnnexParser.g:13038:2: rule__ListTerm__Group_2_1__0__Impl rule__ListTerm__Group_2_1__1 + // InternalBehaviorAnnexParser.g:13064:1: ( rule__ListTerm__Group_2_1__0__Impl rule__ListTerm__Group_2_1__1 ) + // InternalBehaviorAnnexParser.g:13065:2: rule__ListTerm__Group_2_1__0__Impl rule__ListTerm__Group_2_1__1 { pushFollow(FollowSets000.FOLLOW_16); rule__ListTerm__Group_2_1__0__Impl(); @@ -43233,17 +43328,17 @@ public final void rule__ListTerm__Group_2_1__0() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group_2_1__0__Impl" - // InternalBehaviorAnnexParser.g:13045:1: rule__ListTerm__Group_2_1__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:13072:1: rule__ListTerm__Group_2_1__0__Impl : ( Comma ) ; public final void rule__ListTerm__Group_2_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13049:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:13050:1: ( Comma ) + // InternalBehaviorAnnexParser.g:13076:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:13077:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:13050:1: ( Comma ) - // InternalBehaviorAnnexParser.g:13051:2: Comma + // InternalBehaviorAnnexParser.g:13077:1: ( Comma ) + // InternalBehaviorAnnexParser.g:13078:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getCommaKeyword_2_1_0()); @@ -43274,14 +43369,14 @@ public final void rule__ListTerm__Group_2_1__0__Impl() throws RecognitionExcepti // $ANTLR start "rule__ListTerm__Group_2_1__1" - // InternalBehaviorAnnexParser.g:13060:1: rule__ListTerm__Group_2_1__1 : rule__ListTerm__Group_2_1__1__Impl ; + // InternalBehaviorAnnexParser.g:13087:1: rule__ListTerm__Group_2_1__1 : rule__ListTerm__Group_2_1__1__Impl ; public final void rule__ListTerm__Group_2_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13064:1: ( rule__ListTerm__Group_2_1__1__Impl ) - // InternalBehaviorAnnexParser.g:13065:2: rule__ListTerm__Group_2_1__1__Impl + // InternalBehaviorAnnexParser.g:13091:1: ( rule__ListTerm__Group_2_1__1__Impl ) + // InternalBehaviorAnnexParser.g:13092:2: rule__ListTerm__Group_2_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__Group_2_1__1__Impl(); @@ -43307,23 +43402,23 @@ public final void rule__ListTerm__Group_2_1__1() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group_2_1__1__Impl" - // InternalBehaviorAnnexParser.g:13071:1: rule__ListTerm__Group_2_1__1__Impl : ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:13098:1: rule__ListTerm__Group_2_1__1__Impl : ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) ; public final void rule__ListTerm__Group_2_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13075:1: ( ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:13076:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) + // InternalBehaviorAnnexParser.g:13102:1: ( ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:13103:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) { - // InternalBehaviorAnnexParser.g:13076:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) - // InternalBehaviorAnnexParser.g:13077:2: ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) + // InternalBehaviorAnnexParser.g:13103:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) + // InternalBehaviorAnnexParser.g:13104:2: ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getOwnedListElementAssignment_2_1_1()); } - // InternalBehaviorAnnexParser.g:13078:2: ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) - // InternalBehaviorAnnexParser.g:13078:3: rule__ListTerm__OwnedListElementAssignment_2_1_1 + // InternalBehaviorAnnexParser.g:13105:2: ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) + // InternalBehaviorAnnexParser.g:13105:3: rule__ListTerm__OwnedListElementAssignment_2_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__OwnedListElementAssignment_2_1_1(); @@ -43358,14 +43453,14 @@ public final void rule__ListTerm__Group_2_1__1__Impl() throws RecognitionExcepti // $ANTLR start "rule__FieldPropertyAssociation__Group__0" - // InternalBehaviorAnnexParser.g:13087:1: rule__FieldPropertyAssociation__Group__0 : rule__FieldPropertyAssociation__Group__0__Impl rule__FieldPropertyAssociation__Group__1 ; + // InternalBehaviorAnnexParser.g:13114:1: rule__FieldPropertyAssociation__Group__0 : rule__FieldPropertyAssociation__Group__0__Impl rule__FieldPropertyAssociation__Group__1 ; public final void rule__FieldPropertyAssociation__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13091:1: ( rule__FieldPropertyAssociation__Group__0__Impl rule__FieldPropertyAssociation__Group__1 ) - // InternalBehaviorAnnexParser.g:13092:2: rule__FieldPropertyAssociation__Group__0__Impl rule__FieldPropertyAssociation__Group__1 + // InternalBehaviorAnnexParser.g:13118:1: ( rule__FieldPropertyAssociation__Group__0__Impl rule__FieldPropertyAssociation__Group__1 ) + // InternalBehaviorAnnexParser.g:13119:2: rule__FieldPropertyAssociation__Group__0__Impl rule__FieldPropertyAssociation__Group__1 { pushFollow(FollowSets000.FOLLOW_15); rule__FieldPropertyAssociation__Group__0__Impl(); @@ -43396,23 +43491,23 @@ public final void rule__FieldPropertyAssociation__Group__0() throws RecognitionE // $ANTLR start "rule__FieldPropertyAssociation__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13099:1: rule__FieldPropertyAssociation__Group__0__Impl : ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:13126:1: rule__FieldPropertyAssociation__Group__0__Impl : ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) ; public final void rule__FieldPropertyAssociation__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13103:1: ( ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:13104:1: ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13130:1: ( ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:13131:1: ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:13104:1: ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:13105:2: ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) + // InternalBehaviorAnnexParser.g:13131:1: ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13132:2: ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getPropertyAssignment_0()); } - // InternalBehaviorAnnexParser.g:13106:2: ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) - // InternalBehaviorAnnexParser.g:13106:3: rule__FieldPropertyAssociation__PropertyAssignment_0 + // InternalBehaviorAnnexParser.g:13133:2: ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) + // InternalBehaviorAnnexParser.g:13133:3: rule__FieldPropertyAssociation__PropertyAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__FieldPropertyAssociation__PropertyAssignment_0(); @@ -43447,14 +43542,14 @@ public final void rule__FieldPropertyAssociation__Group__0__Impl() throws Recogn // $ANTLR start "rule__FieldPropertyAssociation__Group__1" - // InternalBehaviorAnnexParser.g:13114:1: rule__FieldPropertyAssociation__Group__1 : rule__FieldPropertyAssociation__Group__1__Impl rule__FieldPropertyAssociation__Group__2 ; + // InternalBehaviorAnnexParser.g:13141:1: rule__FieldPropertyAssociation__Group__1 : rule__FieldPropertyAssociation__Group__1__Impl rule__FieldPropertyAssociation__Group__2 ; public final void rule__FieldPropertyAssociation__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13118:1: ( rule__FieldPropertyAssociation__Group__1__Impl rule__FieldPropertyAssociation__Group__2 ) - // InternalBehaviorAnnexParser.g:13119:2: rule__FieldPropertyAssociation__Group__1__Impl rule__FieldPropertyAssociation__Group__2 + // InternalBehaviorAnnexParser.g:13145:1: ( rule__FieldPropertyAssociation__Group__1__Impl rule__FieldPropertyAssociation__Group__2 ) + // InternalBehaviorAnnexParser.g:13146:2: rule__FieldPropertyAssociation__Group__1__Impl rule__FieldPropertyAssociation__Group__2 { pushFollow(FollowSets000.FOLLOW_16); rule__FieldPropertyAssociation__Group__1__Impl(); @@ -43485,17 +43580,17 @@ public final void rule__FieldPropertyAssociation__Group__1() throws RecognitionE // $ANTLR start "rule__FieldPropertyAssociation__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13126:1: rule__FieldPropertyAssociation__Group__1__Impl : ( EqualsSignGreaterThanSign ) ; + // InternalBehaviorAnnexParser.g:13153:1: rule__FieldPropertyAssociation__Group__1__Impl : ( EqualsSignGreaterThanSign ) ; public final void rule__FieldPropertyAssociation__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13130:1: ( ( EqualsSignGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:13131:1: ( EqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:13157:1: ( ( EqualsSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:13158:1: ( EqualsSignGreaterThanSign ) { - // InternalBehaviorAnnexParser.g:13131:1: ( EqualsSignGreaterThanSign ) - // InternalBehaviorAnnexParser.g:13132:2: EqualsSignGreaterThanSign + // InternalBehaviorAnnexParser.g:13158:1: ( EqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:13159:2: EqualsSignGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getEqualsSignGreaterThanSignKeyword_1()); @@ -43526,14 +43621,14 @@ public final void rule__FieldPropertyAssociation__Group__1__Impl() throws Recogn // $ANTLR start "rule__FieldPropertyAssociation__Group__2" - // InternalBehaviorAnnexParser.g:13141:1: rule__FieldPropertyAssociation__Group__2 : rule__FieldPropertyAssociation__Group__2__Impl rule__FieldPropertyAssociation__Group__3 ; + // InternalBehaviorAnnexParser.g:13168:1: rule__FieldPropertyAssociation__Group__2 : rule__FieldPropertyAssociation__Group__2__Impl rule__FieldPropertyAssociation__Group__3 ; public final void rule__FieldPropertyAssociation__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13145:1: ( rule__FieldPropertyAssociation__Group__2__Impl rule__FieldPropertyAssociation__Group__3 ) - // InternalBehaviorAnnexParser.g:13146:2: rule__FieldPropertyAssociation__Group__2__Impl rule__FieldPropertyAssociation__Group__3 + // InternalBehaviorAnnexParser.g:13172:1: ( rule__FieldPropertyAssociation__Group__2__Impl rule__FieldPropertyAssociation__Group__3 ) + // InternalBehaviorAnnexParser.g:13173:2: rule__FieldPropertyAssociation__Group__2__Impl rule__FieldPropertyAssociation__Group__3 { pushFollow(FollowSets000.FOLLOW_17); rule__FieldPropertyAssociation__Group__2__Impl(); @@ -43564,23 +43659,23 @@ public final void rule__FieldPropertyAssociation__Group__2() throws RecognitionE // $ANTLR start "rule__FieldPropertyAssociation__Group__2__Impl" - // InternalBehaviorAnnexParser.g:13153:1: rule__FieldPropertyAssociation__Group__2__Impl : ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:13180:1: rule__FieldPropertyAssociation__Group__2__Impl : ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) ; public final void rule__FieldPropertyAssociation__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13157:1: ( ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:13158:1: ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13184:1: ( ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:13185:1: ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:13158:1: ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:13159:2: ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) + // InternalBehaviorAnnexParser.g:13185:1: ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13186:2: ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getOwnedValueAssignment_2()); } - // InternalBehaviorAnnexParser.g:13160:2: ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) - // InternalBehaviorAnnexParser.g:13160:3: rule__FieldPropertyAssociation__OwnedValueAssignment_2 + // InternalBehaviorAnnexParser.g:13187:2: ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) + // InternalBehaviorAnnexParser.g:13187:3: rule__FieldPropertyAssociation__OwnedValueAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__FieldPropertyAssociation__OwnedValueAssignment_2(); @@ -43615,14 +43710,14 @@ public final void rule__FieldPropertyAssociation__Group__2__Impl() throws Recogn // $ANTLR start "rule__FieldPropertyAssociation__Group__3" - // InternalBehaviorAnnexParser.g:13168:1: rule__FieldPropertyAssociation__Group__3 : rule__FieldPropertyAssociation__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:13195:1: rule__FieldPropertyAssociation__Group__3 : rule__FieldPropertyAssociation__Group__3__Impl ; public final void rule__FieldPropertyAssociation__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13172:1: ( rule__FieldPropertyAssociation__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:13173:2: rule__FieldPropertyAssociation__Group__3__Impl + // InternalBehaviorAnnexParser.g:13199:1: ( rule__FieldPropertyAssociation__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:13200:2: rule__FieldPropertyAssociation__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__FieldPropertyAssociation__Group__3__Impl(); @@ -43648,17 +43743,17 @@ public final void rule__FieldPropertyAssociation__Group__3() throws RecognitionE // $ANTLR start "rule__FieldPropertyAssociation__Group__3__Impl" - // InternalBehaviorAnnexParser.g:13179:1: rule__FieldPropertyAssociation__Group__3__Impl : ( Semicolon ) ; + // InternalBehaviorAnnexParser.g:13206:1: rule__FieldPropertyAssociation__Group__3__Impl : ( Semicolon ) ; public final void rule__FieldPropertyAssociation__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13183:1: ( ( Semicolon ) ) - // InternalBehaviorAnnexParser.g:13184:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:13210:1: ( ( Semicolon ) ) + // InternalBehaviorAnnexParser.g:13211:1: ( Semicolon ) { - // InternalBehaviorAnnexParser.g:13184:1: ( Semicolon ) - // InternalBehaviorAnnexParser.g:13185:2: Semicolon + // InternalBehaviorAnnexParser.g:13211:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:13212:2: Semicolon { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getSemicolonKeyword_3()); @@ -43689,14 +43784,14 @@ public final void rule__FieldPropertyAssociation__Group__3__Impl() throws Recogn // $ANTLR start "rule__ContainmentPathElement__Group__0" - // InternalBehaviorAnnexParser.g:13195:1: rule__ContainmentPathElement__Group__0 : rule__ContainmentPathElement__Group__0__Impl rule__ContainmentPathElement__Group__1 ; + // InternalBehaviorAnnexParser.g:13222:1: rule__ContainmentPathElement__Group__0 : rule__ContainmentPathElement__Group__0__Impl rule__ContainmentPathElement__Group__1 ; public final void rule__ContainmentPathElement__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13199:1: ( rule__ContainmentPathElement__Group__0__Impl rule__ContainmentPathElement__Group__1 ) - // InternalBehaviorAnnexParser.g:13200:2: rule__ContainmentPathElement__Group__0__Impl rule__ContainmentPathElement__Group__1 + // InternalBehaviorAnnexParser.g:13226:1: ( rule__ContainmentPathElement__Group__0__Impl rule__ContainmentPathElement__Group__1 ) + // InternalBehaviorAnnexParser.g:13227:2: rule__ContainmentPathElement__Group__0__Impl rule__ContainmentPathElement__Group__1 { pushFollow(FollowSets000.FOLLOW_87); rule__ContainmentPathElement__Group__0__Impl(); @@ -43727,23 +43822,23 @@ public final void rule__ContainmentPathElement__Group__0() throws RecognitionExc // $ANTLR start "rule__ContainmentPathElement__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13207:1: rule__ContainmentPathElement__Group__0__Impl : ( ( rule__ContainmentPathElement__Group_0__0 ) ) ; + // InternalBehaviorAnnexParser.g:13234:1: rule__ContainmentPathElement__Group__0__Impl : ( ( rule__ContainmentPathElement__Group_0__0 ) ) ; public final void rule__ContainmentPathElement__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13211:1: ( ( ( rule__ContainmentPathElement__Group_0__0 ) ) ) - // InternalBehaviorAnnexParser.g:13212:1: ( ( rule__ContainmentPathElement__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:13238:1: ( ( ( rule__ContainmentPathElement__Group_0__0 ) ) ) + // InternalBehaviorAnnexParser.g:13239:1: ( ( rule__ContainmentPathElement__Group_0__0 ) ) { - // InternalBehaviorAnnexParser.g:13212:1: ( ( rule__ContainmentPathElement__Group_0__0 ) ) - // InternalBehaviorAnnexParser.g:13213:2: ( rule__ContainmentPathElement__Group_0__0 ) + // InternalBehaviorAnnexParser.g:13239:1: ( ( rule__ContainmentPathElement__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:13240:2: ( rule__ContainmentPathElement__Group_0__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getGroup_0()); } - // InternalBehaviorAnnexParser.g:13214:2: ( rule__ContainmentPathElement__Group_0__0 ) - // InternalBehaviorAnnexParser.g:13214:3: rule__ContainmentPathElement__Group_0__0 + // InternalBehaviorAnnexParser.g:13241:2: ( rule__ContainmentPathElement__Group_0__0 ) + // InternalBehaviorAnnexParser.g:13241:3: rule__ContainmentPathElement__Group_0__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group_0__0(); @@ -43778,14 +43873,14 @@ public final void rule__ContainmentPathElement__Group__0__Impl() throws Recognit // $ANTLR start "rule__ContainmentPathElement__Group__1" - // InternalBehaviorAnnexParser.g:13222:1: rule__ContainmentPathElement__Group__1 : rule__ContainmentPathElement__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13249:1: rule__ContainmentPathElement__Group__1 : rule__ContainmentPathElement__Group__1__Impl ; public final void rule__ContainmentPathElement__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13226:1: ( rule__ContainmentPathElement__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13227:2: rule__ContainmentPathElement__Group__1__Impl + // InternalBehaviorAnnexParser.g:13253:1: ( rule__ContainmentPathElement__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13254:2: rule__ContainmentPathElement__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group__1__Impl(); @@ -43811,31 +43906,31 @@ public final void rule__ContainmentPathElement__Group__1() throws RecognitionExc // $ANTLR start "rule__ContainmentPathElement__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13233:1: rule__ContainmentPathElement__Group__1__Impl : ( ( rule__ContainmentPathElement__Group_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:13260:1: rule__ContainmentPathElement__Group__1__Impl : ( ( rule__ContainmentPathElement__Group_1__0 )? ) ; public final void rule__ContainmentPathElement__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13237:1: ( ( ( rule__ContainmentPathElement__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:13238:1: ( ( rule__ContainmentPathElement__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:13264:1: ( ( ( rule__ContainmentPathElement__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:13265:1: ( ( rule__ContainmentPathElement__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:13238:1: ( ( rule__ContainmentPathElement__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:13239:2: ( rule__ContainmentPathElement__Group_1__0 )? + // InternalBehaviorAnnexParser.g:13265:1: ( ( rule__ContainmentPathElement__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:13266:2: ( rule__ContainmentPathElement__Group_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:13240:2: ( rule__ContainmentPathElement__Group_1__0 )? - int alt111=2; - int LA111_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13267:2: ( rule__ContainmentPathElement__Group_1__0 )? + int alt112=2; + int LA112_0 = input.LA(1); - if ( (LA111_0==FullStop) ) { - alt111=1; + if ( (LA112_0==FullStop) ) { + alt112=1; } - switch (alt111) { + switch (alt112) { case 1 : - // InternalBehaviorAnnexParser.g:13240:3: rule__ContainmentPathElement__Group_1__0 + // InternalBehaviorAnnexParser.g:13267:3: rule__ContainmentPathElement__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group_1__0(); @@ -43873,14 +43968,14 @@ public final void rule__ContainmentPathElement__Group__1__Impl() throws Recognit // $ANTLR start "rule__ContainmentPathElement__Group_0__0" - // InternalBehaviorAnnexParser.g:13249:1: rule__ContainmentPathElement__Group_0__0 : rule__ContainmentPathElement__Group_0__0__Impl rule__ContainmentPathElement__Group_0__1 ; + // InternalBehaviorAnnexParser.g:13276:1: rule__ContainmentPathElement__Group_0__0 : rule__ContainmentPathElement__Group_0__0__Impl rule__ContainmentPathElement__Group_0__1 ; public final void rule__ContainmentPathElement__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13253:1: ( rule__ContainmentPathElement__Group_0__0__Impl rule__ContainmentPathElement__Group_0__1 ) - // InternalBehaviorAnnexParser.g:13254:2: rule__ContainmentPathElement__Group_0__0__Impl rule__ContainmentPathElement__Group_0__1 + // InternalBehaviorAnnexParser.g:13280:1: ( rule__ContainmentPathElement__Group_0__0__Impl rule__ContainmentPathElement__Group_0__1 ) + // InternalBehaviorAnnexParser.g:13281:2: rule__ContainmentPathElement__Group_0__0__Impl rule__ContainmentPathElement__Group_0__1 { pushFollow(FollowSets000.FOLLOW_11); rule__ContainmentPathElement__Group_0__0__Impl(); @@ -43911,23 +44006,23 @@ public final void rule__ContainmentPathElement__Group_0__0() throws RecognitionE // $ANTLR start "rule__ContainmentPathElement__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:13261:1: rule__ContainmentPathElement__Group_0__0__Impl : ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) ; + // InternalBehaviorAnnexParser.g:13288:1: rule__ContainmentPathElement__Group_0__0__Impl : ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) ; public final void rule__ContainmentPathElement__Group_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13265:1: ( ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) ) - // InternalBehaviorAnnexParser.g:13266:1: ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) + // InternalBehaviorAnnexParser.g:13292:1: ( ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) ) + // InternalBehaviorAnnexParser.g:13293:1: ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) { - // InternalBehaviorAnnexParser.g:13266:1: ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) - // InternalBehaviorAnnexParser.g:13267:2: ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) + // InternalBehaviorAnnexParser.g:13293:1: ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) + // InternalBehaviorAnnexParser.g:13294:2: ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getNamedElementAssignment_0_0()); } - // InternalBehaviorAnnexParser.g:13268:2: ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) - // InternalBehaviorAnnexParser.g:13268:3: rule__ContainmentPathElement__NamedElementAssignment_0_0 + // InternalBehaviorAnnexParser.g:13295:2: ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) + // InternalBehaviorAnnexParser.g:13295:3: rule__ContainmentPathElement__NamedElementAssignment_0_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__NamedElementAssignment_0_0(); @@ -43962,14 +44057,14 @@ public final void rule__ContainmentPathElement__Group_0__0__Impl() throws Recogn // $ANTLR start "rule__ContainmentPathElement__Group_0__1" - // InternalBehaviorAnnexParser.g:13276:1: rule__ContainmentPathElement__Group_0__1 : rule__ContainmentPathElement__Group_0__1__Impl ; + // InternalBehaviorAnnexParser.g:13303:1: rule__ContainmentPathElement__Group_0__1 : rule__ContainmentPathElement__Group_0__1__Impl ; public final void rule__ContainmentPathElement__Group_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13280:1: ( rule__ContainmentPathElement__Group_0__1__Impl ) - // InternalBehaviorAnnexParser.g:13281:2: rule__ContainmentPathElement__Group_0__1__Impl + // InternalBehaviorAnnexParser.g:13307:1: ( rule__ContainmentPathElement__Group_0__1__Impl ) + // InternalBehaviorAnnexParser.g:13308:2: rule__ContainmentPathElement__Group_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group_0__1__Impl(); @@ -43995,35 +44090,35 @@ public final void rule__ContainmentPathElement__Group_0__1() throws RecognitionE // $ANTLR start "rule__ContainmentPathElement__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:13287:1: rule__ContainmentPathElement__Group_0__1__Impl : ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) ; + // InternalBehaviorAnnexParser.g:13314:1: rule__ContainmentPathElement__Group_0__1__Impl : ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) ; public final void rule__ContainmentPathElement__Group_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13291:1: ( ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) ) - // InternalBehaviorAnnexParser.g:13292:1: ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) + // InternalBehaviorAnnexParser.g:13318:1: ( ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) ) + // InternalBehaviorAnnexParser.g:13319:1: ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) { - // InternalBehaviorAnnexParser.g:13292:1: ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) - // InternalBehaviorAnnexParser.g:13293:2: ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* + // InternalBehaviorAnnexParser.g:13319:1: ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) + // InternalBehaviorAnnexParser.g:13320:2: ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getArrayRangeAssignment_0_1()); } - // InternalBehaviorAnnexParser.g:13294:2: ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* - loop112: + // InternalBehaviorAnnexParser.g:13321:2: ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* + loop113: do { - int alt112=2; - int LA112_0 = input.LA(1); + int alt113=2; + int LA113_0 = input.LA(1); - if ( (LA112_0==LeftSquareBracket) ) { - alt112=1; + if ( (LA113_0==LeftSquareBracket) ) { + alt113=1; } - switch (alt112) { + switch (alt113) { case 1 : - // InternalBehaviorAnnexParser.g:13294:3: rule__ContainmentPathElement__ArrayRangeAssignment_0_1 + // InternalBehaviorAnnexParser.g:13321:3: rule__ContainmentPathElement__ArrayRangeAssignment_0_1 { pushFollow(FollowSets000.FOLLOW_12); rule__ContainmentPathElement__ArrayRangeAssignment_0_1(); @@ -44035,7 +44130,7 @@ public final void rule__ContainmentPathElement__Group_0__1__Impl() throws Recogn break; default : - break loop112; + break loop113; } } while (true); @@ -44064,14 +44159,14 @@ public final void rule__ContainmentPathElement__Group_0__1__Impl() throws Recogn // $ANTLR start "rule__ContainmentPathElement__Group_1__0" - // InternalBehaviorAnnexParser.g:13303:1: rule__ContainmentPathElement__Group_1__0 : rule__ContainmentPathElement__Group_1__0__Impl rule__ContainmentPathElement__Group_1__1 ; + // InternalBehaviorAnnexParser.g:13330:1: rule__ContainmentPathElement__Group_1__0 : rule__ContainmentPathElement__Group_1__0__Impl rule__ContainmentPathElement__Group_1__1 ; public final void rule__ContainmentPathElement__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13307:1: ( rule__ContainmentPathElement__Group_1__0__Impl rule__ContainmentPathElement__Group_1__1 ) - // InternalBehaviorAnnexParser.g:13308:2: rule__ContainmentPathElement__Group_1__0__Impl rule__ContainmentPathElement__Group_1__1 + // InternalBehaviorAnnexParser.g:13334:1: ( rule__ContainmentPathElement__Group_1__0__Impl rule__ContainmentPathElement__Group_1__1 ) + // InternalBehaviorAnnexParser.g:13335:2: rule__ContainmentPathElement__Group_1__0__Impl rule__ContainmentPathElement__Group_1__1 { pushFollow(FollowSets000.FOLLOW_4); rule__ContainmentPathElement__Group_1__0__Impl(); @@ -44102,17 +44197,17 @@ public final void rule__ContainmentPathElement__Group_1__0() throws RecognitionE // $ANTLR start "rule__ContainmentPathElement__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:13315:1: rule__ContainmentPathElement__Group_1__0__Impl : ( FullStop ) ; + // InternalBehaviorAnnexParser.g:13342:1: rule__ContainmentPathElement__Group_1__0__Impl : ( FullStop ) ; public final void rule__ContainmentPathElement__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13319:1: ( ( FullStop ) ) - // InternalBehaviorAnnexParser.g:13320:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:13346:1: ( ( FullStop ) ) + // InternalBehaviorAnnexParser.g:13347:1: ( FullStop ) { - // InternalBehaviorAnnexParser.g:13320:1: ( FullStop ) - // InternalBehaviorAnnexParser.g:13321:2: FullStop + // InternalBehaviorAnnexParser.g:13347:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:13348:2: FullStop { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getFullStopKeyword_1_0()); @@ -44143,14 +44238,14 @@ public final void rule__ContainmentPathElement__Group_1__0__Impl() throws Recogn // $ANTLR start "rule__ContainmentPathElement__Group_1__1" - // InternalBehaviorAnnexParser.g:13330:1: rule__ContainmentPathElement__Group_1__1 : rule__ContainmentPathElement__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:13357:1: rule__ContainmentPathElement__Group_1__1 : rule__ContainmentPathElement__Group_1__1__Impl ; public final void rule__ContainmentPathElement__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13334:1: ( rule__ContainmentPathElement__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:13335:2: rule__ContainmentPathElement__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:13361:1: ( rule__ContainmentPathElement__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:13362:2: rule__ContainmentPathElement__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group_1__1__Impl(); @@ -44176,23 +44271,23 @@ public final void rule__ContainmentPathElement__Group_1__1() throws RecognitionE // $ANTLR start "rule__ContainmentPathElement__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:13341:1: rule__ContainmentPathElement__Group_1__1__Impl : ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:13368:1: rule__ContainmentPathElement__Group_1__1__Impl : ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) ; public final void rule__ContainmentPathElement__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13345:1: ( ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:13346:1: ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:13372:1: ( ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:13373:1: ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:13346:1: ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:13347:2: ( rule__ContainmentPathElement__PathAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:13373:1: ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:13374:2: ( rule__ContainmentPathElement__PathAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getPathAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:13348:2: ( rule__ContainmentPathElement__PathAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:13348:3: rule__ContainmentPathElement__PathAssignment_1_1 + // InternalBehaviorAnnexParser.g:13375:2: ( rule__ContainmentPathElement__PathAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:13375:3: rule__ContainmentPathElement__PathAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__PathAssignment_1_1(); @@ -44227,14 +44322,14 @@ public final void rule__ContainmentPathElement__Group_1__1__Impl() throws Recogn // $ANTLR start "rule__ArrayRange__Group__0" - // InternalBehaviorAnnexParser.g:13357:1: rule__ArrayRange__Group__0 : rule__ArrayRange__Group__0__Impl rule__ArrayRange__Group__1 ; + // InternalBehaviorAnnexParser.g:13384:1: rule__ArrayRange__Group__0 : rule__ArrayRange__Group__0__Impl rule__ArrayRange__Group__1 ; public final void rule__ArrayRange__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13361:1: ( rule__ArrayRange__Group__0__Impl rule__ArrayRange__Group__1 ) - // InternalBehaviorAnnexParser.g:13362:2: rule__ArrayRange__Group__0__Impl rule__ArrayRange__Group__1 + // InternalBehaviorAnnexParser.g:13388:1: ( rule__ArrayRange__Group__0__Impl rule__ArrayRange__Group__1 ) + // InternalBehaviorAnnexParser.g:13389:2: rule__ArrayRange__Group__0__Impl rule__ArrayRange__Group__1 { pushFollow(FollowSets000.FOLLOW_11); rule__ArrayRange__Group__0__Impl(); @@ -44265,23 +44360,23 @@ public final void rule__ArrayRange__Group__0() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13369:1: rule__ArrayRange__Group__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:13396:1: rule__ArrayRange__Group__0__Impl : ( () ) ; public final void rule__ArrayRange__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13373:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:13374:1: ( () ) + // InternalBehaviorAnnexParser.g:13400:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:13401:1: ( () ) { - // InternalBehaviorAnnexParser.g:13374:1: ( () ) - // InternalBehaviorAnnexParser.g:13375:2: () + // InternalBehaviorAnnexParser.g:13401:1: ( () ) + // InternalBehaviorAnnexParser.g:13402:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getArrayRangeAction_0()); } - // InternalBehaviorAnnexParser.g:13376:2: () - // InternalBehaviorAnnexParser.g:13376:3: + // InternalBehaviorAnnexParser.g:13403:2: () + // InternalBehaviorAnnexParser.g:13403:3: { } @@ -44306,14 +44401,14 @@ public final void rule__ArrayRange__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__ArrayRange__Group__1" - // InternalBehaviorAnnexParser.g:13384:1: rule__ArrayRange__Group__1 : rule__ArrayRange__Group__1__Impl rule__ArrayRange__Group__2 ; + // InternalBehaviorAnnexParser.g:13411:1: rule__ArrayRange__Group__1 : rule__ArrayRange__Group__1__Impl rule__ArrayRange__Group__2 ; public final void rule__ArrayRange__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13388:1: ( rule__ArrayRange__Group__1__Impl rule__ArrayRange__Group__2 ) - // InternalBehaviorAnnexParser.g:13389:2: rule__ArrayRange__Group__1__Impl rule__ArrayRange__Group__2 + // InternalBehaviorAnnexParser.g:13415:1: ( rule__ArrayRange__Group__1__Impl rule__ArrayRange__Group__2 ) + // InternalBehaviorAnnexParser.g:13416:2: rule__ArrayRange__Group__1__Impl rule__ArrayRange__Group__2 { pushFollow(FollowSets000.FOLLOW_23); rule__ArrayRange__Group__1__Impl(); @@ -44344,17 +44439,17 @@ public final void rule__ArrayRange__Group__1() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13396:1: rule__ArrayRange__Group__1__Impl : ( LeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:13423:1: rule__ArrayRange__Group__1__Impl : ( LeftSquareBracket ) ; public final void rule__ArrayRange__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13400:1: ( ( LeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:13401:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:13427:1: ( ( LeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:13428:1: ( LeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:13401:1: ( LeftSquareBracket ) - // InternalBehaviorAnnexParser.g:13402:2: LeftSquareBracket + // InternalBehaviorAnnexParser.g:13428:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:13429:2: LeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getLeftSquareBracketKeyword_1()); @@ -44385,14 +44480,14 @@ public final void rule__ArrayRange__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__ArrayRange__Group__2" - // InternalBehaviorAnnexParser.g:13411:1: rule__ArrayRange__Group__2 : rule__ArrayRange__Group__2__Impl rule__ArrayRange__Group__3 ; + // InternalBehaviorAnnexParser.g:13438:1: rule__ArrayRange__Group__2 : rule__ArrayRange__Group__2__Impl rule__ArrayRange__Group__3 ; public final void rule__ArrayRange__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13415:1: ( rule__ArrayRange__Group__2__Impl rule__ArrayRange__Group__3 ) - // InternalBehaviorAnnexParser.g:13416:2: rule__ArrayRange__Group__2__Impl rule__ArrayRange__Group__3 + // InternalBehaviorAnnexParser.g:13442:1: ( rule__ArrayRange__Group__2__Impl rule__ArrayRange__Group__3 ) + // InternalBehaviorAnnexParser.g:13443:2: rule__ArrayRange__Group__2__Impl rule__ArrayRange__Group__3 { pushFollow(FollowSets000.FOLLOW_88); rule__ArrayRange__Group__2__Impl(); @@ -44423,23 +44518,23 @@ public final void rule__ArrayRange__Group__2() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group__2__Impl" - // InternalBehaviorAnnexParser.g:13423:1: rule__ArrayRange__Group__2__Impl : ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:13450:1: rule__ArrayRange__Group__2__Impl : ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) ; public final void rule__ArrayRange__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13427:1: ( ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:13428:1: ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13454:1: ( ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:13455:1: ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:13428:1: ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:13429:2: ( rule__ArrayRange__LowerBoundAssignment_2 ) + // InternalBehaviorAnnexParser.g:13455:1: ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13456:2: ( rule__ArrayRange__LowerBoundAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getLowerBoundAssignment_2()); } - // InternalBehaviorAnnexParser.g:13430:2: ( rule__ArrayRange__LowerBoundAssignment_2 ) - // InternalBehaviorAnnexParser.g:13430:3: rule__ArrayRange__LowerBoundAssignment_2 + // InternalBehaviorAnnexParser.g:13457:2: ( rule__ArrayRange__LowerBoundAssignment_2 ) + // InternalBehaviorAnnexParser.g:13457:3: rule__ArrayRange__LowerBoundAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__LowerBoundAssignment_2(); @@ -44474,14 +44569,14 @@ public final void rule__ArrayRange__Group__2__Impl() throws RecognitionException // $ANTLR start "rule__ArrayRange__Group__3" - // InternalBehaviorAnnexParser.g:13438:1: rule__ArrayRange__Group__3 : rule__ArrayRange__Group__3__Impl rule__ArrayRange__Group__4 ; + // InternalBehaviorAnnexParser.g:13465:1: rule__ArrayRange__Group__3 : rule__ArrayRange__Group__3__Impl rule__ArrayRange__Group__4 ; public final void rule__ArrayRange__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13442:1: ( rule__ArrayRange__Group__3__Impl rule__ArrayRange__Group__4 ) - // InternalBehaviorAnnexParser.g:13443:2: rule__ArrayRange__Group__3__Impl rule__ArrayRange__Group__4 + // InternalBehaviorAnnexParser.g:13469:1: ( rule__ArrayRange__Group__3__Impl rule__ArrayRange__Group__4 ) + // InternalBehaviorAnnexParser.g:13470:2: rule__ArrayRange__Group__3__Impl rule__ArrayRange__Group__4 { pushFollow(FollowSets000.FOLLOW_88); rule__ArrayRange__Group__3__Impl(); @@ -44512,31 +44607,31 @@ public final void rule__ArrayRange__Group__3() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group__3__Impl" - // InternalBehaviorAnnexParser.g:13450:1: rule__ArrayRange__Group__3__Impl : ( ( rule__ArrayRange__Group_3__0 )? ) ; + // InternalBehaviorAnnexParser.g:13477:1: rule__ArrayRange__Group__3__Impl : ( ( rule__ArrayRange__Group_3__0 )? ) ; public final void rule__ArrayRange__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13454:1: ( ( ( rule__ArrayRange__Group_3__0 )? ) ) - // InternalBehaviorAnnexParser.g:13455:1: ( ( rule__ArrayRange__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:13481:1: ( ( ( rule__ArrayRange__Group_3__0 )? ) ) + // InternalBehaviorAnnexParser.g:13482:1: ( ( rule__ArrayRange__Group_3__0 )? ) { - // InternalBehaviorAnnexParser.g:13455:1: ( ( rule__ArrayRange__Group_3__0 )? ) - // InternalBehaviorAnnexParser.g:13456:2: ( rule__ArrayRange__Group_3__0 )? + // InternalBehaviorAnnexParser.g:13482:1: ( ( rule__ArrayRange__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:13483:2: ( rule__ArrayRange__Group_3__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getGroup_3()); } - // InternalBehaviorAnnexParser.g:13457:2: ( rule__ArrayRange__Group_3__0 )? - int alt113=2; - int LA113_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13484:2: ( rule__ArrayRange__Group_3__0 )? + int alt114=2; + int LA114_0 = input.LA(1); - if ( (LA113_0==FullStopFullStop) ) { - alt113=1; + if ( (LA114_0==FullStopFullStop) ) { + alt114=1; } - switch (alt113) { + switch (alt114) { case 1 : - // InternalBehaviorAnnexParser.g:13457:3: rule__ArrayRange__Group_3__0 + // InternalBehaviorAnnexParser.g:13484:3: rule__ArrayRange__Group_3__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__Group_3__0(); @@ -44574,14 +44669,14 @@ public final void rule__ArrayRange__Group__3__Impl() throws RecognitionException // $ANTLR start "rule__ArrayRange__Group__4" - // InternalBehaviorAnnexParser.g:13465:1: rule__ArrayRange__Group__4 : rule__ArrayRange__Group__4__Impl ; + // InternalBehaviorAnnexParser.g:13492:1: rule__ArrayRange__Group__4 : rule__ArrayRange__Group__4__Impl ; public final void rule__ArrayRange__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13469:1: ( rule__ArrayRange__Group__4__Impl ) - // InternalBehaviorAnnexParser.g:13470:2: rule__ArrayRange__Group__4__Impl + // InternalBehaviorAnnexParser.g:13496:1: ( rule__ArrayRange__Group__4__Impl ) + // InternalBehaviorAnnexParser.g:13497:2: rule__ArrayRange__Group__4__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__Group__4__Impl(); @@ -44607,17 +44702,17 @@ public final void rule__ArrayRange__Group__4() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group__4__Impl" - // InternalBehaviorAnnexParser.g:13476:1: rule__ArrayRange__Group__4__Impl : ( RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:13503:1: rule__ArrayRange__Group__4__Impl : ( RightSquareBracket ) ; public final void rule__ArrayRange__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13480:1: ( ( RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:13481:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:13507:1: ( ( RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:13508:1: ( RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:13481:1: ( RightSquareBracket ) - // InternalBehaviorAnnexParser.g:13482:2: RightSquareBracket + // InternalBehaviorAnnexParser.g:13508:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:13509:2: RightSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getRightSquareBracketKeyword_4()); @@ -44648,14 +44743,14 @@ public final void rule__ArrayRange__Group__4__Impl() throws RecognitionException // $ANTLR start "rule__ArrayRange__Group_3__0" - // InternalBehaviorAnnexParser.g:13492:1: rule__ArrayRange__Group_3__0 : rule__ArrayRange__Group_3__0__Impl rule__ArrayRange__Group_3__1 ; + // InternalBehaviorAnnexParser.g:13519:1: rule__ArrayRange__Group_3__0 : rule__ArrayRange__Group_3__0__Impl rule__ArrayRange__Group_3__1 ; public final void rule__ArrayRange__Group_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13496:1: ( rule__ArrayRange__Group_3__0__Impl rule__ArrayRange__Group_3__1 ) - // InternalBehaviorAnnexParser.g:13497:2: rule__ArrayRange__Group_3__0__Impl rule__ArrayRange__Group_3__1 + // InternalBehaviorAnnexParser.g:13523:1: ( rule__ArrayRange__Group_3__0__Impl rule__ArrayRange__Group_3__1 ) + // InternalBehaviorAnnexParser.g:13524:2: rule__ArrayRange__Group_3__0__Impl rule__ArrayRange__Group_3__1 { pushFollow(FollowSets000.FOLLOW_23); rule__ArrayRange__Group_3__0__Impl(); @@ -44686,17 +44781,17 @@ public final void rule__ArrayRange__Group_3__0() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group_3__0__Impl" - // InternalBehaviorAnnexParser.g:13504:1: rule__ArrayRange__Group_3__0__Impl : ( FullStopFullStop ) ; + // InternalBehaviorAnnexParser.g:13531:1: rule__ArrayRange__Group_3__0__Impl : ( FullStopFullStop ) ; public final void rule__ArrayRange__Group_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13508:1: ( ( FullStopFullStop ) ) - // InternalBehaviorAnnexParser.g:13509:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:13535:1: ( ( FullStopFullStop ) ) + // InternalBehaviorAnnexParser.g:13536:1: ( FullStopFullStop ) { - // InternalBehaviorAnnexParser.g:13509:1: ( FullStopFullStop ) - // InternalBehaviorAnnexParser.g:13510:2: FullStopFullStop + // InternalBehaviorAnnexParser.g:13536:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:13537:2: FullStopFullStop { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getFullStopFullStopKeyword_3_0()); @@ -44727,14 +44822,14 @@ public final void rule__ArrayRange__Group_3__0__Impl() throws RecognitionExcepti // $ANTLR start "rule__ArrayRange__Group_3__1" - // InternalBehaviorAnnexParser.g:13519:1: rule__ArrayRange__Group_3__1 : rule__ArrayRange__Group_3__1__Impl ; + // InternalBehaviorAnnexParser.g:13546:1: rule__ArrayRange__Group_3__1 : rule__ArrayRange__Group_3__1__Impl ; public final void rule__ArrayRange__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13523:1: ( rule__ArrayRange__Group_3__1__Impl ) - // InternalBehaviorAnnexParser.g:13524:2: rule__ArrayRange__Group_3__1__Impl + // InternalBehaviorAnnexParser.g:13550:1: ( rule__ArrayRange__Group_3__1__Impl ) + // InternalBehaviorAnnexParser.g:13551:2: rule__ArrayRange__Group_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__Group_3__1__Impl(); @@ -44760,23 +44855,23 @@ public final void rule__ArrayRange__Group_3__1() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group_3__1__Impl" - // InternalBehaviorAnnexParser.g:13530:1: rule__ArrayRange__Group_3__1__Impl : ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:13557:1: rule__ArrayRange__Group_3__1__Impl : ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) ; public final void rule__ArrayRange__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13534:1: ( ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:13535:1: ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:13561:1: ( ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:13562:1: ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) { - // InternalBehaviorAnnexParser.g:13535:1: ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) - // InternalBehaviorAnnexParser.g:13536:2: ( rule__ArrayRange__UpperBoundAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:13562:1: ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:13563:2: ( rule__ArrayRange__UpperBoundAssignment_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getUpperBoundAssignment_3_1()); } - // InternalBehaviorAnnexParser.g:13537:2: ( rule__ArrayRange__UpperBoundAssignment_3_1 ) - // InternalBehaviorAnnexParser.g:13537:3: rule__ArrayRange__UpperBoundAssignment_3_1 + // InternalBehaviorAnnexParser.g:13564:2: ( rule__ArrayRange__UpperBoundAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:13564:3: rule__ArrayRange__UpperBoundAssignment_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__UpperBoundAssignment_3_1(); @@ -44811,14 +44906,14 @@ public final void rule__ArrayRange__Group_3__1__Impl() throws RecognitionExcepti // $ANTLR start "rule__SignedConstant__Group__0" - // InternalBehaviorAnnexParser.g:13546:1: rule__SignedConstant__Group__0 : rule__SignedConstant__Group__0__Impl rule__SignedConstant__Group__1 ; + // InternalBehaviorAnnexParser.g:13573:1: rule__SignedConstant__Group__0 : rule__SignedConstant__Group__0__Impl rule__SignedConstant__Group__1 ; public final void rule__SignedConstant__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13550:1: ( rule__SignedConstant__Group__0__Impl rule__SignedConstant__Group__1 ) - // InternalBehaviorAnnexParser.g:13551:2: rule__SignedConstant__Group__0__Impl rule__SignedConstant__Group__1 + // InternalBehaviorAnnexParser.g:13577:1: ( rule__SignedConstant__Group__0__Impl rule__SignedConstant__Group__1 ) + // InternalBehaviorAnnexParser.g:13578:2: rule__SignedConstant__Group__0__Impl rule__SignedConstant__Group__1 { pushFollow(FollowSets000.FOLLOW_89); rule__SignedConstant__Group__0__Impl(); @@ -44849,23 +44944,23 @@ public final void rule__SignedConstant__Group__0() throws RecognitionException { // $ANTLR start "rule__SignedConstant__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13558:1: rule__SignedConstant__Group__0__Impl : ( ( rule__SignedConstant__OpAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:13585:1: rule__SignedConstant__Group__0__Impl : ( ( rule__SignedConstant__OpAssignment_0 ) ) ; public final void rule__SignedConstant__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13562:1: ( ( ( rule__SignedConstant__OpAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:13563:1: ( ( rule__SignedConstant__OpAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13589:1: ( ( ( rule__SignedConstant__OpAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:13590:1: ( ( rule__SignedConstant__OpAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:13563:1: ( ( rule__SignedConstant__OpAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:13564:2: ( rule__SignedConstant__OpAssignment_0 ) + // InternalBehaviorAnnexParser.g:13590:1: ( ( rule__SignedConstant__OpAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13591:2: ( rule__SignedConstant__OpAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSignedConstantAccess().getOpAssignment_0()); } - // InternalBehaviorAnnexParser.g:13565:2: ( rule__SignedConstant__OpAssignment_0 ) - // InternalBehaviorAnnexParser.g:13565:3: rule__SignedConstant__OpAssignment_0 + // InternalBehaviorAnnexParser.g:13592:2: ( rule__SignedConstant__OpAssignment_0 ) + // InternalBehaviorAnnexParser.g:13592:3: rule__SignedConstant__OpAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedConstant__OpAssignment_0(); @@ -44900,14 +44995,14 @@ public final void rule__SignedConstant__Group__0__Impl() throws RecognitionExcep // $ANTLR start "rule__SignedConstant__Group__1" - // InternalBehaviorAnnexParser.g:13573:1: rule__SignedConstant__Group__1 : rule__SignedConstant__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13600:1: rule__SignedConstant__Group__1 : rule__SignedConstant__Group__1__Impl ; public final void rule__SignedConstant__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13577:1: ( rule__SignedConstant__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13578:2: rule__SignedConstant__Group__1__Impl + // InternalBehaviorAnnexParser.g:13604:1: ( rule__SignedConstant__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13605:2: rule__SignedConstant__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__SignedConstant__Group__1__Impl(); @@ -44933,23 +45028,23 @@ public final void rule__SignedConstant__Group__1() throws RecognitionException { // $ANTLR start "rule__SignedConstant__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13584:1: rule__SignedConstant__Group__1__Impl : ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:13611:1: rule__SignedConstant__Group__1__Impl : ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) ; public final void rule__SignedConstant__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13588:1: ( ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:13589:1: ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:13615:1: ( ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:13616:1: ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:13589:1: ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:13590:2: ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) + // InternalBehaviorAnnexParser.g:13616:1: ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:13617:2: ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSignedConstantAccess().getOwnedPropertyExpressionAssignment_1()); } - // InternalBehaviorAnnexParser.g:13591:2: ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) - // InternalBehaviorAnnexParser.g:13591:3: rule__SignedConstant__OwnedPropertyExpressionAssignment_1 + // InternalBehaviorAnnexParser.g:13618:2: ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) + // InternalBehaviorAnnexParser.g:13618:3: rule__SignedConstant__OwnedPropertyExpressionAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedConstant__OwnedPropertyExpressionAssignment_1(); @@ -44984,14 +45079,14 @@ public final void rule__SignedConstant__Group__1__Impl() throws RecognitionExcep // $ANTLR start "rule__IntegerTerm__Group__0" - // InternalBehaviorAnnexParser.g:13600:1: rule__IntegerTerm__Group__0 : rule__IntegerTerm__Group__0__Impl rule__IntegerTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:13627:1: rule__IntegerTerm__Group__0 : rule__IntegerTerm__Group__0__Impl rule__IntegerTerm__Group__1 ; public final void rule__IntegerTerm__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13604:1: ( rule__IntegerTerm__Group__0__Impl rule__IntegerTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:13605:2: rule__IntegerTerm__Group__0__Impl rule__IntegerTerm__Group__1 + // InternalBehaviorAnnexParser.g:13631:1: ( rule__IntegerTerm__Group__0__Impl rule__IntegerTerm__Group__1 ) + // InternalBehaviorAnnexParser.g:13632:2: rule__IntegerTerm__Group__0__Impl rule__IntegerTerm__Group__1 { pushFollow(FollowSets000.FOLLOW_4); rule__IntegerTerm__Group__0__Impl(); @@ -45022,23 +45117,23 @@ public final void rule__IntegerTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__IntegerTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13612:1: rule__IntegerTerm__Group__0__Impl : ( ( rule__IntegerTerm__ValueAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:13639:1: rule__IntegerTerm__Group__0__Impl : ( ( rule__IntegerTerm__ValueAssignment_0 ) ) ; public final void rule__IntegerTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13616:1: ( ( ( rule__IntegerTerm__ValueAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:13617:1: ( ( rule__IntegerTerm__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13643:1: ( ( ( rule__IntegerTerm__ValueAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:13644:1: ( ( rule__IntegerTerm__ValueAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:13617:1: ( ( rule__IntegerTerm__ValueAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:13618:2: ( rule__IntegerTerm__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:13644:1: ( ( rule__IntegerTerm__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13645:2: ( rule__IntegerTerm__ValueAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getValueAssignment_0()); } - // InternalBehaviorAnnexParser.g:13619:2: ( rule__IntegerTerm__ValueAssignment_0 ) - // InternalBehaviorAnnexParser.g:13619:3: rule__IntegerTerm__ValueAssignment_0 + // InternalBehaviorAnnexParser.g:13646:2: ( rule__IntegerTerm__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:13646:3: rule__IntegerTerm__ValueAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__IntegerTerm__ValueAssignment_0(); @@ -45073,14 +45168,14 @@ public final void rule__IntegerTerm__Group__0__Impl() throws RecognitionExceptio // $ANTLR start "rule__IntegerTerm__Group__1" - // InternalBehaviorAnnexParser.g:13627:1: rule__IntegerTerm__Group__1 : rule__IntegerTerm__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13654:1: rule__IntegerTerm__Group__1 : rule__IntegerTerm__Group__1__Impl ; public final void rule__IntegerTerm__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13631:1: ( rule__IntegerTerm__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13632:2: rule__IntegerTerm__Group__1__Impl + // InternalBehaviorAnnexParser.g:13658:1: ( rule__IntegerTerm__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13659:2: rule__IntegerTerm__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__IntegerTerm__Group__1__Impl(); @@ -45106,31 +45201,31 @@ public final void rule__IntegerTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__IntegerTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13638:1: rule__IntegerTerm__Group__1__Impl : ( ( rule__IntegerTerm__UnitAssignment_1 )? ) ; + // InternalBehaviorAnnexParser.g:13665:1: rule__IntegerTerm__Group__1__Impl : ( ( rule__IntegerTerm__UnitAssignment_1 )? ) ; public final void rule__IntegerTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13642:1: ( ( ( rule__IntegerTerm__UnitAssignment_1 )? ) ) - // InternalBehaviorAnnexParser.g:13643:1: ( ( rule__IntegerTerm__UnitAssignment_1 )? ) + // InternalBehaviorAnnexParser.g:13669:1: ( ( ( rule__IntegerTerm__UnitAssignment_1 )? ) ) + // InternalBehaviorAnnexParser.g:13670:1: ( ( rule__IntegerTerm__UnitAssignment_1 )? ) { - // InternalBehaviorAnnexParser.g:13643:1: ( ( rule__IntegerTerm__UnitAssignment_1 )? ) - // InternalBehaviorAnnexParser.g:13644:2: ( rule__IntegerTerm__UnitAssignment_1 )? + // InternalBehaviorAnnexParser.g:13670:1: ( ( rule__IntegerTerm__UnitAssignment_1 )? ) + // InternalBehaviorAnnexParser.g:13671:2: ( rule__IntegerTerm__UnitAssignment_1 )? { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getUnitAssignment_1()); } - // InternalBehaviorAnnexParser.g:13645:2: ( rule__IntegerTerm__UnitAssignment_1 )? - int alt114=2; - int LA114_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13672:2: ( rule__IntegerTerm__UnitAssignment_1 )? + int alt115=2; + int LA115_0 = input.LA(1); - if ( (LA114_0==RULE_ID) ) { - alt114=1; + if ( (LA115_0==RULE_ID) ) { + alt115=1; } - switch (alt114) { + switch (alt115) { case 1 : - // InternalBehaviorAnnexParser.g:13645:3: rule__IntegerTerm__UnitAssignment_1 + // InternalBehaviorAnnexParser.g:13672:3: rule__IntegerTerm__UnitAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__IntegerTerm__UnitAssignment_1(); @@ -45168,14 +45263,14 @@ public final void rule__IntegerTerm__Group__1__Impl() throws RecognitionExceptio // $ANTLR start "rule__SignedInt__Group__0" - // InternalBehaviorAnnexParser.g:13654:1: rule__SignedInt__Group__0 : rule__SignedInt__Group__0__Impl rule__SignedInt__Group__1 ; + // InternalBehaviorAnnexParser.g:13681:1: rule__SignedInt__Group__0 : rule__SignedInt__Group__0__Impl rule__SignedInt__Group__1 ; public final void rule__SignedInt__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13658:1: ( rule__SignedInt__Group__0__Impl rule__SignedInt__Group__1 ) - // InternalBehaviorAnnexParser.g:13659:2: rule__SignedInt__Group__0__Impl rule__SignedInt__Group__1 + // InternalBehaviorAnnexParser.g:13685:1: ( rule__SignedInt__Group__0__Impl rule__SignedInt__Group__1 ) + // InternalBehaviorAnnexParser.g:13686:2: rule__SignedInt__Group__0__Impl rule__SignedInt__Group__1 { pushFollow(FollowSets000.FOLLOW_90); rule__SignedInt__Group__0__Impl(); @@ -45206,31 +45301,31 @@ public final void rule__SignedInt__Group__0() throws RecognitionException { // $ANTLR start "rule__SignedInt__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13666:1: rule__SignedInt__Group__0__Impl : ( ( rule__SignedInt__Alternatives_0 )? ) ; + // InternalBehaviorAnnexParser.g:13693:1: rule__SignedInt__Group__0__Impl : ( ( rule__SignedInt__Alternatives_0 )? ) ; public final void rule__SignedInt__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13670:1: ( ( ( rule__SignedInt__Alternatives_0 )? ) ) - // InternalBehaviorAnnexParser.g:13671:1: ( ( rule__SignedInt__Alternatives_0 )? ) + // InternalBehaviorAnnexParser.g:13697:1: ( ( ( rule__SignedInt__Alternatives_0 )? ) ) + // InternalBehaviorAnnexParser.g:13698:1: ( ( rule__SignedInt__Alternatives_0 )? ) { - // InternalBehaviorAnnexParser.g:13671:1: ( ( rule__SignedInt__Alternatives_0 )? ) - // InternalBehaviorAnnexParser.g:13672:2: ( rule__SignedInt__Alternatives_0 )? + // InternalBehaviorAnnexParser.g:13698:1: ( ( rule__SignedInt__Alternatives_0 )? ) + // InternalBehaviorAnnexParser.g:13699:2: ( rule__SignedInt__Alternatives_0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getSignedIntAccess().getAlternatives_0()); } - // InternalBehaviorAnnexParser.g:13673:2: ( rule__SignedInt__Alternatives_0 )? - int alt115=2; - int LA115_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13700:2: ( rule__SignedInt__Alternatives_0 )? + int alt116=2; + int LA116_0 = input.LA(1); - if ( (LA115_0==PlusSign||LA115_0==HyphenMinus) ) { - alt115=1; + if ( (LA116_0==PlusSign||LA116_0==HyphenMinus) ) { + alt116=1; } - switch (alt115) { + switch (alt116) { case 1 : - // InternalBehaviorAnnexParser.g:13673:3: rule__SignedInt__Alternatives_0 + // InternalBehaviorAnnexParser.g:13700:3: rule__SignedInt__Alternatives_0 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedInt__Alternatives_0(); @@ -45268,14 +45363,14 @@ public final void rule__SignedInt__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__SignedInt__Group__1" - // InternalBehaviorAnnexParser.g:13681:1: rule__SignedInt__Group__1 : rule__SignedInt__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13708:1: rule__SignedInt__Group__1 : rule__SignedInt__Group__1__Impl ; public final void rule__SignedInt__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13685:1: ( rule__SignedInt__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13686:2: rule__SignedInt__Group__1__Impl + // InternalBehaviorAnnexParser.g:13712:1: ( rule__SignedInt__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13713:2: rule__SignedInt__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__SignedInt__Group__1__Impl(); @@ -45301,17 +45396,17 @@ public final void rule__SignedInt__Group__1() throws RecognitionException { // $ANTLR start "rule__SignedInt__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13692:1: rule__SignedInt__Group__1__Impl : ( RULE_INTEGER_LIT ) ; + // InternalBehaviorAnnexParser.g:13719:1: rule__SignedInt__Group__1__Impl : ( RULE_INTEGER_LIT ) ; public final void rule__SignedInt__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13696:1: ( ( RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:13697:1: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:13723:1: ( ( RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:13724:1: ( RULE_INTEGER_LIT ) { - // InternalBehaviorAnnexParser.g:13697:1: ( RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:13698:2: RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:13724:1: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:13725:2: RULE_INTEGER_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getSignedIntAccess().getINTEGER_LITTerminalRuleCall_1()); @@ -45342,14 +45437,14 @@ public final void rule__SignedInt__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__RealTerm__Group__0" - // InternalBehaviorAnnexParser.g:13708:1: rule__RealTerm__Group__0 : rule__RealTerm__Group__0__Impl rule__RealTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:13735:1: rule__RealTerm__Group__0 : rule__RealTerm__Group__0__Impl rule__RealTerm__Group__1 ; public final void rule__RealTerm__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13712:1: ( rule__RealTerm__Group__0__Impl rule__RealTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:13713:2: rule__RealTerm__Group__0__Impl rule__RealTerm__Group__1 + // InternalBehaviorAnnexParser.g:13739:1: ( rule__RealTerm__Group__0__Impl rule__RealTerm__Group__1 ) + // InternalBehaviorAnnexParser.g:13740:2: rule__RealTerm__Group__0__Impl rule__RealTerm__Group__1 { pushFollow(FollowSets000.FOLLOW_4); rule__RealTerm__Group__0__Impl(); @@ -45380,23 +45475,23 @@ public final void rule__RealTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__RealTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13720:1: rule__RealTerm__Group__0__Impl : ( ( rule__RealTerm__ValueAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:13747:1: rule__RealTerm__Group__0__Impl : ( ( rule__RealTerm__ValueAssignment_0 ) ) ; public final void rule__RealTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13724:1: ( ( ( rule__RealTerm__ValueAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:13725:1: ( ( rule__RealTerm__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13751:1: ( ( ( rule__RealTerm__ValueAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:13752:1: ( ( rule__RealTerm__ValueAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:13725:1: ( ( rule__RealTerm__ValueAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:13726:2: ( rule__RealTerm__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:13752:1: ( ( rule__RealTerm__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13753:2: ( rule__RealTerm__ValueAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getValueAssignment_0()); } - // InternalBehaviorAnnexParser.g:13727:2: ( rule__RealTerm__ValueAssignment_0 ) - // InternalBehaviorAnnexParser.g:13727:3: rule__RealTerm__ValueAssignment_0 + // InternalBehaviorAnnexParser.g:13754:2: ( rule__RealTerm__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:13754:3: rule__RealTerm__ValueAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__RealTerm__ValueAssignment_0(); @@ -45431,14 +45526,14 @@ public final void rule__RealTerm__Group__0__Impl() throws RecognitionException { // $ANTLR start "rule__RealTerm__Group__1" - // InternalBehaviorAnnexParser.g:13735:1: rule__RealTerm__Group__1 : rule__RealTerm__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13762:1: rule__RealTerm__Group__1 : rule__RealTerm__Group__1__Impl ; public final void rule__RealTerm__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13739:1: ( rule__RealTerm__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13740:2: rule__RealTerm__Group__1__Impl + // InternalBehaviorAnnexParser.g:13766:1: ( rule__RealTerm__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13767:2: rule__RealTerm__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__RealTerm__Group__1__Impl(); @@ -45464,31 +45559,31 @@ public final void rule__RealTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__RealTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13746:1: rule__RealTerm__Group__1__Impl : ( ( rule__RealTerm__UnitAssignment_1 )? ) ; + // InternalBehaviorAnnexParser.g:13773:1: rule__RealTerm__Group__1__Impl : ( ( rule__RealTerm__UnitAssignment_1 )? ) ; public final void rule__RealTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13750:1: ( ( ( rule__RealTerm__UnitAssignment_1 )? ) ) - // InternalBehaviorAnnexParser.g:13751:1: ( ( rule__RealTerm__UnitAssignment_1 )? ) + // InternalBehaviorAnnexParser.g:13777:1: ( ( ( rule__RealTerm__UnitAssignment_1 )? ) ) + // InternalBehaviorAnnexParser.g:13778:1: ( ( rule__RealTerm__UnitAssignment_1 )? ) { - // InternalBehaviorAnnexParser.g:13751:1: ( ( rule__RealTerm__UnitAssignment_1 )? ) - // InternalBehaviorAnnexParser.g:13752:2: ( rule__RealTerm__UnitAssignment_1 )? + // InternalBehaviorAnnexParser.g:13778:1: ( ( rule__RealTerm__UnitAssignment_1 )? ) + // InternalBehaviorAnnexParser.g:13779:2: ( rule__RealTerm__UnitAssignment_1 )? { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getUnitAssignment_1()); } - // InternalBehaviorAnnexParser.g:13753:2: ( rule__RealTerm__UnitAssignment_1 )? - int alt116=2; - int LA116_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13780:2: ( rule__RealTerm__UnitAssignment_1 )? + int alt117=2; + int LA117_0 = input.LA(1); - if ( (LA116_0==RULE_ID) ) { - alt116=1; + if ( (LA117_0==RULE_ID) ) { + alt117=1; } - switch (alt116) { + switch (alt117) { case 1 : - // InternalBehaviorAnnexParser.g:13753:3: rule__RealTerm__UnitAssignment_1 + // InternalBehaviorAnnexParser.g:13780:3: rule__RealTerm__UnitAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__RealTerm__UnitAssignment_1(); @@ -45526,14 +45621,14 @@ public final void rule__RealTerm__Group__1__Impl() throws RecognitionException { // $ANTLR start "rule__SignedReal__Group__0" - // InternalBehaviorAnnexParser.g:13762:1: rule__SignedReal__Group__0 : rule__SignedReal__Group__0__Impl rule__SignedReal__Group__1 ; + // InternalBehaviorAnnexParser.g:13789:1: rule__SignedReal__Group__0 : rule__SignedReal__Group__0__Impl rule__SignedReal__Group__1 ; public final void rule__SignedReal__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13766:1: ( rule__SignedReal__Group__0__Impl rule__SignedReal__Group__1 ) - // InternalBehaviorAnnexParser.g:13767:2: rule__SignedReal__Group__0__Impl rule__SignedReal__Group__1 + // InternalBehaviorAnnexParser.g:13793:1: ( rule__SignedReal__Group__0__Impl rule__SignedReal__Group__1 ) + // InternalBehaviorAnnexParser.g:13794:2: rule__SignedReal__Group__0__Impl rule__SignedReal__Group__1 { pushFollow(FollowSets000.FOLLOW_91); rule__SignedReal__Group__0__Impl(); @@ -45564,31 +45659,31 @@ public final void rule__SignedReal__Group__0() throws RecognitionException { // $ANTLR start "rule__SignedReal__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13774:1: rule__SignedReal__Group__0__Impl : ( ( rule__SignedReal__Alternatives_0 )? ) ; + // InternalBehaviorAnnexParser.g:13801:1: rule__SignedReal__Group__0__Impl : ( ( rule__SignedReal__Alternatives_0 )? ) ; public final void rule__SignedReal__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13778:1: ( ( ( rule__SignedReal__Alternatives_0 )? ) ) - // InternalBehaviorAnnexParser.g:13779:1: ( ( rule__SignedReal__Alternatives_0 )? ) + // InternalBehaviorAnnexParser.g:13805:1: ( ( ( rule__SignedReal__Alternatives_0 )? ) ) + // InternalBehaviorAnnexParser.g:13806:1: ( ( rule__SignedReal__Alternatives_0 )? ) { - // InternalBehaviorAnnexParser.g:13779:1: ( ( rule__SignedReal__Alternatives_0 )? ) - // InternalBehaviorAnnexParser.g:13780:2: ( rule__SignedReal__Alternatives_0 )? + // InternalBehaviorAnnexParser.g:13806:1: ( ( rule__SignedReal__Alternatives_0 )? ) + // InternalBehaviorAnnexParser.g:13807:2: ( rule__SignedReal__Alternatives_0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getSignedRealAccess().getAlternatives_0()); } - // InternalBehaviorAnnexParser.g:13781:2: ( rule__SignedReal__Alternatives_0 )? - int alt117=2; - int LA117_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13808:2: ( rule__SignedReal__Alternatives_0 )? + int alt118=2; + int LA118_0 = input.LA(1); - if ( (LA117_0==PlusSign||LA117_0==HyphenMinus) ) { - alt117=1; + if ( (LA118_0==PlusSign||LA118_0==HyphenMinus) ) { + alt118=1; } - switch (alt117) { + switch (alt118) { case 1 : - // InternalBehaviorAnnexParser.g:13781:3: rule__SignedReal__Alternatives_0 + // InternalBehaviorAnnexParser.g:13808:3: rule__SignedReal__Alternatives_0 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedReal__Alternatives_0(); @@ -45626,14 +45721,14 @@ public final void rule__SignedReal__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__SignedReal__Group__1" - // InternalBehaviorAnnexParser.g:13789:1: rule__SignedReal__Group__1 : rule__SignedReal__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13816:1: rule__SignedReal__Group__1 : rule__SignedReal__Group__1__Impl ; public final void rule__SignedReal__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13793:1: ( rule__SignedReal__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13794:2: rule__SignedReal__Group__1__Impl + // InternalBehaviorAnnexParser.g:13820:1: ( rule__SignedReal__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13821:2: rule__SignedReal__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__SignedReal__Group__1__Impl(); @@ -45659,17 +45754,17 @@ public final void rule__SignedReal__Group__1() throws RecognitionException { // $ANTLR start "rule__SignedReal__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13800:1: rule__SignedReal__Group__1__Impl : ( RULE_REAL_LIT ) ; + // InternalBehaviorAnnexParser.g:13827:1: rule__SignedReal__Group__1__Impl : ( RULE_REAL_LIT ) ; public final void rule__SignedReal__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13804:1: ( ( RULE_REAL_LIT ) ) - // InternalBehaviorAnnexParser.g:13805:1: ( RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:13831:1: ( ( RULE_REAL_LIT ) ) + // InternalBehaviorAnnexParser.g:13832:1: ( RULE_REAL_LIT ) { - // InternalBehaviorAnnexParser.g:13805:1: ( RULE_REAL_LIT ) - // InternalBehaviorAnnexParser.g:13806:2: RULE_REAL_LIT + // InternalBehaviorAnnexParser.g:13832:1: ( RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:13833:2: RULE_REAL_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getSignedRealAccess().getREAL_LITTerminalRuleCall_1()); @@ -45700,14 +45795,14 @@ public final void rule__SignedReal__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__Group__0" - // InternalBehaviorAnnexParser.g:13816:1: rule__NumericRangeTerm__Group__0 : rule__NumericRangeTerm__Group__0__Impl rule__NumericRangeTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:13843:1: rule__NumericRangeTerm__Group__0 : rule__NumericRangeTerm__Group__0__Impl rule__NumericRangeTerm__Group__1 ; public final void rule__NumericRangeTerm__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13820:1: ( rule__NumericRangeTerm__Group__0__Impl rule__NumericRangeTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:13821:2: rule__NumericRangeTerm__Group__0__Impl rule__NumericRangeTerm__Group__1 + // InternalBehaviorAnnexParser.g:13847:1: ( rule__NumericRangeTerm__Group__0__Impl rule__NumericRangeTerm__Group__1 ) + // InternalBehaviorAnnexParser.g:13848:2: rule__NumericRangeTerm__Group__0__Impl rule__NumericRangeTerm__Group__1 { pushFollow(FollowSets000.FOLLOW_58); rule__NumericRangeTerm__Group__0__Impl(); @@ -45738,23 +45833,23 @@ public final void rule__NumericRangeTerm__Group__0() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13828:1: rule__NumericRangeTerm__Group__0__Impl : ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:13855:1: rule__NumericRangeTerm__Group__0__Impl : ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) ; public final void rule__NumericRangeTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13832:1: ( ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:13833:1: ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13859:1: ( ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:13860:1: ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:13833:1: ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:13834:2: ( rule__NumericRangeTerm__MinimumAssignment_0 ) + // InternalBehaviorAnnexParser.g:13860:1: ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13861:2: ( rule__NumericRangeTerm__MinimumAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getMinimumAssignment_0()); } - // InternalBehaviorAnnexParser.g:13835:2: ( rule__NumericRangeTerm__MinimumAssignment_0 ) - // InternalBehaviorAnnexParser.g:13835:3: rule__NumericRangeTerm__MinimumAssignment_0 + // InternalBehaviorAnnexParser.g:13862:2: ( rule__NumericRangeTerm__MinimumAssignment_0 ) + // InternalBehaviorAnnexParser.g:13862:3: rule__NumericRangeTerm__MinimumAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__MinimumAssignment_0(); @@ -45789,14 +45884,14 @@ public final void rule__NumericRangeTerm__Group__0__Impl() throws RecognitionExc // $ANTLR start "rule__NumericRangeTerm__Group__1" - // InternalBehaviorAnnexParser.g:13843:1: rule__NumericRangeTerm__Group__1 : rule__NumericRangeTerm__Group__1__Impl rule__NumericRangeTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:13870:1: rule__NumericRangeTerm__Group__1 : rule__NumericRangeTerm__Group__1__Impl rule__NumericRangeTerm__Group__2 ; public final void rule__NumericRangeTerm__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13847:1: ( rule__NumericRangeTerm__Group__1__Impl rule__NumericRangeTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:13848:2: rule__NumericRangeTerm__Group__1__Impl rule__NumericRangeTerm__Group__2 + // InternalBehaviorAnnexParser.g:13874:1: ( rule__NumericRangeTerm__Group__1__Impl rule__NumericRangeTerm__Group__2 ) + // InternalBehaviorAnnexParser.g:13875:2: rule__NumericRangeTerm__Group__1__Impl rule__NumericRangeTerm__Group__2 { pushFollow(FollowSets000.FOLLOW_89); rule__NumericRangeTerm__Group__1__Impl(); @@ -45827,17 +45922,17 @@ public final void rule__NumericRangeTerm__Group__1() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13855:1: rule__NumericRangeTerm__Group__1__Impl : ( FullStopFullStop ) ; + // InternalBehaviorAnnexParser.g:13882:1: rule__NumericRangeTerm__Group__1__Impl : ( FullStopFullStop ) ; public final void rule__NumericRangeTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13859:1: ( ( FullStopFullStop ) ) - // InternalBehaviorAnnexParser.g:13860:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:13886:1: ( ( FullStopFullStop ) ) + // InternalBehaviorAnnexParser.g:13887:1: ( FullStopFullStop ) { - // InternalBehaviorAnnexParser.g:13860:1: ( FullStopFullStop ) - // InternalBehaviorAnnexParser.g:13861:2: FullStopFullStop + // InternalBehaviorAnnexParser.g:13887:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:13888:2: FullStopFullStop { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getFullStopFullStopKeyword_1()); @@ -45868,14 +45963,14 @@ public final void rule__NumericRangeTerm__Group__1__Impl() throws RecognitionExc // $ANTLR start "rule__NumericRangeTerm__Group__2" - // InternalBehaviorAnnexParser.g:13870:1: rule__NumericRangeTerm__Group__2 : rule__NumericRangeTerm__Group__2__Impl rule__NumericRangeTerm__Group__3 ; + // InternalBehaviorAnnexParser.g:13897:1: rule__NumericRangeTerm__Group__2 : rule__NumericRangeTerm__Group__2__Impl rule__NumericRangeTerm__Group__3 ; public final void rule__NumericRangeTerm__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13874:1: ( rule__NumericRangeTerm__Group__2__Impl rule__NumericRangeTerm__Group__3 ) - // InternalBehaviorAnnexParser.g:13875:2: rule__NumericRangeTerm__Group__2__Impl rule__NumericRangeTerm__Group__3 + // InternalBehaviorAnnexParser.g:13901:1: ( rule__NumericRangeTerm__Group__2__Impl rule__NumericRangeTerm__Group__3 ) + // InternalBehaviorAnnexParser.g:13902:2: rule__NumericRangeTerm__Group__2__Impl rule__NumericRangeTerm__Group__3 { pushFollow(FollowSets000.FOLLOW_92); rule__NumericRangeTerm__Group__2__Impl(); @@ -45906,23 +46001,23 @@ public final void rule__NumericRangeTerm__Group__2() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:13882:1: rule__NumericRangeTerm__Group__2__Impl : ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:13909:1: rule__NumericRangeTerm__Group__2__Impl : ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) ; public final void rule__NumericRangeTerm__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13886:1: ( ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:13887:1: ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13913:1: ( ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:13914:1: ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:13887:1: ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:13888:2: ( rule__NumericRangeTerm__MaximumAssignment_2 ) + // InternalBehaviorAnnexParser.g:13914:1: ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13915:2: ( rule__NumericRangeTerm__MaximumAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getMaximumAssignment_2()); } - // InternalBehaviorAnnexParser.g:13889:2: ( rule__NumericRangeTerm__MaximumAssignment_2 ) - // InternalBehaviorAnnexParser.g:13889:3: rule__NumericRangeTerm__MaximumAssignment_2 + // InternalBehaviorAnnexParser.g:13916:2: ( rule__NumericRangeTerm__MaximumAssignment_2 ) + // InternalBehaviorAnnexParser.g:13916:3: rule__NumericRangeTerm__MaximumAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__MaximumAssignment_2(); @@ -45957,14 +46052,14 @@ public final void rule__NumericRangeTerm__Group__2__Impl() throws RecognitionExc // $ANTLR start "rule__NumericRangeTerm__Group__3" - // InternalBehaviorAnnexParser.g:13897:1: rule__NumericRangeTerm__Group__3 : rule__NumericRangeTerm__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:13924:1: rule__NumericRangeTerm__Group__3 : rule__NumericRangeTerm__Group__3__Impl ; public final void rule__NumericRangeTerm__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13901:1: ( rule__NumericRangeTerm__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:13902:2: rule__NumericRangeTerm__Group__3__Impl + // InternalBehaviorAnnexParser.g:13928:1: ( rule__NumericRangeTerm__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:13929:2: rule__NumericRangeTerm__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__Group__3__Impl(); @@ -45990,31 +46085,31 @@ public final void rule__NumericRangeTerm__Group__3() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__Group__3__Impl" - // InternalBehaviorAnnexParser.g:13908:1: rule__NumericRangeTerm__Group__3__Impl : ( ( rule__NumericRangeTerm__Group_3__0 )? ) ; + // InternalBehaviorAnnexParser.g:13935:1: rule__NumericRangeTerm__Group__3__Impl : ( ( rule__NumericRangeTerm__Group_3__0 )? ) ; public final void rule__NumericRangeTerm__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13912:1: ( ( ( rule__NumericRangeTerm__Group_3__0 )? ) ) - // InternalBehaviorAnnexParser.g:13913:1: ( ( rule__NumericRangeTerm__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:13939:1: ( ( ( rule__NumericRangeTerm__Group_3__0 )? ) ) + // InternalBehaviorAnnexParser.g:13940:1: ( ( rule__NumericRangeTerm__Group_3__0 )? ) { - // InternalBehaviorAnnexParser.g:13913:1: ( ( rule__NumericRangeTerm__Group_3__0 )? ) - // InternalBehaviorAnnexParser.g:13914:2: ( rule__NumericRangeTerm__Group_3__0 )? + // InternalBehaviorAnnexParser.g:13940:1: ( ( rule__NumericRangeTerm__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:13941:2: ( rule__NumericRangeTerm__Group_3__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getGroup_3()); } - // InternalBehaviorAnnexParser.g:13915:2: ( rule__NumericRangeTerm__Group_3__0 )? - int alt118=2; - int LA118_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13942:2: ( rule__NumericRangeTerm__Group_3__0 )? + int alt119=2; + int LA119_0 = input.LA(1); - if ( (LA118_0==Delta) ) { - alt118=1; + if ( (LA119_0==Delta) ) { + alt119=1; } - switch (alt118) { + switch (alt119) { case 1 : - // InternalBehaviorAnnexParser.g:13915:3: rule__NumericRangeTerm__Group_3__0 + // InternalBehaviorAnnexParser.g:13942:3: rule__NumericRangeTerm__Group_3__0 { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__Group_3__0(); @@ -46052,14 +46147,14 @@ public final void rule__NumericRangeTerm__Group__3__Impl() throws RecognitionExc // $ANTLR start "rule__NumericRangeTerm__Group_3__0" - // InternalBehaviorAnnexParser.g:13924:1: rule__NumericRangeTerm__Group_3__0 : rule__NumericRangeTerm__Group_3__0__Impl rule__NumericRangeTerm__Group_3__1 ; + // InternalBehaviorAnnexParser.g:13951:1: rule__NumericRangeTerm__Group_3__0 : rule__NumericRangeTerm__Group_3__0__Impl rule__NumericRangeTerm__Group_3__1 ; public final void rule__NumericRangeTerm__Group_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13928:1: ( rule__NumericRangeTerm__Group_3__0__Impl rule__NumericRangeTerm__Group_3__1 ) - // InternalBehaviorAnnexParser.g:13929:2: rule__NumericRangeTerm__Group_3__0__Impl rule__NumericRangeTerm__Group_3__1 + // InternalBehaviorAnnexParser.g:13955:1: ( rule__NumericRangeTerm__Group_3__0__Impl rule__NumericRangeTerm__Group_3__1 ) + // InternalBehaviorAnnexParser.g:13956:2: rule__NumericRangeTerm__Group_3__0__Impl rule__NumericRangeTerm__Group_3__1 { pushFollow(FollowSets000.FOLLOW_89); rule__NumericRangeTerm__Group_3__0__Impl(); @@ -46090,17 +46185,17 @@ public final void rule__NumericRangeTerm__Group_3__0() throws RecognitionExcepti // $ANTLR start "rule__NumericRangeTerm__Group_3__0__Impl" - // InternalBehaviorAnnexParser.g:13936:1: rule__NumericRangeTerm__Group_3__0__Impl : ( Delta ) ; + // InternalBehaviorAnnexParser.g:13963:1: rule__NumericRangeTerm__Group_3__0__Impl : ( Delta ) ; public final void rule__NumericRangeTerm__Group_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13940:1: ( ( Delta ) ) - // InternalBehaviorAnnexParser.g:13941:1: ( Delta ) + // InternalBehaviorAnnexParser.g:13967:1: ( ( Delta ) ) + // InternalBehaviorAnnexParser.g:13968:1: ( Delta ) { - // InternalBehaviorAnnexParser.g:13941:1: ( Delta ) - // InternalBehaviorAnnexParser.g:13942:2: Delta + // InternalBehaviorAnnexParser.g:13968:1: ( Delta ) + // InternalBehaviorAnnexParser.g:13969:2: Delta { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getDeltaKeyword_3_0()); @@ -46131,14 +46226,14 @@ public final void rule__NumericRangeTerm__Group_3__0__Impl() throws RecognitionE // $ANTLR start "rule__NumericRangeTerm__Group_3__1" - // InternalBehaviorAnnexParser.g:13951:1: rule__NumericRangeTerm__Group_3__1 : rule__NumericRangeTerm__Group_3__1__Impl ; + // InternalBehaviorAnnexParser.g:13978:1: rule__NumericRangeTerm__Group_3__1 : rule__NumericRangeTerm__Group_3__1__Impl ; public final void rule__NumericRangeTerm__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13955:1: ( rule__NumericRangeTerm__Group_3__1__Impl ) - // InternalBehaviorAnnexParser.g:13956:2: rule__NumericRangeTerm__Group_3__1__Impl + // InternalBehaviorAnnexParser.g:13982:1: ( rule__NumericRangeTerm__Group_3__1__Impl ) + // InternalBehaviorAnnexParser.g:13983:2: rule__NumericRangeTerm__Group_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__Group_3__1__Impl(); @@ -46164,23 +46259,23 @@ public final void rule__NumericRangeTerm__Group_3__1() throws RecognitionExcepti // $ANTLR start "rule__NumericRangeTerm__Group_3__1__Impl" - // InternalBehaviorAnnexParser.g:13962:1: rule__NumericRangeTerm__Group_3__1__Impl : ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:13989:1: rule__NumericRangeTerm__Group_3__1__Impl : ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) ; public final void rule__NumericRangeTerm__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13966:1: ( ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:13967:1: ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:13993:1: ( ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:13994:1: ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) { - // InternalBehaviorAnnexParser.g:13967:1: ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) - // InternalBehaviorAnnexParser.g:13968:2: ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:13994:1: ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:13995:2: ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getDeltaAssignment_3_1()); } - // InternalBehaviorAnnexParser.g:13969:2: ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) - // InternalBehaviorAnnexParser.g:13969:3: rule__NumericRangeTerm__DeltaAssignment_3_1 + // InternalBehaviorAnnexParser.g:13996:2: ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:13996:3: rule__NumericRangeTerm__DeltaAssignment_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__DeltaAssignment_3_1(); @@ -46215,14 +46310,14 @@ public final void rule__NumericRangeTerm__Group_3__1__Impl() throws RecognitionE // $ANTLR start "rule__QPREF__Group__0" - // InternalBehaviorAnnexParser.g:13978:1: rule__QPREF__Group__0 : rule__QPREF__Group__0__Impl rule__QPREF__Group__1 ; + // InternalBehaviorAnnexParser.g:14005:1: rule__QPREF__Group__0 : rule__QPREF__Group__0__Impl rule__QPREF__Group__1 ; public final void rule__QPREF__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13982:1: ( rule__QPREF__Group__0__Impl rule__QPREF__Group__1 ) - // InternalBehaviorAnnexParser.g:13983:2: rule__QPREF__Group__0__Impl rule__QPREF__Group__1 + // InternalBehaviorAnnexParser.g:14009:1: ( rule__QPREF__Group__0__Impl rule__QPREF__Group__1 ) + // InternalBehaviorAnnexParser.g:14010:2: rule__QPREF__Group__0__Impl rule__QPREF__Group__1 { pushFollow(FollowSets000.FOLLOW_78); rule__QPREF__Group__0__Impl(); @@ -46253,17 +46348,17 @@ public final void rule__QPREF__Group__0() throws RecognitionException { // $ANTLR start "rule__QPREF__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13990:1: rule__QPREF__Group__0__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14017:1: rule__QPREF__Group__0__Impl : ( RULE_ID ) ; public final void rule__QPREF__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13994:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:13995:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14021:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14022:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:13995:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:13996:2: RULE_ID + // InternalBehaviorAnnexParser.g:14022:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14023:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQPREFAccess().getIDTerminalRuleCall_0()); @@ -46294,14 +46389,14 @@ public final void rule__QPREF__Group__0__Impl() throws RecognitionException { // $ANTLR start "rule__QPREF__Group__1" - // InternalBehaviorAnnexParser.g:14005:1: rule__QPREF__Group__1 : rule__QPREF__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:14032:1: rule__QPREF__Group__1 : rule__QPREF__Group__1__Impl ; public final void rule__QPREF__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14009:1: ( rule__QPREF__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:14010:2: rule__QPREF__Group__1__Impl + // InternalBehaviorAnnexParser.g:14036:1: ( rule__QPREF__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:14037:2: rule__QPREF__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QPREF__Group__1__Impl(); @@ -46327,31 +46422,31 @@ public final void rule__QPREF__Group__1() throws RecognitionException { // $ANTLR start "rule__QPREF__Group__1__Impl" - // InternalBehaviorAnnexParser.g:14016:1: rule__QPREF__Group__1__Impl : ( ( rule__QPREF__Group_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:14043:1: rule__QPREF__Group__1__Impl : ( ( rule__QPREF__Group_1__0 )? ) ; public final void rule__QPREF__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14020:1: ( ( ( rule__QPREF__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:14021:1: ( ( rule__QPREF__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:14047:1: ( ( ( rule__QPREF__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:14048:1: ( ( rule__QPREF__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:14021:1: ( ( rule__QPREF__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:14022:2: ( rule__QPREF__Group_1__0 )? + // InternalBehaviorAnnexParser.g:14048:1: ( ( rule__QPREF__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:14049:2: ( rule__QPREF__Group_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getQPREFAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:14023:2: ( rule__QPREF__Group_1__0 )? - int alt119=2; - int LA119_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:14050:2: ( rule__QPREF__Group_1__0 )? + int alt120=2; + int LA120_0 = input.LA(1); - if ( (LA119_0==ColonColon) ) { - alt119=1; + if ( (LA120_0==ColonColon) ) { + alt120=1; } - switch (alt119) { + switch (alt120) { case 1 : - // InternalBehaviorAnnexParser.g:14023:3: rule__QPREF__Group_1__0 + // InternalBehaviorAnnexParser.g:14050:3: rule__QPREF__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__QPREF__Group_1__0(); @@ -46389,14 +46484,14 @@ public final void rule__QPREF__Group__1__Impl() throws RecognitionException { // $ANTLR start "rule__QPREF__Group_1__0" - // InternalBehaviorAnnexParser.g:14032:1: rule__QPREF__Group_1__0 : rule__QPREF__Group_1__0__Impl rule__QPREF__Group_1__1 ; + // InternalBehaviorAnnexParser.g:14059:1: rule__QPREF__Group_1__0 : rule__QPREF__Group_1__0__Impl rule__QPREF__Group_1__1 ; public final void rule__QPREF__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14036:1: ( rule__QPREF__Group_1__0__Impl rule__QPREF__Group_1__1 ) - // InternalBehaviorAnnexParser.g:14037:2: rule__QPREF__Group_1__0__Impl rule__QPREF__Group_1__1 + // InternalBehaviorAnnexParser.g:14063:1: ( rule__QPREF__Group_1__0__Impl rule__QPREF__Group_1__1 ) + // InternalBehaviorAnnexParser.g:14064:2: rule__QPREF__Group_1__0__Impl rule__QPREF__Group_1__1 { pushFollow(FollowSets000.FOLLOW_4); rule__QPREF__Group_1__0__Impl(); @@ -46427,17 +46522,17 @@ public final void rule__QPREF__Group_1__0() throws RecognitionException { // $ANTLR start "rule__QPREF__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:14044:1: rule__QPREF__Group_1__0__Impl : ( ColonColon ) ; + // InternalBehaviorAnnexParser.g:14071:1: rule__QPREF__Group_1__0__Impl : ( ColonColon ) ; public final void rule__QPREF__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14048:1: ( ( ColonColon ) ) - // InternalBehaviorAnnexParser.g:14049:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:14075:1: ( ( ColonColon ) ) + // InternalBehaviorAnnexParser.g:14076:1: ( ColonColon ) { - // InternalBehaviorAnnexParser.g:14049:1: ( ColonColon ) - // InternalBehaviorAnnexParser.g:14050:2: ColonColon + // InternalBehaviorAnnexParser.g:14076:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:14077:2: ColonColon { if ( state.backtracking==0 ) { before(grammarAccess.getQPREFAccess().getColonColonKeyword_1_0()); @@ -46468,14 +46563,14 @@ public final void rule__QPREF__Group_1__0__Impl() throws RecognitionException { // $ANTLR start "rule__QPREF__Group_1__1" - // InternalBehaviorAnnexParser.g:14059:1: rule__QPREF__Group_1__1 : rule__QPREF__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:14086:1: rule__QPREF__Group_1__1 : rule__QPREF__Group_1__1__Impl ; public final void rule__QPREF__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14063:1: ( rule__QPREF__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:14064:2: rule__QPREF__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:14090:1: ( rule__QPREF__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:14091:2: rule__QPREF__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QPREF__Group_1__1__Impl(); @@ -46501,17 +46596,17 @@ public final void rule__QPREF__Group_1__1() throws RecognitionException { // $ANTLR start "rule__QPREF__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:14070:1: rule__QPREF__Group_1__1__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14097:1: rule__QPREF__Group_1__1__Impl : ( RULE_ID ) ; public final void rule__QPREF__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14074:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14075:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14101:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14102:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14075:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14076:2: RULE_ID + // InternalBehaviorAnnexParser.g:14102:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14103:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQPREFAccess().getIDTerminalRuleCall_1_1()); @@ -46542,14 +46637,14 @@ public final void rule__QPREF__Group_1__1__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__0" - // InternalBehaviorAnnexParser.g:14086:1: rule__QCREF__Group__0 : rule__QCREF__Group__0__Impl rule__QCREF__Group__1 ; + // InternalBehaviorAnnexParser.g:14113:1: rule__QCREF__Group__0 : rule__QCREF__Group__0__Impl rule__QCREF__Group__1 ; public final void rule__QCREF__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14090:1: ( rule__QCREF__Group__0__Impl rule__QCREF__Group__1 ) - // InternalBehaviorAnnexParser.g:14091:2: rule__QCREF__Group__0__Impl rule__QCREF__Group__1 + // InternalBehaviorAnnexParser.g:14117:1: ( rule__QCREF__Group__0__Impl rule__QCREF__Group__1 ) + // InternalBehaviorAnnexParser.g:14118:2: rule__QCREF__Group__0__Impl rule__QCREF__Group__1 { pushFollow(FollowSets000.FOLLOW_4); rule__QCREF__Group__0__Impl(); @@ -46580,41 +46675,41 @@ public final void rule__QCREF__Group__0() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__0__Impl" - // InternalBehaviorAnnexParser.g:14098:1: rule__QCREF__Group__0__Impl : ( ( rule__QCREF__Group_0__0 )* ) ; + // InternalBehaviorAnnexParser.g:14125:1: rule__QCREF__Group__0__Impl : ( ( rule__QCREF__Group_0__0 )* ) ; public final void rule__QCREF__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14102:1: ( ( ( rule__QCREF__Group_0__0 )* ) ) - // InternalBehaviorAnnexParser.g:14103:1: ( ( rule__QCREF__Group_0__0 )* ) + // InternalBehaviorAnnexParser.g:14129:1: ( ( ( rule__QCREF__Group_0__0 )* ) ) + // InternalBehaviorAnnexParser.g:14130:1: ( ( rule__QCREF__Group_0__0 )* ) { - // InternalBehaviorAnnexParser.g:14103:1: ( ( rule__QCREF__Group_0__0 )* ) - // InternalBehaviorAnnexParser.g:14104:2: ( rule__QCREF__Group_0__0 )* + // InternalBehaviorAnnexParser.g:14130:1: ( ( rule__QCREF__Group_0__0 )* ) + // InternalBehaviorAnnexParser.g:14131:2: ( rule__QCREF__Group_0__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getGroup_0()); } - // InternalBehaviorAnnexParser.g:14105:2: ( rule__QCREF__Group_0__0 )* - loop120: + // InternalBehaviorAnnexParser.g:14132:2: ( rule__QCREF__Group_0__0 )* + loop121: do { - int alt120=2; - int LA120_0 = input.LA(1); + int alt121=2; + int LA121_0 = input.LA(1); - if ( (LA120_0==RULE_ID) ) { - int LA120_1 = input.LA(2); + if ( (LA121_0==RULE_ID) ) { + int LA121_1 = input.LA(2); - if ( (LA120_1==ColonColon) ) { - alt120=1; + if ( (LA121_1==ColonColon) ) { + alt121=1; } } - switch (alt120) { + switch (alt121) { case 1 : - // InternalBehaviorAnnexParser.g:14105:3: rule__QCREF__Group_0__0 + // InternalBehaviorAnnexParser.g:14132:3: rule__QCREF__Group_0__0 { pushFollow(FollowSets000.FOLLOW_5); rule__QCREF__Group_0__0(); @@ -46626,7 +46721,7 @@ public final void rule__QCREF__Group__0__Impl() throws RecognitionException { break; default : - break loop120; + break loop121; } } while (true); @@ -46655,14 +46750,14 @@ public final void rule__QCREF__Group__0__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__1" - // InternalBehaviorAnnexParser.g:14113:1: rule__QCREF__Group__1 : rule__QCREF__Group__1__Impl rule__QCREF__Group__2 ; + // InternalBehaviorAnnexParser.g:14140:1: rule__QCREF__Group__1 : rule__QCREF__Group__1__Impl rule__QCREF__Group__2 ; public final void rule__QCREF__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14117:1: ( rule__QCREF__Group__1__Impl rule__QCREF__Group__2 ) - // InternalBehaviorAnnexParser.g:14118:2: rule__QCREF__Group__1__Impl rule__QCREF__Group__2 + // InternalBehaviorAnnexParser.g:14144:1: ( rule__QCREF__Group__1__Impl rule__QCREF__Group__2 ) + // InternalBehaviorAnnexParser.g:14145:2: rule__QCREF__Group__1__Impl rule__QCREF__Group__2 { pushFollow(FollowSets000.FOLLOW_87); rule__QCREF__Group__1__Impl(); @@ -46693,17 +46788,17 @@ public final void rule__QCREF__Group__1() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__1__Impl" - // InternalBehaviorAnnexParser.g:14125:1: rule__QCREF__Group__1__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14152:1: rule__QCREF__Group__1__Impl : ( RULE_ID ) ; public final void rule__QCREF__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14129:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14130:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14156:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14157:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14130:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14131:2: RULE_ID + // InternalBehaviorAnnexParser.g:14157:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14158:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getIDTerminalRuleCall_1()); @@ -46734,14 +46829,14 @@ public final void rule__QCREF__Group__1__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__2" - // InternalBehaviorAnnexParser.g:14140:1: rule__QCREF__Group__2 : rule__QCREF__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:14167:1: rule__QCREF__Group__2 : rule__QCREF__Group__2__Impl ; public final void rule__QCREF__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14144:1: ( rule__QCREF__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:14145:2: rule__QCREF__Group__2__Impl + // InternalBehaviorAnnexParser.g:14171:1: ( rule__QCREF__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:14172:2: rule__QCREF__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QCREF__Group__2__Impl(); @@ -46767,31 +46862,31 @@ public final void rule__QCREF__Group__2() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__2__Impl" - // InternalBehaviorAnnexParser.g:14151:1: rule__QCREF__Group__2__Impl : ( ( rule__QCREF__Group_2__0 )? ) ; + // InternalBehaviorAnnexParser.g:14178:1: rule__QCREF__Group__2__Impl : ( ( rule__QCREF__Group_2__0 )? ) ; public final void rule__QCREF__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14155:1: ( ( ( rule__QCREF__Group_2__0 )? ) ) - // InternalBehaviorAnnexParser.g:14156:1: ( ( rule__QCREF__Group_2__0 )? ) + // InternalBehaviorAnnexParser.g:14182:1: ( ( ( rule__QCREF__Group_2__0 )? ) ) + // InternalBehaviorAnnexParser.g:14183:1: ( ( rule__QCREF__Group_2__0 )? ) { - // InternalBehaviorAnnexParser.g:14156:1: ( ( rule__QCREF__Group_2__0 )? ) - // InternalBehaviorAnnexParser.g:14157:2: ( rule__QCREF__Group_2__0 )? + // InternalBehaviorAnnexParser.g:14183:1: ( ( rule__QCREF__Group_2__0 )? ) + // InternalBehaviorAnnexParser.g:14184:2: ( rule__QCREF__Group_2__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getGroup_2()); } - // InternalBehaviorAnnexParser.g:14158:2: ( rule__QCREF__Group_2__0 )? - int alt121=2; - int LA121_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:14185:2: ( rule__QCREF__Group_2__0 )? + int alt122=2; + int LA122_0 = input.LA(1); - if ( (LA121_0==FullStop) ) { - alt121=1; + if ( (LA122_0==FullStop) ) { + alt122=1; } - switch (alt121) { + switch (alt122) { case 1 : - // InternalBehaviorAnnexParser.g:14158:3: rule__QCREF__Group_2__0 + // InternalBehaviorAnnexParser.g:14185:3: rule__QCREF__Group_2__0 { pushFollow(FollowSets000.FOLLOW_2); rule__QCREF__Group_2__0(); @@ -46829,14 +46924,14 @@ public final void rule__QCREF__Group__2__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_0__0" - // InternalBehaviorAnnexParser.g:14167:1: rule__QCREF__Group_0__0 : rule__QCREF__Group_0__0__Impl rule__QCREF__Group_0__1 ; + // InternalBehaviorAnnexParser.g:14194:1: rule__QCREF__Group_0__0 : rule__QCREF__Group_0__0__Impl rule__QCREF__Group_0__1 ; public final void rule__QCREF__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14171:1: ( rule__QCREF__Group_0__0__Impl rule__QCREF__Group_0__1 ) - // InternalBehaviorAnnexParser.g:14172:2: rule__QCREF__Group_0__0__Impl rule__QCREF__Group_0__1 + // InternalBehaviorAnnexParser.g:14198:1: ( rule__QCREF__Group_0__0__Impl rule__QCREF__Group_0__1 ) + // InternalBehaviorAnnexParser.g:14199:2: rule__QCREF__Group_0__0__Impl rule__QCREF__Group_0__1 { pushFollow(FollowSets000.FOLLOW_78); rule__QCREF__Group_0__0__Impl(); @@ -46867,17 +46962,17 @@ public final void rule__QCREF__Group_0__0() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:14179:1: rule__QCREF__Group_0__0__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14206:1: rule__QCREF__Group_0__0__Impl : ( RULE_ID ) ; public final void rule__QCREF__Group_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14183:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14184:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14210:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14211:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14184:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14185:2: RULE_ID + // InternalBehaviorAnnexParser.g:14211:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14212:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getIDTerminalRuleCall_0_0()); @@ -46908,14 +47003,14 @@ public final void rule__QCREF__Group_0__0__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_0__1" - // InternalBehaviorAnnexParser.g:14194:1: rule__QCREF__Group_0__1 : rule__QCREF__Group_0__1__Impl ; + // InternalBehaviorAnnexParser.g:14221:1: rule__QCREF__Group_0__1 : rule__QCREF__Group_0__1__Impl ; public final void rule__QCREF__Group_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14198:1: ( rule__QCREF__Group_0__1__Impl ) - // InternalBehaviorAnnexParser.g:14199:2: rule__QCREF__Group_0__1__Impl + // InternalBehaviorAnnexParser.g:14225:1: ( rule__QCREF__Group_0__1__Impl ) + // InternalBehaviorAnnexParser.g:14226:2: rule__QCREF__Group_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QCREF__Group_0__1__Impl(); @@ -46941,17 +47036,17 @@ public final void rule__QCREF__Group_0__1() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:14205:1: rule__QCREF__Group_0__1__Impl : ( ColonColon ) ; + // InternalBehaviorAnnexParser.g:14232:1: rule__QCREF__Group_0__1__Impl : ( ColonColon ) ; public final void rule__QCREF__Group_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14209:1: ( ( ColonColon ) ) - // InternalBehaviorAnnexParser.g:14210:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:14236:1: ( ( ColonColon ) ) + // InternalBehaviorAnnexParser.g:14237:1: ( ColonColon ) { - // InternalBehaviorAnnexParser.g:14210:1: ( ColonColon ) - // InternalBehaviorAnnexParser.g:14211:2: ColonColon + // InternalBehaviorAnnexParser.g:14237:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:14238:2: ColonColon { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getColonColonKeyword_0_1()); @@ -46982,14 +47077,14 @@ public final void rule__QCREF__Group_0__1__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_2__0" - // InternalBehaviorAnnexParser.g:14221:1: rule__QCREF__Group_2__0 : rule__QCREF__Group_2__0__Impl rule__QCREF__Group_2__1 ; + // InternalBehaviorAnnexParser.g:14248:1: rule__QCREF__Group_2__0 : rule__QCREF__Group_2__0__Impl rule__QCREF__Group_2__1 ; public final void rule__QCREF__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14225:1: ( rule__QCREF__Group_2__0__Impl rule__QCREF__Group_2__1 ) - // InternalBehaviorAnnexParser.g:14226:2: rule__QCREF__Group_2__0__Impl rule__QCREF__Group_2__1 + // InternalBehaviorAnnexParser.g:14252:1: ( rule__QCREF__Group_2__0__Impl rule__QCREF__Group_2__1 ) + // InternalBehaviorAnnexParser.g:14253:2: rule__QCREF__Group_2__0__Impl rule__QCREF__Group_2__1 { pushFollow(FollowSets000.FOLLOW_4); rule__QCREF__Group_2__0__Impl(); @@ -47020,17 +47115,17 @@ public final void rule__QCREF__Group_2__0() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_2__0__Impl" - // InternalBehaviorAnnexParser.g:14233:1: rule__QCREF__Group_2__0__Impl : ( FullStop ) ; + // InternalBehaviorAnnexParser.g:14260:1: rule__QCREF__Group_2__0__Impl : ( FullStop ) ; public final void rule__QCREF__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14237:1: ( ( FullStop ) ) - // InternalBehaviorAnnexParser.g:14238:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:14264:1: ( ( FullStop ) ) + // InternalBehaviorAnnexParser.g:14265:1: ( FullStop ) { - // InternalBehaviorAnnexParser.g:14238:1: ( FullStop ) - // InternalBehaviorAnnexParser.g:14239:2: FullStop + // InternalBehaviorAnnexParser.g:14265:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:14266:2: FullStop { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getFullStopKeyword_2_0()); @@ -47061,14 +47156,14 @@ public final void rule__QCREF__Group_2__0__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_2__1" - // InternalBehaviorAnnexParser.g:14248:1: rule__QCREF__Group_2__1 : rule__QCREF__Group_2__1__Impl ; + // InternalBehaviorAnnexParser.g:14275:1: rule__QCREF__Group_2__1 : rule__QCREF__Group_2__1__Impl ; public final void rule__QCREF__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14252:1: ( rule__QCREF__Group_2__1__Impl ) - // InternalBehaviorAnnexParser.g:14253:2: rule__QCREF__Group_2__1__Impl + // InternalBehaviorAnnexParser.g:14279:1: ( rule__QCREF__Group_2__1__Impl ) + // InternalBehaviorAnnexParser.g:14280:2: rule__QCREF__Group_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QCREF__Group_2__1__Impl(); @@ -47094,17 +47189,17 @@ public final void rule__QCREF__Group_2__1() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_2__1__Impl" - // InternalBehaviorAnnexParser.g:14259:1: rule__QCREF__Group_2__1__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14286:1: rule__QCREF__Group_2__1__Impl : ( RULE_ID ) ; public final void rule__QCREF__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14263:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14264:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14290:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14291:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14264:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14265:2: RULE_ID + // InternalBehaviorAnnexParser.g:14291:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14292:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getIDTerminalRuleCall_2_1()); @@ -47135,17 +47230,17 @@ public final void rule__QCREF__Group_2__1__Impl() throws RecognitionException { // $ANTLR start "rule__BehaviorAnnex__VariableGroupsAssignment_1_1" - // InternalBehaviorAnnexParser.g:14275:1: rule__BehaviorAnnex__VariableGroupsAssignment_1_1 : ( ruleBehaviorVariableGroup ) ; + // InternalBehaviorAnnexParser.g:14302:1: rule__BehaviorAnnex__VariableGroupsAssignment_1_1 : ( ruleBehaviorVariableGroup ) ; public final void rule__BehaviorAnnex__VariableGroupsAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14279:1: ( ( ruleBehaviorVariableGroup ) ) - // InternalBehaviorAnnexParser.g:14280:2: ( ruleBehaviorVariableGroup ) + // InternalBehaviorAnnexParser.g:14306:1: ( ( ruleBehaviorVariableGroup ) ) + // InternalBehaviorAnnexParser.g:14307:2: ( ruleBehaviorVariableGroup ) { - // InternalBehaviorAnnexParser.g:14280:2: ( ruleBehaviorVariableGroup ) - // InternalBehaviorAnnexParser.g:14281:3: ruleBehaviorVariableGroup + // InternalBehaviorAnnexParser.g:14307:2: ( ruleBehaviorVariableGroup ) + // InternalBehaviorAnnexParser.g:14308:3: ruleBehaviorVariableGroup { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getVariableGroupsBehaviorVariableGroupParserRuleCall_1_1_0()); @@ -47180,17 +47275,17 @@ public final void rule__BehaviorAnnex__VariableGroupsAssignment_1_1() throws Rec // $ANTLR start "rule__BehaviorAnnex__StateGroupsAssignment_2_1" - // InternalBehaviorAnnexParser.g:14290:1: rule__BehaviorAnnex__StateGroupsAssignment_2_1 : ( ruleBehaviorStateGroup ) ; + // InternalBehaviorAnnexParser.g:14317:1: rule__BehaviorAnnex__StateGroupsAssignment_2_1 : ( ruleBehaviorStateGroup ) ; public final void rule__BehaviorAnnex__StateGroupsAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14294:1: ( ( ruleBehaviorStateGroup ) ) - // InternalBehaviorAnnexParser.g:14295:2: ( ruleBehaviorStateGroup ) + // InternalBehaviorAnnexParser.g:14321:1: ( ( ruleBehaviorStateGroup ) ) + // InternalBehaviorAnnexParser.g:14322:2: ( ruleBehaviorStateGroup ) { - // InternalBehaviorAnnexParser.g:14295:2: ( ruleBehaviorStateGroup ) - // InternalBehaviorAnnexParser.g:14296:3: ruleBehaviorStateGroup + // InternalBehaviorAnnexParser.g:14322:2: ( ruleBehaviorStateGroup ) + // InternalBehaviorAnnexParser.g:14323:3: ruleBehaviorStateGroup { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getStateGroupsBehaviorStateGroupParserRuleCall_2_1_0()); @@ -47225,17 +47320,17 @@ public final void rule__BehaviorAnnex__StateGroupsAssignment_2_1() throws Recogn // $ANTLR start "rule__BehaviorAnnex__TransitionsAssignment_3_1" - // InternalBehaviorAnnexParser.g:14305:1: rule__BehaviorAnnex__TransitionsAssignment_3_1 : ( ruleBehaviorTransition ) ; + // InternalBehaviorAnnexParser.g:14332:1: rule__BehaviorAnnex__TransitionsAssignment_3_1 : ( ruleBehaviorTransition ) ; public final void rule__BehaviorAnnex__TransitionsAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14309:1: ( ( ruleBehaviorTransition ) ) - // InternalBehaviorAnnexParser.g:14310:2: ( ruleBehaviorTransition ) + // InternalBehaviorAnnexParser.g:14336:1: ( ( ruleBehaviorTransition ) ) + // InternalBehaviorAnnexParser.g:14337:2: ( ruleBehaviorTransition ) { - // InternalBehaviorAnnexParser.g:14310:2: ( ruleBehaviorTransition ) - // InternalBehaviorAnnexParser.g:14311:3: ruleBehaviorTransition + // InternalBehaviorAnnexParser.g:14337:2: ( ruleBehaviorTransition ) + // InternalBehaviorAnnexParser.g:14338:3: ruleBehaviorTransition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getTransitionsBehaviorTransitionParserRuleCall_3_1_0()); @@ -47270,17 +47365,17 @@ public final void rule__BehaviorAnnex__TransitionsAssignment_3_1() throws Recogn // $ANTLR start "rule__BehaviorVariableGroup__VariablesAssignment_0" - // InternalBehaviorAnnexParser.g:14320:1: rule__BehaviorVariableGroup__VariablesAssignment_0 : ( ruleBehaviorVariable ) ; + // InternalBehaviorAnnexParser.g:14347:1: rule__BehaviorVariableGroup__VariablesAssignment_0 : ( ruleBehaviorVariable ) ; public final void rule__BehaviorVariableGroup__VariablesAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14324:1: ( ( ruleBehaviorVariable ) ) - // InternalBehaviorAnnexParser.g:14325:2: ( ruleBehaviorVariable ) + // InternalBehaviorAnnexParser.g:14351:1: ( ( ruleBehaviorVariable ) ) + // InternalBehaviorAnnexParser.g:14352:2: ( ruleBehaviorVariable ) { - // InternalBehaviorAnnexParser.g:14325:2: ( ruleBehaviorVariable ) - // InternalBehaviorAnnexParser.g:14326:3: ruleBehaviorVariable + // InternalBehaviorAnnexParser.g:14352:2: ( ruleBehaviorVariable ) + // InternalBehaviorAnnexParser.g:14353:3: ruleBehaviorVariable { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getVariablesBehaviorVariableParserRuleCall_0_0()); @@ -47315,17 +47410,17 @@ public final void rule__BehaviorVariableGroup__VariablesAssignment_0() throws Re // $ANTLR start "rule__BehaviorVariableGroup__VariablesAssignment_1_1" - // InternalBehaviorAnnexParser.g:14335:1: rule__BehaviorVariableGroup__VariablesAssignment_1_1 : ( ruleBehaviorVariable ) ; + // InternalBehaviorAnnexParser.g:14362:1: rule__BehaviorVariableGroup__VariablesAssignment_1_1 : ( ruleBehaviorVariable ) ; public final void rule__BehaviorVariableGroup__VariablesAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14339:1: ( ( ruleBehaviorVariable ) ) - // InternalBehaviorAnnexParser.g:14340:2: ( ruleBehaviorVariable ) + // InternalBehaviorAnnexParser.g:14366:1: ( ( ruleBehaviorVariable ) ) + // InternalBehaviorAnnexParser.g:14367:2: ( ruleBehaviorVariable ) { - // InternalBehaviorAnnexParser.g:14340:2: ( ruleBehaviorVariable ) - // InternalBehaviorAnnexParser.g:14341:3: ruleBehaviorVariable + // InternalBehaviorAnnexParser.g:14367:2: ( ruleBehaviorVariable ) + // InternalBehaviorAnnexParser.g:14368:3: ruleBehaviorVariable { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getVariablesBehaviorVariableParserRuleCall_1_1_0()); @@ -47360,23 +47455,23 @@ public final void rule__BehaviorVariableGroup__VariablesAssignment_1_1() throws // $ANTLR start "rule__BehaviorVariableGroup__DataClassifierAssignment_3" - // InternalBehaviorAnnexParser.g:14350:1: rule__BehaviorVariableGroup__DataClassifierAssignment_3 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:14377:1: rule__BehaviorVariableGroup__DataClassifierAssignment_3 : ( ( ruleQCREF ) ) ; public final void rule__BehaviorVariableGroup__DataClassifierAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14354:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:14355:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:14381:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:14382:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:14355:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:14356:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:14382:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:14383:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getDataClassifierComponentClassifierCrossReference_3_0()); } - // InternalBehaviorAnnexParser.g:14357:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:14358:4: ruleQCREF + // InternalBehaviorAnnexParser.g:14384:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:14385:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_3_0_1()); @@ -47417,17 +47512,17 @@ public final void rule__BehaviorVariableGroup__DataClassifierAssignment_3() thro // $ANTLR start "rule__BehaviorVariableGroup__InitialValueAssignment_4_1" - // InternalBehaviorAnnexParser.g:14369:1: rule__BehaviorVariableGroup__InitialValueAssignment_4_1 : ( ruleValueConstant ) ; + // InternalBehaviorAnnexParser.g:14396:1: rule__BehaviorVariableGroup__InitialValueAssignment_4_1 : ( ruleValueConstant ) ; public final void rule__BehaviorVariableGroup__InitialValueAssignment_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14373:1: ( ( ruleValueConstant ) ) - // InternalBehaviorAnnexParser.g:14374:2: ( ruleValueConstant ) + // InternalBehaviorAnnexParser.g:14400:1: ( ( ruleValueConstant ) ) + // InternalBehaviorAnnexParser.g:14401:2: ( ruleValueConstant ) { - // InternalBehaviorAnnexParser.g:14374:2: ( ruleValueConstant ) - // InternalBehaviorAnnexParser.g:14375:3: ruleValueConstant + // InternalBehaviorAnnexParser.g:14401:2: ( ruleValueConstant ) + // InternalBehaviorAnnexParser.g:14402:3: ruleValueConstant { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getInitialValueValueConstantParserRuleCall_4_1_0()); @@ -47462,17 +47557,17 @@ public final void rule__BehaviorVariableGroup__InitialValueAssignment_4_1() thro // $ANTLR start "rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1" - // InternalBehaviorAnnexParser.g:14384:1: rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 : ( ruleBehaviorPropertyAssociation ) ; + // InternalBehaviorAnnexParser.g:14411:1: rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 : ( ruleBehaviorPropertyAssociation ) ; public final void rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14388:1: ( ( ruleBehaviorPropertyAssociation ) ) - // InternalBehaviorAnnexParser.g:14389:2: ( ruleBehaviorPropertyAssociation ) + // InternalBehaviorAnnexParser.g:14415:1: ( ( ruleBehaviorPropertyAssociation ) ) + // InternalBehaviorAnnexParser.g:14416:2: ( ruleBehaviorPropertyAssociation ) { - // InternalBehaviorAnnexParser.g:14389:2: ( ruleBehaviorPropertyAssociation ) - // InternalBehaviorAnnexParser.g:14390:3: ruleBehaviorPropertyAssociation + // InternalBehaviorAnnexParser.g:14416:2: ( ruleBehaviorPropertyAssociation ) + // InternalBehaviorAnnexParser.g:14417:3: ruleBehaviorPropertyAssociation { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getPropertyAssociationsBehaviorPropertyAssociationParserRuleCall_5_1_0()); @@ -47507,17 +47602,17 @@ public final void rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_ // $ANTLR start "rule__BehaviorVariable__NameAssignment_0" - // InternalBehaviorAnnexParser.g:14399:1: rule__BehaviorVariable__NameAssignment_0 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14426:1: rule__BehaviorVariable__NameAssignment_0 : ( RULE_ID ) ; public final void rule__BehaviorVariable__NameAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14403:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14404:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14430:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14431:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14404:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14405:3: RULE_ID + // InternalBehaviorAnnexParser.g:14431:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14432:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableAccess().getNameIDTerminalRuleCall_0_0()); @@ -47548,17 +47643,17 @@ public final void rule__BehaviorVariable__NameAssignment_0() throws RecognitionE // $ANTLR start "rule__BehaviorVariable__ArrayDimensionsAssignment_1" - // InternalBehaviorAnnexParser.g:14414:1: rule__BehaviorVariable__ArrayDimensionsAssignment_1 : ( ruleArrayDimension ) ; + // InternalBehaviorAnnexParser.g:14441:1: rule__BehaviorVariable__ArrayDimensionsAssignment_1 : ( ruleArrayDimension ) ; public final void rule__BehaviorVariable__ArrayDimensionsAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14418:1: ( ( ruleArrayDimension ) ) - // InternalBehaviorAnnexParser.g:14419:2: ( ruleArrayDimension ) + // InternalBehaviorAnnexParser.g:14445:1: ( ( ruleArrayDimension ) ) + // InternalBehaviorAnnexParser.g:14446:2: ( ruleArrayDimension ) { - // InternalBehaviorAnnexParser.g:14419:2: ( ruleArrayDimension ) - // InternalBehaviorAnnexParser.g:14420:3: ruleArrayDimension + // InternalBehaviorAnnexParser.g:14446:2: ( ruleArrayDimension ) + // InternalBehaviorAnnexParser.g:14447:3: ruleArrayDimension { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableAccess().getArrayDimensionsArrayDimensionParserRuleCall_1_0()); @@ -47593,17 +47688,17 @@ public final void rule__BehaviorVariable__ArrayDimensionsAssignment_1() throws R // $ANTLR start "rule__ArrayDimension__SizeAssignment_1" - // InternalBehaviorAnnexParser.g:14429:1: rule__ArrayDimension__SizeAssignment_1 : ( ruleIntegerValue ) ; + // InternalBehaviorAnnexParser.g:14456:1: rule__ArrayDimension__SizeAssignment_1 : ( ruleIntegerValue ) ; public final void rule__ArrayDimension__SizeAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14433:1: ( ( ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:14434:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:14460:1: ( ( ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:14461:2: ( ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:14434:2: ( ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:14435:3: ruleIntegerValue + // InternalBehaviorAnnexParser.g:14461:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:14462:3: ruleIntegerValue { if ( state.backtracking==0 ) { before(grammarAccess.getArrayDimensionAccess().getSizeIntegerValueParserRuleCall_1_0()); @@ -47638,23 +47733,23 @@ public final void rule__ArrayDimension__SizeAssignment_1() throws RecognitionExc // $ANTLR start "rule__BehaviorPropertyAssociation__PropertyAssignment_0" - // InternalBehaviorAnnexParser.g:14444:1: rule__BehaviorPropertyAssociation__PropertyAssignment_0 : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:14471:1: rule__BehaviorPropertyAssociation__PropertyAssignment_0 : ( ( ruleQPREF ) ) ; public final void rule__BehaviorPropertyAssociation__PropertyAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14448:1: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:14449:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:14475:1: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:14476:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:14449:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:14450:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:14476:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:14477:3: ( ruleQPREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorPropertyAssociationAccess().getPropertyPropertyCrossReference_0_0()); } - // InternalBehaviorAnnexParser.g:14451:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:14452:4: ruleQPREF + // InternalBehaviorAnnexParser.g:14478:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:14479:4: ruleQPREF { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorPropertyAssociationAccess().getPropertyPropertyQPREFParserRuleCall_0_0_1()); @@ -47695,17 +47790,17 @@ public final void rule__BehaviorPropertyAssociation__PropertyAssignment_0() thro // $ANTLR start "rule__BehaviorPropertyAssociation__OwnedValueAssignment_2" - // InternalBehaviorAnnexParser.g:14463:1: rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:14490:1: rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 : ( rulePropertyExpression ) ; public final void rule__BehaviorPropertyAssociation__OwnedValueAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14467:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:14468:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:14494:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:14495:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:14468:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:14469:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:14495:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:14496:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorPropertyAssociationAccess().getOwnedValuePropertyExpressionParserRuleCall_2_0()); @@ -47740,17 +47835,17 @@ public final void rule__BehaviorPropertyAssociation__OwnedValueAssignment_2() th // $ANTLR start "rule__BehaviorStateGroup__StatesAssignment_0" - // InternalBehaviorAnnexParser.g:14478:1: rule__BehaviorStateGroup__StatesAssignment_0 : ( ruleBehaviorState ) ; + // InternalBehaviorAnnexParser.g:14505:1: rule__BehaviorStateGroup__StatesAssignment_0 : ( ruleBehaviorState ) ; public final void rule__BehaviorStateGroup__StatesAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14482:1: ( ( ruleBehaviorState ) ) - // InternalBehaviorAnnexParser.g:14483:2: ( ruleBehaviorState ) + // InternalBehaviorAnnexParser.g:14509:1: ( ( ruleBehaviorState ) ) + // InternalBehaviorAnnexParser.g:14510:2: ( ruleBehaviorState ) { - // InternalBehaviorAnnexParser.g:14483:2: ( ruleBehaviorState ) - // InternalBehaviorAnnexParser.g:14484:3: ruleBehaviorState + // InternalBehaviorAnnexParser.g:14510:2: ( ruleBehaviorState ) + // InternalBehaviorAnnexParser.g:14511:3: ruleBehaviorState { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getStatesBehaviorStateParserRuleCall_0_0()); @@ -47785,17 +47880,17 @@ public final void rule__BehaviorStateGroup__StatesAssignment_0() throws Recognit // $ANTLR start "rule__BehaviorStateGroup__StatesAssignment_1_1" - // InternalBehaviorAnnexParser.g:14493:1: rule__BehaviorStateGroup__StatesAssignment_1_1 : ( ruleBehaviorState ) ; + // InternalBehaviorAnnexParser.g:14520:1: rule__BehaviorStateGroup__StatesAssignment_1_1 : ( ruleBehaviorState ) ; public final void rule__BehaviorStateGroup__StatesAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14497:1: ( ( ruleBehaviorState ) ) - // InternalBehaviorAnnexParser.g:14498:2: ( ruleBehaviorState ) + // InternalBehaviorAnnexParser.g:14524:1: ( ( ruleBehaviorState ) ) + // InternalBehaviorAnnexParser.g:14525:2: ( ruleBehaviorState ) { - // InternalBehaviorAnnexParser.g:14498:2: ( ruleBehaviorState ) - // InternalBehaviorAnnexParser.g:14499:3: ruleBehaviorState + // InternalBehaviorAnnexParser.g:14525:2: ( ruleBehaviorState ) + // InternalBehaviorAnnexParser.g:14526:3: ruleBehaviorState { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getStatesBehaviorStateParserRuleCall_1_1_0()); @@ -47830,23 +47925,23 @@ public final void rule__BehaviorStateGroup__StatesAssignment_1_1() throws Recogn // $ANTLR start "rule__BehaviorStateGroup__InitialAssignment_3" - // InternalBehaviorAnnexParser.g:14508:1: rule__BehaviorStateGroup__InitialAssignment_3 : ( ( Initial ) ) ; + // InternalBehaviorAnnexParser.g:14535:1: rule__BehaviorStateGroup__InitialAssignment_3 : ( ( Initial ) ) ; public final void rule__BehaviorStateGroup__InitialAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14512:1: ( ( ( Initial ) ) ) - // InternalBehaviorAnnexParser.g:14513:2: ( ( Initial ) ) + // InternalBehaviorAnnexParser.g:14539:1: ( ( ( Initial ) ) ) + // InternalBehaviorAnnexParser.g:14540:2: ( ( Initial ) ) { - // InternalBehaviorAnnexParser.g:14513:2: ( ( Initial ) ) - // InternalBehaviorAnnexParser.g:14514:3: ( Initial ) + // InternalBehaviorAnnexParser.g:14540:2: ( ( Initial ) ) + // InternalBehaviorAnnexParser.g:14541:3: ( Initial ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getInitialInitialKeyword_3_0()); } - // InternalBehaviorAnnexParser.g:14515:3: ( Initial ) - // InternalBehaviorAnnexParser.g:14516:4: Initial + // InternalBehaviorAnnexParser.g:14542:3: ( Initial ) + // InternalBehaviorAnnexParser.g:14543:4: Initial { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getInitialInitialKeyword_3_0()); @@ -47883,23 +47978,23 @@ public final void rule__BehaviorStateGroup__InitialAssignment_3() throws Recogni // $ANTLR start "rule__BehaviorStateGroup__CompleteAssignment_4" - // InternalBehaviorAnnexParser.g:14527:1: rule__BehaviorStateGroup__CompleteAssignment_4 : ( ( Complete ) ) ; + // InternalBehaviorAnnexParser.g:14554:1: rule__BehaviorStateGroup__CompleteAssignment_4 : ( ( Complete ) ) ; public final void rule__BehaviorStateGroup__CompleteAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14531:1: ( ( ( Complete ) ) ) - // InternalBehaviorAnnexParser.g:14532:2: ( ( Complete ) ) + // InternalBehaviorAnnexParser.g:14558:1: ( ( ( Complete ) ) ) + // InternalBehaviorAnnexParser.g:14559:2: ( ( Complete ) ) { - // InternalBehaviorAnnexParser.g:14532:2: ( ( Complete ) ) - // InternalBehaviorAnnexParser.g:14533:3: ( Complete ) + // InternalBehaviorAnnexParser.g:14559:2: ( ( Complete ) ) + // InternalBehaviorAnnexParser.g:14560:3: ( Complete ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getCompleteCompleteKeyword_4_0()); } - // InternalBehaviorAnnexParser.g:14534:3: ( Complete ) - // InternalBehaviorAnnexParser.g:14535:4: Complete + // InternalBehaviorAnnexParser.g:14561:3: ( Complete ) + // InternalBehaviorAnnexParser.g:14562:4: Complete { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getCompleteCompleteKeyword_4_0()); @@ -47936,23 +48031,23 @@ public final void rule__BehaviorStateGroup__CompleteAssignment_4() throws Recogn // $ANTLR start "rule__BehaviorStateGroup__FinalAssignment_5" - // InternalBehaviorAnnexParser.g:14546:1: rule__BehaviorStateGroup__FinalAssignment_5 : ( ( Final ) ) ; + // InternalBehaviorAnnexParser.g:14573:1: rule__BehaviorStateGroup__FinalAssignment_5 : ( ( Final ) ) ; public final void rule__BehaviorStateGroup__FinalAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14550:1: ( ( ( Final ) ) ) - // InternalBehaviorAnnexParser.g:14551:2: ( ( Final ) ) + // InternalBehaviorAnnexParser.g:14577:1: ( ( ( Final ) ) ) + // InternalBehaviorAnnexParser.g:14578:2: ( ( Final ) ) { - // InternalBehaviorAnnexParser.g:14551:2: ( ( Final ) ) - // InternalBehaviorAnnexParser.g:14552:3: ( Final ) + // InternalBehaviorAnnexParser.g:14578:2: ( ( Final ) ) + // InternalBehaviorAnnexParser.g:14579:3: ( Final ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getFinalFinalKeyword_5_0()); } - // InternalBehaviorAnnexParser.g:14553:3: ( Final ) - // InternalBehaviorAnnexParser.g:14554:4: Final + // InternalBehaviorAnnexParser.g:14580:3: ( Final ) + // InternalBehaviorAnnexParser.g:14581:4: Final { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getFinalFinalKeyword_5_0()); @@ -47989,17 +48084,17 @@ public final void rule__BehaviorStateGroup__FinalAssignment_5() throws Recogniti // $ANTLR start "rule__BehaviorState__NameAssignment" - // InternalBehaviorAnnexParser.g:14565:1: rule__BehaviorState__NameAssignment : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14592:1: rule__BehaviorState__NameAssignment : ( RULE_ID ) ; public final void rule__BehaviorState__NameAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14569:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14570:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14596:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14597:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14570:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14571:3: RULE_ID + // InternalBehaviorAnnexParser.g:14597:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14598:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateAccess().getNameIDTerminalRuleCall_0()); @@ -48030,17 +48125,17 @@ public final void rule__BehaviorState__NameAssignment() throws RecognitionExcept // $ANTLR start "rule__BehaviorTransition__NameAssignment_0_0" - // InternalBehaviorAnnexParser.g:14580:1: rule__BehaviorTransition__NameAssignment_0_0 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14607:1: rule__BehaviorTransition__NameAssignment_0_0 : ( RULE_ID ) ; public final void rule__BehaviorTransition__NameAssignment_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14584:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14585:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14611:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14612:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14585:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14586:3: RULE_ID + // InternalBehaviorAnnexParser.g:14612:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14613:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getNameIDTerminalRuleCall_0_0_0()); @@ -48071,17 +48166,17 @@ public final void rule__BehaviorTransition__NameAssignment_0_0() throws Recognit // $ANTLR start "rule__BehaviorTransition__PriorityAssignment_0_1_1" - // InternalBehaviorAnnexParser.g:14595:1: rule__BehaviorTransition__PriorityAssignment_0_1_1 : ( RULE_INTEGER_LIT ) ; + // InternalBehaviorAnnexParser.g:14622:1: rule__BehaviorTransition__PriorityAssignment_0_1_1 : ( RULE_INTEGER_LIT ) ; public final void rule__BehaviorTransition__PriorityAssignment_0_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14599:1: ( ( RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:14600:2: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:14626:1: ( ( RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:14627:2: ( RULE_INTEGER_LIT ) { - // InternalBehaviorAnnexParser.g:14600:2: ( RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:14601:3: RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:14627:2: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:14628:3: RULE_INTEGER_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getPriorityINTEGER_LITTerminalRuleCall_0_1_1_0()); @@ -48112,23 +48207,23 @@ public final void rule__BehaviorTransition__PriorityAssignment_0_1_1() throws Re // $ANTLR start "rule__BehaviorTransition__SourceStatesAssignment_1" - // InternalBehaviorAnnexParser.g:14610:1: rule__BehaviorTransition__SourceStatesAssignment_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:14637:1: rule__BehaviorTransition__SourceStatesAssignment_1 : ( ( RULE_ID ) ) ; public final void rule__BehaviorTransition__SourceStatesAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14614:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:14615:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14641:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:14642:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:14615:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14616:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14642:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14643:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSourceStatesBehaviorStateCrossReference_1_0()); } - // InternalBehaviorAnnexParser.g:14617:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14618:4: RULE_ID + // InternalBehaviorAnnexParser.g:14644:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14645:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSourceStatesBehaviorStateIDTerminalRuleCall_1_0_1()); @@ -48165,23 +48260,23 @@ public final void rule__BehaviorTransition__SourceStatesAssignment_1() throws Re // $ANTLR start "rule__BehaviorTransition__SourceStatesAssignment_2_1" - // InternalBehaviorAnnexParser.g:14629:1: rule__BehaviorTransition__SourceStatesAssignment_2_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:14656:1: rule__BehaviorTransition__SourceStatesAssignment_2_1 : ( ( RULE_ID ) ) ; public final void rule__BehaviorTransition__SourceStatesAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14633:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:14634:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14660:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:14661:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:14634:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14635:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14661:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14662:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSourceStatesBehaviorStateCrossReference_2_1_0()); } - // InternalBehaviorAnnexParser.g:14636:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14637:4: RULE_ID + // InternalBehaviorAnnexParser.g:14663:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14664:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSourceStatesBehaviorStateIDTerminalRuleCall_2_1_0_1()); @@ -48218,17 +48313,17 @@ public final void rule__BehaviorTransition__SourceStatesAssignment_2_1() throws // $ANTLR start "rule__BehaviorTransition__ConditionAssignment_4" - // InternalBehaviorAnnexParser.g:14648:1: rule__BehaviorTransition__ConditionAssignment_4 : ( ruleBehaviorCondition ) ; + // InternalBehaviorAnnexParser.g:14675:1: rule__BehaviorTransition__ConditionAssignment_4 : ( ruleBehaviorCondition ) ; public final void rule__BehaviorTransition__ConditionAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14652:1: ( ( ruleBehaviorCondition ) ) - // InternalBehaviorAnnexParser.g:14653:2: ( ruleBehaviorCondition ) + // InternalBehaviorAnnexParser.g:14679:1: ( ( ruleBehaviorCondition ) ) + // InternalBehaviorAnnexParser.g:14680:2: ( ruleBehaviorCondition ) { - // InternalBehaviorAnnexParser.g:14653:2: ( ruleBehaviorCondition ) - // InternalBehaviorAnnexParser.g:14654:3: ruleBehaviorCondition + // InternalBehaviorAnnexParser.g:14680:2: ( ruleBehaviorCondition ) + // InternalBehaviorAnnexParser.g:14681:3: ruleBehaviorCondition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getConditionBehaviorConditionParserRuleCall_4_0()); @@ -48263,23 +48358,23 @@ public final void rule__BehaviorTransition__ConditionAssignment_4() throws Recog // $ANTLR start "rule__BehaviorTransition__DestinationStateAssignment_6" - // InternalBehaviorAnnexParser.g:14663:1: rule__BehaviorTransition__DestinationStateAssignment_6 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:14690:1: rule__BehaviorTransition__DestinationStateAssignment_6 : ( ( RULE_ID ) ) ; public final void rule__BehaviorTransition__DestinationStateAssignment_6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14667:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:14668:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14694:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:14695:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:14668:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14669:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14695:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14696:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getDestinationStateBehaviorStateCrossReference_6_0()); } - // InternalBehaviorAnnexParser.g:14670:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14671:4: RULE_ID + // InternalBehaviorAnnexParser.g:14697:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14698:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getDestinationStateBehaviorStateIDTerminalRuleCall_6_0_1()); @@ -48316,17 +48411,17 @@ public final void rule__BehaviorTransition__DestinationStateAssignment_6() throw // $ANTLR start "rule__BehaviorTransition__ActionBlockAssignment_7" - // InternalBehaviorAnnexParser.g:14682:1: rule__BehaviorTransition__ActionBlockAssignment_7 : ( ruleBehaviorActionBlock ) ; + // InternalBehaviorAnnexParser.g:14709:1: rule__BehaviorTransition__ActionBlockAssignment_7 : ( ruleBehaviorActionBlock ) ; public final void rule__BehaviorTransition__ActionBlockAssignment_7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14686:1: ( ( ruleBehaviorActionBlock ) ) - // InternalBehaviorAnnexParser.g:14687:2: ( ruleBehaviorActionBlock ) + // InternalBehaviorAnnexParser.g:14713:1: ( ( ruleBehaviorActionBlock ) ) + // InternalBehaviorAnnexParser.g:14714:2: ( ruleBehaviorActionBlock ) { - // InternalBehaviorAnnexParser.g:14687:2: ( ruleBehaviorActionBlock ) - // InternalBehaviorAnnexParser.g:14688:3: ruleBehaviorActionBlock + // InternalBehaviorAnnexParser.g:14714:2: ( ruleBehaviorActionBlock ) + // InternalBehaviorAnnexParser.g:14715:3: ruleBehaviorActionBlock { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getActionBlockBehaviorActionBlockParserRuleCall_7_0()); @@ -48361,17 +48456,17 @@ public final void rule__BehaviorTransition__ActionBlockAssignment_7() throws Rec // $ANTLR start "rule__BehaviorCondition__DispatchAssignment_0_1_0" - // InternalBehaviorAnnexParser.g:14697:1: rule__BehaviorCondition__DispatchAssignment_0_1_0 : ( ruleDispatchCondition ) ; + // InternalBehaviorAnnexParser.g:14724:1: rule__BehaviorCondition__DispatchAssignment_0_1_0 : ( ruleDispatchCondition ) ; public final void rule__BehaviorCondition__DispatchAssignment_0_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14701:1: ( ( ruleDispatchCondition ) ) - // InternalBehaviorAnnexParser.g:14702:2: ( ruleDispatchCondition ) + // InternalBehaviorAnnexParser.g:14728:1: ( ( ruleDispatchCondition ) ) + // InternalBehaviorAnnexParser.g:14729:2: ( ruleDispatchCondition ) { - // InternalBehaviorAnnexParser.g:14702:2: ( ruleDispatchCondition ) - // InternalBehaviorAnnexParser.g:14703:3: ruleDispatchCondition + // InternalBehaviorAnnexParser.g:14729:2: ( ruleDispatchCondition ) + // InternalBehaviorAnnexParser.g:14730:3: ruleDispatchCondition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getDispatchDispatchConditionParserRuleCall_0_1_0_0()); @@ -48406,17 +48501,17 @@ public final void rule__BehaviorCondition__DispatchAssignment_0_1_0() throws Rec // $ANTLR start "rule__BehaviorCondition__InternalAssignment_0_1_1" - // InternalBehaviorAnnexParser.g:14712:1: rule__BehaviorCondition__InternalAssignment_0_1_1 : ( ruleInternalCondition ) ; + // InternalBehaviorAnnexParser.g:14739:1: rule__BehaviorCondition__InternalAssignment_0_1_1 : ( ruleInternalCondition ) ; public final void rule__BehaviorCondition__InternalAssignment_0_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14716:1: ( ( ruleInternalCondition ) ) - // InternalBehaviorAnnexParser.g:14717:2: ( ruleInternalCondition ) + // InternalBehaviorAnnexParser.g:14743:1: ( ( ruleInternalCondition ) ) + // InternalBehaviorAnnexParser.g:14744:2: ( ruleInternalCondition ) { - // InternalBehaviorAnnexParser.g:14717:2: ( ruleInternalCondition ) - // InternalBehaviorAnnexParser.g:14718:3: ruleInternalCondition + // InternalBehaviorAnnexParser.g:14744:2: ( ruleInternalCondition ) + // InternalBehaviorAnnexParser.g:14745:3: ruleInternalCondition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getInternalInternalConditionParserRuleCall_0_1_1_0()); @@ -48451,17 +48546,17 @@ public final void rule__BehaviorCondition__InternalAssignment_0_1_1() throws Rec // $ANTLR start "rule__BehaviorCondition__ModeSwitchAssignment_0_1_2" - // InternalBehaviorAnnexParser.g:14727:1: rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 : ( ruleModeSwitchCondition ) ; + // InternalBehaviorAnnexParser.g:14754:1: rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 : ( ruleModeSwitchCondition ) ; public final void rule__BehaviorCondition__ModeSwitchAssignment_0_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14731:1: ( ( ruleModeSwitchCondition ) ) - // InternalBehaviorAnnexParser.g:14732:2: ( ruleModeSwitchCondition ) + // InternalBehaviorAnnexParser.g:14758:1: ( ( ruleModeSwitchCondition ) ) + // InternalBehaviorAnnexParser.g:14759:2: ( ruleModeSwitchCondition ) { - // InternalBehaviorAnnexParser.g:14732:2: ( ruleModeSwitchCondition ) - // InternalBehaviorAnnexParser.g:14733:3: ruleModeSwitchCondition + // InternalBehaviorAnnexParser.g:14759:2: ( ruleModeSwitchCondition ) + // InternalBehaviorAnnexParser.g:14760:3: ruleModeSwitchCondition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getModeSwitchModeSwitchConditionParserRuleCall_0_1_2_0()); @@ -48496,17 +48591,17 @@ public final void rule__BehaviorCondition__ModeSwitchAssignment_0_1_2() throws R // $ANTLR start "rule__BehaviorCondition__ExecuteAssignment_1" - // InternalBehaviorAnnexParser.g:14742:1: rule__BehaviorCondition__ExecuteAssignment_1 : ( ruleExecuteCondition ) ; + // InternalBehaviorAnnexParser.g:14769:1: rule__BehaviorCondition__ExecuteAssignment_1 : ( ruleExecuteCondition ) ; public final void rule__BehaviorCondition__ExecuteAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14746:1: ( ( ruleExecuteCondition ) ) - // InternalBehaviorAnnexParser.g:14747:2: ( ruleExecuteCondition ) + // InternalBehaviorAnnexParser.g:14773:1: ( ( ruleExecuteCondition ) ) + // InternalBehaviorAnnexParser.g:14774:2: ( ruleExecuteCondition ) { - // InternalBehaviorAnnexParser.g:14747:2: ( ruleExecuteCondition ) - // InternalBehaviorAnnexParser.g:14748:3: ruleExecuteCondition + // InternalBehaviorAnnexParser.g:14774:2: ( ruleExecuteCondition ) + // InternalBehaviorAnnexParser.g:14775:3: ruleExecuteCondition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getExecuteExecuteConditionParserRuleCall_1_0()); @@ -48541,17 +48636,17 @@ public final void rule__BehaviorCondition__ExecuteAssignment_1() throws Recognit // $ANTLR start "rule__ExecuteCondition__ValueAssignment_0" - // InternalBehaviorAnnexParser.g:14757:1: rule__ExecuteCondition__ValueAssignment_0 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:14784:1: rule__ExecuteCondition__ValueAssignment_0 : ( ruleValueExpression ) ; public final void rule__ExecuteCondition__ValueAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14761:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:14762:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:14788:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:14789:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:14762:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:14763:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:14789:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:14790:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getValueValueExpressionParserRuleCall_0_0()); @@ -48586,23 +48681,23 @@ public final void rule__ExecuteCondition__ValueAssignment_0() throws Recognition // $ANTLR start "rule__ExecuteCondition__TimeoutAssignment_1" - // InternalBehaviorAnnexParser.g:14772:1: rule__ExecuteCondition__TimeoutAssignment_1 : ( ( Timeout ) ) ; + // InternalBehaviorAnnexParser.g:14799:1: rule__ExecuteCondition__TimeoutAssignment_1 : ( ( Timeout ) ) ; public final void rule__ExecuteCondition__TimeoutAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14776:1: ( ( ( Timeout ) ) ) - // InternalBehaviorAnnexParser.g:14777:2: ( ( Timeout ) ) + // InternalBehaviorAnnexParser.g:14803:1: ( ( ( Timeout ) ) ) + // InternalBehaviorAnnexParser.g:14804:2: ( ( Timeout ) ) { - // InternalBehaviorAnnexParser.g:14777:2: ( ( Timeout ) ) - // InternalBehaviorAnnexParser.g:14778:3: ( Timeout ) + // InternalBehaviorAnnexParser.g:14804:2: ( ( Timeout ) ) + // InternalBehaviorAnnexParser.g:14805:3: ( Timeout ) { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getTimeoutTimeoutKeyword_1_0()); } - // InternalBehaviorAnnexParser.g:14779:3: ( Timeout ) - // InternalBehaviorAnnexParser.g:14780:4: Timeout + // InternalBehaviorAnnexParser.g:14806:3: ( Timeout ) + // InternalBehaviorAnnexParser.g:14807:4: Timeout { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getTimeoutTimeoutKeyword_1_0()); @@ -48639,23 +48734,23 @@ public final void rule__ExecuteCondition__TimeoutAssignment_1() throws Recogniti // $ANTLR start "rule__ExecuteCondition__OtherwiseAssignment_2" - // InternalBehaviorAnnexParser.g:14791:1: rule__ExecuteCondition__OtherwiseAssignment_2 : ( ( Otherwise ) ) ; + // InternalBehaviorAnnexParser.g:14818:1: rule__ExecuteCondition__OtherwiseAssignment_2 : ( ( Otherwise ) ) ; public final void rule__ExecuteCondition__OtherwiseAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14795:1: ( ( ( Otherwise ) ) ) - // InternalBehaviorAnnexParser.g:14796:2: ( ( Otherwise ) ) + // InternalBehaviorAnnexParser.g:14822:1: ( ( ( Otherwise ) ) ) + // InternalBehaviorAnnexParser.g:14823:2: ( ( Otherwise ) ) { - // InternalBehaviorAnnexParser.g:14796:2: ( ( Otherwise ) ) - // InternalBehaviorAnnexParser.g:14797:3: ( Otherwise ) + // InternalBehaviorAnnexParser.g:14823:2: ( ( Otherwise ) ) + // InternalBehaviorAnnexParser.g:14824:3: ( Otherwise ) { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getOtherwiseOtherwiseKeyword_2_0()); } - // InternalBehaviorAnnexParser.g:14798:3: ( Otherwise ) - // InternalBehaviorAnnexParser.g:14799:4: Otherwise + // InternalBehaviorAnnexParser.g:14825:3: ( Otherwise ) + // InternalBehaviorAnnexParser.g:14826:4: Otherwise { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getOtherwiseOtherwiseKeyword_2_0()); @@ -48692,17 +48787,17 @@ public final void rule__ExecuteCondition__OtherwiseAssignment_2() throws Recogni // $ANTLR start "rule__DispatchCondition__TriggerAssignment_2" - // InternalBehaviorAnnexParser.g:14810:1: rule__DispatchCondition__TriggerAssignment_2 : ( ruleDispatchTriggerCondition ) ; + // InternalBehaviorAnnexParser.g:14837:1: rule__DispatchCondition__TriggerAssignment_2 : ( ruleDispatchTriggerCondition ) ; public final void rule__DispatchCondition__TriggerAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14814:1: ( ( ruleDispatchTriggerCondition ) ) - // InternalBehaviorAnnexParser.g:14815:2: ( ruleDispatchTriggerCondition ) + // InternalBehaviorAnnexParser.g:14841:1: ( ( ruleDispatchTriggerCondition ) ) + // InternalBehaviorAnnexParser.g:14842:2: ( ruleDispatchTriggerCondition ) { - // InternalBehaviorAnnexParser.g:14815:2: ( ruleDispatchTriggerCondition ) - // InternalBehaviorAnnexParser.g:14816:3: ruleDispatchTriggerCondition + // InternalBehaviorAnnexParser.g:14842:2: ( ruleDispatchTriggerCondition ) + // InternalBehaviorAnnexParser.g:14843:3: ruleDispatchTriggerCondition { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getTriggerDispatchTriggerConditionParserRuleCall_2_0()); @@ -48737,17 +48832,17 @@ public final void rule__DispatchCondition__TriggerAssignment_2() throws Recognit // $ANTLR start "rule__DispatchCondition__FrozenPortsAssignment_3_2" - // InternalBehaviorAnnexParser.g:14825:1: rule__DispatchCondition__FrozenPortsAssignment_3_2 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:14852:1: rule__DispatchCondition__FrozenPortsAssignment_3_2 : ( ruleReference ) ; public final void rule__DispatchCondition__FrozenPortsAssignment_3_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14829:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14830:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14856:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:14857:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14830:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14831:3: ruleReference + // InternalBehaviorAnnexParser.g:14857:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14858:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getFrozenPortsReferenceParserRuleCall_3_2_0()); @@ -48782,17 +48877,17 @@ public final void rule__DispatchCondition__FrozenPortsAssignment_3_2() throws Re // $ANTLR start "rule__DispatchCondition__FrozenPortsAssignment_3_3_1" - // InternalBehaviorAnnexParser.g:14840:1: rule__DispatchCondition__FrozenPortsAssignment_3_3_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:14867:1: rule__DispatchCondition__FrozenPortsAssignment_3_3_1 : ( ruleReference ) ; public final void rule__DispatchCondition__FrozenPortsAssignment_3_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14844:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14845:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14871:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:14872:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14845:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14846:3: ruleReference + // InternalBehaviorAnnexParser.g:14872:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14873:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getFrozenPortsReferenceParserRuleCall_3_3_1_0()); @@ -48827,17 +48922,17 @@ public final void rule__DispatchCondition__FrozenPortsAssignment_3_3_1() throws // $ANTLR start "rule__DispatchTriggerCondition__ExpressionAssignment_0" - // InternalBehaviorAnnexParser.g:14855:1: rule__DispatchTriggerCondition__ExpressionAssignment_0 : ( ruleDispatchTriggerLogicalExpression ) ; + // InternalBehaviorAnnexParser.g:14882:1: rule__DispatchTriggerCondition__ExpressionAssignment_0 : ( ruleDispatchTriggerLogicalExpression ) ; public final void rule__DispatchTriggerCondition__ExpressionAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14859:1: ( ( ruleDispatchTriggerLogicalExpression ) ) - // InternalBehaviorAnnexParser.g:14860:2: ( ruleDispatchTriggerLogicalExpression ) + // InternalBehaviorAnnexParser.g:14886:1: ( ( ruleDispatchTriggerLogicalExpression ) ) + // InternalBehaviorAnnexParser.g:14887:2: ( ruleDispatchTriggerLogicalExpression ) { - // InternalBehaviorAnnexParser.g:14860:2: ( ruleDispatchTriggerLogicalExpression ) - // InternalBehaviorAnnexParser.g:14861:3: ruleDispatchTriggerLogicalExpression + // InternalBehaviorAnnexParser.g:14887:2: ( ruleDispatchTriggerLogicalExpression ) + // InternalBehaviorAnnexParser.g:14888:3: ruleDispatchTriggerLogicalExpression { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getExpressionDispatchTriggerLogicalExpressionParserRuleCall_0_0()); @@ -48872,23 +48967,23 @@ public final void rule__DispatchTriggerCondition__ExpressionAssignment_0() throw // $ANTLR start "rule__DispatchTriggerCondition__TimeoutAssignment_1_0" - // InternalBehaviorAnnexParser.g:14870:1: rule__DispatchTriggerCondition__TimeoutAssignment_1_0 : ( ( Timeout ) ) ; + // InternalBehaviorAnnexParser.g:14897:1: rule__DispatchTriggerCondition__TimeoutAssignment_1_0 : ( ( Timeout ) ) ; public final void rule__DispatchTriggerCondition__TimeoutAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14874:1: ( ( ( Timeout ) ) ) - // InternalBehaviorAnnexParser.g:14875:2: ( ( Timeout ) ) + // InternalBehaviorAnnexParser.g:14901:1: ( ( ( Timeout ) ) ) + // InternalBehaviorAnnexParser.g:14902:2: ( ( Timeout ) ) { - // InternalBehaviorAnnexParser.g:14875:2: ( ( Timeout ) ) - // InternalBehaviorAnnexParser.g:14876:3: ( Timeout ) + // InternalBehaviorAnnexParser.g:14902:2: ( ( Timeout ) ) + // InternalBehaviorAnnexParser.g:14903:3: ( Timeout ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getTimeoutTimeoutKeyword_1_0_0()); } - // InternalBehaviorAnnexParser.g:14877:3: ( Timeout ) - // InternalBehaviorAnnexParser.g:14878:4: Timeout + // InternalBehaviorAnnexParser.g:14904:3: ( Timeout ) + // InternalBehaviorAnnexParser.g:14905:4: Timeout { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getTimeoutTimeoutKeyword_1_0_0()); @@ -48925,17 +49020,17 @@ public final void rule__DispatchTriggerCondition__TimeoutAssignment_1_0() throws // $ANTLR start "rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1" - // InternalBehaviorAnnexParser.g:14889:1: rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:14916:1: rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 : ( ruleReference ) ; public final void rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14893:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14894:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14920:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:14921:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14894:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14895:3: ruleReference + // InternalBehaviorAnnexParser.g:14921:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14922:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getResetPortsReferenceParserRuleCall_1_1_1_0()); @@ -48970,17 +49065,17 @@ public final void rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1() t // $ANTLR start "rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1" - // InternalBehaviorAnnexParser.g:14904:1: rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:14931:1: rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 : ( ruleReference ) ; public final void rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14908:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14909:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14935:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:14936:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14909:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14910:3: ruleReference + // InternalBehaviorAnnexParser.g:14936:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14937:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getResetPortsReferenceParserRuleCall_1_1_2_1_0()); @@ -49015,17 +49110,17 @@ public final void rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1() // $ANTLR start "rule__DispatchTriggerCondition__TimeAssignment_1_2" - // InternalBehaviorAnnexParser.g:14919:1: rule__DispatchTriggerCondition__TimeAssignment_1_2 : ( ruleBehaviorTime ) ; + // InternalBehaviorAnnexParser.g:14946:1: rule__DispatchTriggerCondition__TimeAssignment_1_2 : ( ruleBehaviorTime ) ; public final void rule__DispatchTriggerCondition__TimeAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14923:1: ( ( ruleBehaviorTime ) ) - // InternalBehaviorAnnexParser.g:14924:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:14950:1: ( ( ruleBehaviorTime ) ) + // InternalBehaviorAnnexParser.g:14951:2: ( ruleBehaviorTime ) { - // InternalBehaviorAnnexParser.g:14924:2: ( ruleBehaviorTime ) - // InternalBehaviorAnnexParser.g:14925:3: ruleBehaviorTime + // InternalBehaviorAnnexParser.g:14951:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:14952:3: ruleBehaviorTime { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getTimeBehaviorTimeParserRuleCall_1_2_0()); @@ -49060,23 +49155,23 @@ public final void rule__DispatchTriggerCondition__TimeAssignment_1_2() throws Re // $ANTLR start "rule__DispatchTriggerCondition__StopAssignment_2" - // InternalBehaviorAnnexParser.g:14934:1: rule__DispatchTriggerCondition__StopAssignment_2 : ( ( Stop ) ) ; + // InternalBehaviorAnnexParser.g:14961:1: rule__DispatchTriggerCondition__StopAssignment_2 : ( ( Stop ) ) ; public final void rule__DispatchTriggerCondition__StopAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14938:1: ( ( ( Stop ) ) ) - // InternalBehaviorAnnexParser.g:14939:2: ( ( Stop ) ) + // InternalBehaviorAnnexParser.g:14965:1: ( ( ( Stop ) ) ) + // InternalBehaviorAnnexParser.g:14966:2: ( ( Stop ) ) { - // InternalBehaviorAnnexParser.g:14939:2: ( ( Stop ) ) - // InternalBehaviorAnnexParser.g:14940:3: ( Stop ) + // InternalBehaviorAnnexParser.g:14966:2: ( ( Stop ) ) + // InternalBehaviorAnnexParser.g:14967:3: ( Stop ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getStopStopKeyword_2_0()); } - // InternalBehaviorAnnexParser.g:14941:3: ( Stop ) - // InternalBehaviorAnnexParser.g:14942:4: Stop + // InternalBehaviorAnnexParser.g:14968:3: ( Stop ) + // InternalBehaviorAnnexParser.g:14969:4: Stop { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getStopStopKeyword_2_0()); @@ -49113,17 +49208,17 @@ public final void rule__DispatchTriggerCondition__StopAssignment_2() throws Reco // $ANTLR start "rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0" - // InternalBehaviorAnnexParser.g:14953:1: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 : ( ruleDispatchConjunction ) ; + // InternalBehaviorAnnexParser.g:14980:1: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 : ( ruleDispatchConjunction ) ; public final void rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14957:1: ( ( ruleDispatchConjunction ) ) - // InternalBehaviorAnnexParser.g:14958:2: ( ruleDispatchConjunction ) + // InternalBehaviorAnnexParser.g:14984:1: ( ( ruleDispatchConjunction ) ) + // InternalBehaviorAnnexParser.g:14985:2: ( ruleDispatchConjunction ) { - // InternalBehaviorAnnexParser.g:14958:2: ( ruleDispatchConjunction ) - // InternalBehaviorAnnexParser.g:14959:3: ruleDispatchConjunction + // InternalBehaviorAnnexParser.g:14985:2: ( ruleDispatchConjunction ) + // InternalBehaviorAnnexParser.g:14986:3: ruleDispatchConjunction { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerLogicalExpressionAccess().getConjunctionsDispatchConjunctionParserRuleCall_0_0()); @@ -49158,17 +49253,17 @@ public final void rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment // $ANTLR start "rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1" - // InternalBehaviorAnnexParser.g:14968:1: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 : ( ruleDispatchConjunction ) ; + // InternalBehaviorAnnexParser.g:14995:1: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 : ( ruleDispatchConjunction ) ; public final void rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14972:1: ( ( ruleDispatchConjunction ) ) - // InternalBehaviorAnnexParser.g:14973:2: ( ruleDispatchConjunction ) + // InternalBehaviorAnnexParser.g:14999:1: ( ( ruleDispatchConjunction ) ) + // InternalBehaviorAnnexParser.g:15000:2: ( ruleDispatchConjunction ) { - // InternalBehaviorAnnexParser.g:14973:2: ( ruleDispatchConjunction ) - // InternalBehaviorAnnexParser.g:14974:3: ruleDispatchConjunction + // InternalBehaviorAnnexParser.g:15000:2: ( ruleDispatchConjunction ) + // InternalBehaviorAnnexParser.g:15001:3: ruleDispatchConjunction { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerLogicalExpressionAccess().getConjunctionsDispatchConjunctionParserRuleCall_1_1_0()); @@ -49203,17 +49298,17 @@ public final void rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment // $ANTLR start "rule__DispatchConjunction__TriggersAssignment_0" - // InternalBehaviorAnnexParser.g:14983:1: rule__DispatchConjunction__TriggersAssignment_0 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15010:1: rule__DispatchConjunction__TriggersAssignment_0 : ( ruleReference ) ; public final void rule__DispatchConjunction__TriggersAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14987:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14988:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15014:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15015:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14988:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14989:3: ruleReference + // InternalBehaviorAnnexParser.g:15015:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15016:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConjunctionAccess().getTriggersReferenceParserRuleCall_0_0()); @@ -49248,17 +49343,17 @@ public final void rule__DispatchConjunction__TriggersAssignment_0() throws Recog // $ANTLR start "rule__DispatchConjunction__TriggersAssignment_1_1" - // InternalBehaviorAnnexParser.g:14998:1: rule__DispatchConjunction__TriggersAssignment_1_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15025:1: rule__DispatchConjunction__TriggersAssignment_1_1 : ( ruleReference ) ; public final void rule__DispatchConjunction__TriggersAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15002:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15003:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15029:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15030:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15003:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15004:3: ruleReference + // InternalBehaviorAnnexParser.g:15030:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15031:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConjunctionAccess().getTriggersReferenceParserRuleCall_1_1_0()); @@ -49293,17 +49388,17 @@ public final void rule__DispatchConjunction__TriggersAssignment_1_1() throws Rec // $ANTLR start "rule__ModeSwitchCondition__ConjunctionsAssignment_0" - // InternalBehaviorAnnexParser.g:15013:1: rule__ModeSwitchCondition__ConjunctionsAssignment_0 : ( ruleModeSwitchConjunction ) ; + // InternalBehaviorAnnexParser.g:15040:1: rule__ModeSwitchCondition__ConjunctionsAssignment_0 : ( ruleModeSwitchConjunction ) ; public final void rule__ModeSwitchCondition__ConjunctionsAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15017:1: ( ( ruleModeSwitchConjunction ) ) - // InternalBehaviorAnnexParser.g:15018:2: ( ruleModeSwitchConjunction ) + // InternalBehaviorAnnexParser.g:15044:1: ( ( ruleModeSwitchConjunction ) ) + // InternalBehaviorAnnexParser.g:15045:2: ( ruleModeSwitchConjunction ) { - // InternalBehaviorAnnexParser.g:15018:2: ( ruleModeSwitchConjunction ) - // InternalBehaviorAnnexParser.g:15019:3: ruleModeSwitchConjunction + // InternalBehaviorAnnexParser.g:15045:2: ( ruleModeSwitchConjunction ) + // InternalBehaviorAnnexParser.g:15046:3: ruleModeSwitchConjunction { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConditionAccess().getConjunctionsModeSwitchConjunctionParserRuleCall_0_0()); @@ -49338,17 +49433,17 @@ public final void rule__ModeSwitchCondition__ConjunctionsAssignment_0() throws R // $ANTLR start "rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0" - // InternalBehaviorAnnexParser.g:15028:1: rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 : ( ruleLogicalOrOperator ) ; + // InternalBehaviorAnnexParser.g:15055:1: rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 : ( ruleLogicalOrOperator ) ; public final void rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15032:1: ( ( ruleLogicalOrOperator ) ) - // InternalBehaviorAnnexParser.g:15033:2: ( ruleLogicalOrOperator ) + // InternalBehaviorAnnexParser.g:15059:1: ( ( ruleLogicalOrOperator ) ) + // InternalBehaviorAnnexParser.g:15060:2: ( ruleLogicalOrOperator ) { - // InternalBehaviorAnnexParser.g:15033:2: ( ruleLogicalOrOperator ) - // InternalBehaviorAnnexParser.g:15034:3: ruleLogicalOrOperator + // InternalBehaviorAnnexParser.g:15060:2: ( ruleLogicalOrOperator ) + // InternalBehaviorAnnexParser.g:15061:3: ruleLogicalOrOperator { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConditionAccess().getLogicalOperatorsLogicalOrOperatorParserRuleCall_1_0_0()); @@ -49383,17 +49478,17 @@ public final void rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0() th // $ANTLR start "rule__ModeSwitchCondition__ConjunctionsAssignment_1_1" - // InternalBehaviorAnnexParser.g:15043:1: rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 : ( ruleModeSwitchConjunction ) ; + // InternalBehaviorAnnexParser.g:15070:1: rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 : ( ruleModeSwitchConjunction ) ; public final void rule__ModeSwitchCondition__ConjunctionsAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15047:1: ( ( ruleModeSwitchConjunction ) ) - // InternalBehaviorAnnexParser.g:15048:2: ( ruleModeSwitchConjunction ) + // InternalBehaviorAnnexParser.g:15074:1: ( ( ruleModeSwitchConjunction ) ) + // InternalBehaviorAnnexParser.g:15075:2: ( ruleModeSwitchConjunction ) { - // InternalBehaviorAnnexParser.g:15048:2: ( ruleModeSwitchConjunction ) - // InternalBehaviorAnnexParser.g:15049:3: ruleModeSwitchConjunction + // InternalBehaviorAnnexParser.g:15075:2: ( ruleModeSwitchConjunction ) + // InternalBehaviorAnnexParser.g:15076:3: ruleModeSwitchConjunction { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConditionAccess().getConjunctionsModeSwitchConjunctionParserRuleCall_1_1_0()); @@ -49428,17 +49523,17 @@ public final void rule__ModeSwitchCondition__ConjunctionsAssignment_1_1() throws // $ANTLR start "rule__ModeSwitchConjunction__TriggersAssignment_0" - // InternalBehaviorAnnexParser.g:15058:1: rule__ModeSwitchConjunction__TriggersAssignment_0 : ( ruleModeSwitchTrigger ) ; + // InternalBehaviorAnnexParser.g:15085:1: rule__ModeSwitchConjunction__TriggersAssignment_0 : ( ruleModeSwitchTrigger ) ; public final void rule__ModeSwitchConjunction__TriggersAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15062:1: ( ( ruleModeSwitchTrigger ) ) - // InternalBehaviorAnnexParser.g:15063:2: ( ruleModeSwitchTrigger ) + // InternalBehaviorAnnexParser.g:15089:1: ( ( ruleModeSwitchTrigger ) ) + // InternalBehaviorAnnexParser.g:15090:2: ( ruleModeSwitchTrigger ) { - // InternalBehaviorAnnexParser.g:15063:2: ( ruleModeSwitchTrigger ) - // InternalBehaviorAnnexParser.g:15064:3: ruleModeSwitchTrigger + // InternalBehaviorAnnexParser.g:15090:2: ( ruleModeSwitchTrigger ) + // InternalBehaviorAnnexParser.g:15091:3: ruleModeSwitchTrigger { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConjunctionAccess().getTriggersModeSwitchTriggerParserRuleCall_0_0()); @@ -49473,17 +49568,17 @@ public final void rule__ModeSwitchConjunction__TriggersAssignment_0() throws Rec // $ANTLR start "rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0" - // InternalBehaviorAnnexParser.g:15073:1: rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 : ( ruleLogicalAndOperator ) ; + // InternalBehaviorAnnexParser.g:15100:1: rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 : ( ruleLogicalAndOperator ) ; public final void rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15077:1: ( ( ruleLogicalAndOperator ) ) - // InternalBehaviorAnnexParser.g:15078:2: ( ruleLogicalAndOperator ) + // InternalBehaviorAnnexParser.g:15104:1: ( ( ruleLogicalAndOperator ) ) + // InternalBehaviorAnnexParser.g:15105:2: ( ruleLogicalAndOperator ) { - // InternalBehaviorAnnexParser.g:15078:2: ( ruleLogicalAndOperator ) - // InternalBehaviorAnnexParser.g:15079:3: ruleLogicalAndOperator + // InternalBehaviorAnnexParser.g:15105:2: ( ruleLogicalAndOperator ) + // InternalBehaviorAnnexParser.g:15106:3: ruleLogicalAndOperator { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConjunctionAccess().getLogicalOperatorsLogicalAndOperatorParserRuleCall_1_0_0()); @@ -49518,17 +49613,17 @@ public final void rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0() // $ANTLR start "rule__ModeSwitchConjunction__TriggersAssignment_1_1" - // InternalBehaviorAnnexParser.g:15088:1: rule__ModeSwitchConjunction__TriggersAssignment_1_1 : ( ruleModeSwitchTrigger ) ; + // InternalBehaviorAnnexParser.g:15115:1: rule__ModeSwitchConjunction__TriggersAssignment_1_1 : ( ruleModeSwitchTrigger ) ; public final void rule__ModeSwitchConjunction__TriggersAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15092:1: ( ( ruleModeSwitchTrigger ) ) - // InternalBehaviorAnnexParser.g:15093:2: ( ruleModeSwitchTrigger ) + // InternalBehaviorAnnexParser.g:15119:1: ( ( ruleModeSwitchTrigger ) ) + // InternalBehaviorAnnexParser.g:15120:2: ( ruleModeSwitchTrigger ) { - // InternalBehaviorAnnexParser.g:15093:2: ( ruleModeSwitchTrigger ) - // InternalBehaviorAnnexParser.g:15094:3: ruleModeSwitchTrigger + // InternalBehaviorAnnexParser.g:15120:2: ( ruleModeSwitchTrigger ) + // InternalBehaviorAnnexParser.g:15121:3: ruleModeSwitchTrigger { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConjunctionAccess().getTriggersModeSwitchTriggerParserRuleCall_1_1_0()); @@ -49563,17 +49658,17 @@ public final void rule__ModeSwitchConjunction__TriggersAssignment_1_1() throws R // $ANTLR start "rule__ModeSwitchTrigger__ReferenceAssignment_0" - // InternalBehaviorAnnexParser.g:15103:1: rule__ModeSwitchTrigger__ReferenceAssignment_0 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15130:1: rule__ModeSwitchTrigger__ReferenceAssignment_0 : ( ruleReference ) ; public final void rule__ModeSwitchTrigger__ReferenceAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15107:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15108:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15134:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15135:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15108:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15109:3: ruleReference + // InternalBehaviorAnnexParser.g:15135:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15136:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchTriggerAccess().getReferenceReferenceParserRuleCall_0_0()); @@ -49608,17 +49703,17 @@ public final void rule__ModeSwitchTrigger__ReferenceAssignment_0() throws Recogn // $ANTLR start "rule__ModeSwitchTrigger__ExpressionAssignment_1_1" - // InternalBehaviorAnnexParser.g:15118:1: rule__ModeSwitchTrigger__ExpressionAssignment_1_1 : ( ruleModeSwitchCondition ) ; + // InternalBehaviorAnnexParser.g:15145:1: rule__ModeSwitchTrigger__ExpressionAssignment_1_1 : ( ruleModeSwitchCondition ) ; public final void rule__ModeSwitchTrigger__ExpressionAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15122:1: ( ( ruleModeSwitchCondition ) ) - // InternalBehaviorAnnexParser.g:15123:2: ( ruleModeSwitchCondition ) + // InternalBehaviorAnnexParser.g:15149:1: ( ( ruleModeSwitchCondition ) ) + // InternalBehaviorAnnexParser.g:15150:2: ( ruleModeSwitchCondition ) { - // InternalBehaviorAnnexParser.g:15123:2: ( ruleModeSwitchCondition ) - // InternalBehaviorAnnexParser.g:15124:3: ruleModeSwitchCondition + // InternalBehaviorAnnexParser.g:15150:2: ( ruleModeSwitchCondition ) + // InternalBehaviorAnnexParser.g:15151:3: ruleModeSwitchCondition { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchTriggerAccess().getExpressionModeSwitchConditionParserRuleCall_1_1_0()); @@ -49653,17 +49748,17 @@ public final void rule__ModeSwitchTrigger__ExpressionAssignment_1_1() throws Rec // $ANTLR start "rule__InternalCondition__InternalPortsAssignment_1" - // InternalBehaviorAnnexParser.g:15133:1: rule__InternalCondition__InternalPortsAssignment_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15160:1: rule__InternalCondition__InternalPortsAssignment_1 : ( ruleReference ) ; public final void rule__InternalCondition__InternalPortsAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15137:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15138:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15164:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15165:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15138:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15139:3: ruleReference + // InternalBehaviorAnnexParser.g:15165:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15166:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getInternalConditionAccess().getInternalPortsReferenceParserRuleCall_1_0()); @@ -49698,17 +49793,17 @@ public final void rule__InternalCondition__InternalPortsAssignment_1() throws Re // $ANTLR start "rule__InternalCondition__InternalPortsAssignment_2_1" - // InternalBehaviorAnnexParser.g:15148:1: rule__InternalCondition__InternalPortsAssignment_2_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15175:1: rule__InternalCondition__InternalPortsAssignment_2_1 : ( ruleReference ) ; public final void rule__InternalCondition__InternalPortsAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15152:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15153:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15179:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15180:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15153:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15154:3: ruleReference + // InternalBehaviorAnnexParser.g:15180:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15181:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getInternalConditionAccess().getInternalPortsReferenceParserRuleCall_2_1_0()); @@ -49743,17 +49838,17 @@ public final void rule__InternalCondition__InternalPortsAssignment_2_1() throws // $ANTLR start "rule__BehaviorActionBlock__ContentAssignment_1" - // InternalBehaviorAnnexParser.g:15163:1: rule__BehaviorActionBlock__ContentAssignment_1 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15190:1: rule__BehaviorActionBlock__ContentAssignment_1 : ( ruleBehaviorActions ) ; public final void rule__BehaviorActionBlock__ContentAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15167:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15168:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15194:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15195:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15168:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15169:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15195:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15196:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionBlockAccess().getContentBehaviorActionsParserRuleCall_1_0()); @@ -49788,17 +49883,17 @@ public final void rule__BehaviorActionBlock__ContentAssignment_1() throws Recogn // $ANTLR start "rule__BehaviorActionBlock__TimeoutAssignment_3_1" - // InternalBehaviorAnnexParser.g:15178:1: rule__BehaviorActionBlock__TimeoutAssignment_3_1 : ( ruleBehaviorTime ) ; + // InternalBehaviorAnnexParser.g:15205:1: rule__BehaviorActionBlock__TimeoutAssignment_3_1 : ( ruleBehaviorTime ) ; public final void rule__BehaviorActionBlock__TimeoutAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15182:1: ( ( ruleBehaviorTime ) ) - // InternalBehaviorAnnexParser.g:15183:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15209:1: ( ( ruleBehaviorTime ) ) + // InternalBehaviorAnnexParser.g:15210:2: ( ruleBehaviorTime ) { - // InternalBehaviorAnnexParser.g:15183:2: ( ruleBehaviorTime ) - // InternalBehaviorAnnexParser.g:15184:3: ruleBehaviorTime + // InternalBehaviorAnnexParser.g:15210:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15211:3: ruleBehaviorTime { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionBlockAccess().getTimeoutBehaviorTimeParserRuleCall_3_1_0()); @@ -49833,17 +49928,17 @@ public final void rule__BehaviorActionBlock__TimeoutAssignment_3_1() throws Reco // $ANTLR start "rule__BehaviorActions__ActionsAssignment_1_0_2" - // InternalBehaviorAnnexParser.g:15193:1: rule__BehaviorActions__ActionsAssignment_1_0_2 : ( ruleBehaviorAction ) ; + // InternalBehaviorAnnexParser.g:15220:1: rule__BehaviorActions__ActionsAssignment_1_0_2 : ( ruleBehaviorAction ) ; public final void rule__BehaviorActions__ActionsAssignment_1_0_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15197:1: ( ( ruleBehaviorAction ) ) - // InternalBehaviorAnnexParser.g:15198:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15224:1: ( ( ruleBehaviorAction ) ) + // InternalBehaviorAnnexParser.g:15225:2: ( ruleBehaviorAction ) { - // InternalBehaviorAnnexParser.g:15198:2: ( ruleBehaviorAction ) - // InternalBehaviorAnnexParser.g:15199:3: ruleBehaviorAction + // InternalBehaviorAnnexParser.g:15225:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15226:3: ruleBehaviorAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsBehaviorActionParserRuleCall_1_0_2_0()); @@ -49878,17 +49973,17 @@ public final void rule__BehaviorActions__ActionsAssignment_1_0_2() throws Recogn // $ANTLR start "rule__BehaviorActions__ActionsAssignment_1_0_3_1" - // InternalBehaviorAnnexParser.g:15208:1: rule__BehaviorActions__ActionsAssignment_1_0_3_1 : ( ruleBehaviorAction ) ; + // InternalBehaviorAnnexParser.g:15235:1: rule__BehaviorActions__ActionsAssignment_1_0_3_1 : ( ruleBehaviorAction ) ; public final void rule__BehaviorActions__ActionsAssignment_1_0_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15212:1: ( ( ruleBehaviorAction ) ) - // InternalBehaviorAnnexParser.g:15213:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15239:1: ( ( ruleBehaviorAction ) ) + // InternalBehaviorAnnexParser.g:15240:2: ( ruleBehaviorAction ) { - // InternalBehaviorAnnexParser.g:15213:2: ( ruleBehaviorAction ) - // InternalBehaviorAnnexParser.g:15214:3: ruleBehaviorAction + // InternalBehaviorAnnexParser.g:15240:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15241:3: ruleBehaviorAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsBehaviorActionParserRuleCall_1_0_3_1_0()); @@ -49923,17 +50018,17 @@ public final void rule__BehaviorActions__ActionsAssignment_1_0_3_1() throws Reco // $ANTLR start "rule__BehaviorActions__ActionsAssignment_1_1_2" - // InternalBehaviorAnnexParser.g:15223:1: rule__BehaviorActions__ActionsAssignment_1_1_2 : ( ruleBehaviorAction ) ; + // InternalBehaviorAnnexParser.g:15250:1: rule__BehaviorActions__ActionsAssignment_1_1_2 : ( ruleBehaviorAction ) ; public final void rule__BehaviorActions__ActionsAssignment_1_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15227:1: ( ( ruleBehaviorAction ) ) - // InternalBehaviorAnnexParser.g:15228:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15254:1: ( ( ruleBehaviorAction ) ) + // InternalBehaviorAnnexParser.g:15255:2: ( ruleBehaviorAction ) { - // InternalBehaviorAnnexParser.g:15228:2: ( ruleBehaviorAction ) - // InternalBehaviorAnnexParser.g:15229:3: ruleBehaviorAction + // InternalBehaviorAnnexParser.g:15255:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15256:3: ruleBehaviorAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsBehaviorActionParserRuleCall_1_1_2_0()); @@ -49968,17 +50063,17 @@ public final void rule__BehaviorActions__ActionsAssignment_1_1_2() throws Recogn // $ANTLR start "rule__BehaviorActions__ActionsAssignment_1_1_3_1" - // InternalBehaviorAnnexParser.g:15238:1: rule__BehaviorActions__ActionsAssignment_1_1_3_1 : ( ruleBehaviorAction ) ; + // InternalBehaviorAnnexParser.g:15265:1: rule__BehaviorActions__ActionsAssignment_1_1_3_1 : ( ruleBehaviorAction ) ; public final void rule__BehaviorActions__ActionsAssignment_1_1_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15242:1: ( ( ruleBehaviorAction ) ) - // InternalBehaviorAnnexParser.g:15243:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15269:1: ( ( ruleBehaviorAction ) ) + // InternalBehaviorAnnexParser.g:15270:2: ( ruleBehaviorAction ) { - // InternalBehaviorAnnexParser.g:15243:2: ( ruleBehaviorAction ) - // InternalBehaviorAnnexParser.g:15244:3: ruleBehaviorAction + // InternalBehaviorAnnexParser.g:15270:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15271:3: ruleBehaviorAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsBehaviorActionParserRuleCall_1_1_3_1_0()); @@ -50013,17 +50108,17 @@ public final void rule__BehaviorActions__ActionsAssignment_1_1_3_1() throws Reco // $ANTLR start "rule__AssignmentAction__TargetAssignment_0" - // InternalBehaviorAnnexParser.g:15253:1: rule__AssignmentAction__TargetAssignment_0 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15280:1: rule__AssignmentAction__TargetAssignment_0 : ( ruleReference ) ; public final void rule__AssignmentAction__TargetAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15257:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15258:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15284:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15285:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15258:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15259:3: ruleReference + // InternalBehaviorAnnexParser.g:15285:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15286:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getTargetReferenceParserRuleCall_0_0()); @@ -50058,17 +50153,17 @@ public final void rule__AssignmentAction__TargetAssignment_0() throws Recognitio // $ANTLR start "rule__AssignmentAction__ValueAssignment_2_0" - // InternalBehaviorAnnexParser.g:15268:1: rule__AssignmentAction__ValueAssignment_2_0 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15295:1: rule__AssignmentAction__ValueAssignment_2_0 : ( ruleValueExpression ) ; public final void rule__AssignmentAction__ValueAssignment_2_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15272:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15273:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15299:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15300:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15273:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15274:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15300:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15301:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getValueValueExpressionParserRuleCall_2_0_0()); @@ -50103,23 +50198,23 @@ public final void rule__AssignmentAction__ValueAssignment_2_0() throws Recogniti // $ANTLR start "rule__AssignmentAction__AnyAssignment_2_1" - // InternalBehaviorAnnexParser.g:15283:1: rule__AssignmentAction__AnyAssignment_2_1 : ( ( Any ) ) ; + // InternalBehaviorAnnexParser.g:15310:1: rule__AssignmentAction__AnyAssignment_2_1 : ( ( Any ) ) ; public final void rule__AssignmentAction__AnyAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15287:1: ( ( ( Any ) ) ) - // InternalBehaviorAnnexParser.g:15288:2: ( ( Any ) ) + // InternalBehaviorAnnexParser.g:15314:1: ( ( ( Any ) ) ) + // InternalBehaviorAnnexParser.g:15315:2: ( ( Any ) ) { - // InternalBehaviorAnnexParser.g:15288:2: ( ( Any ) ) - // InternalBehaviorAnnexParser.g:15289:3: ( Any ) + // InternalBehaviorAnnexParser.g:15315:2: ( ( Any ) ) + // InternalBehaviorAnnexParser.g:15316:3: ( Any ) { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getAnyAnyKeyword_2_1_0()); } - // InternalBehaviorAnnexParser.g:15290:3: ( Any ) - // InternalBehaviorAnnexParser.g:15291:4: Any + // InternalBehaviorAnnexParser.g:15317:3: ( Any ) + // InternalBehaviorAnnexParser.g:15318:4: Any { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getAnyAnyKeyword_2_1_0()); @@ -50156,17 +50251,17 @@ public final void rule__AssignmentAction__AnyAssignment_2_1() throws Recognition // $ANTLR start "rule__CommunicationAction__ReferenceAssignment_0_0" - // InternalBehaviorAnnexParser.g:15302:1: rule__CommunicationAction__ReferenceAssignment_0_0 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15329:1: rule__CommunicationAction__ReferenceAssignment_0_0 : ( ruleReference ) ; public final void rule__CommunicationAction__ReferenceAssignment_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15306:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15307:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15333:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15334:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15307:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15308:3: ruleReference + // InternalBehaviorAnnexParser.g:15334:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15335:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getReferenceReferenceParserRuleCall_0_0_0()); @@ -50201,23 +50296,23 @@ public final void rule__CommunicationAction__ReferenceAssignment_0_0() throws Re // $ANTLR start "rule__CommunicationAction__SendAssignment_0_1_0_0" - // InternalBehaviorAnnexParser.g:15317:1: rule__CommunicationAction__SendAssignment_0_1_0_0 : ( ( ExclamationMark ) ) ; + // InternalBehaviorAnnexParser.g:15344:1: rule__CommunicationAction__SendAssignment_0_1_0_0 : ( ( ExclamationMark ) ) ; public final void rule__CommunicationAction__SendAssignment_0_1_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15321:1: ( ( ( ExclamationMark ) ) ) - // InternalBehaviorAnnexParser.g:15322:2: ( ( ExclamationMark ) ) + // InternalBehaviorAnnexParser.g:15348:1: ( ( ( ExclamationMark ) ) ) + // InternalBehaviorAnnexParser.g:15349:2: ( ( ExclamationMark ) ) { - // InternalBehaviorAnnexParser.g:15322:2: ( ( ExclamationMark ) ) - // InternalBehaviorAnnexParser.g:15323:3: ( ExclamationMark ) + // InternalBehaviorAnnexParser.g:15349:2: ( ( ExclamationMark ) ) + // InternalBehaviorAnnexParser.g:15350:3: ( ExclamationMark ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getSendExclamationMarkKeyword_0_1_0_0_0()); } - // InternalBehaviorAnnexParser.g:15324:3: ( ExclamationMark ) - // InternalBehaviorAnnexParser.g:15325:4: ExclamationMark + // InternalBehaviorAnnexParser.g:15351:3: ( ExclamationMark ) + // InternalBehaviorAnnexParser.g:15352:4: ExclamationMark { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getSendExclamationMarkKeyword_0_1_0_0_0()); @@ -50254,17 +50349,17 @@ public final void rule__CommunicationAction__SendAssignment_0_1_0_0() throws Rec // $ANTLR start "rule__CommunicationAction__ParametersAssignment_0_1_0_1_1" - // InternalBehaviorAnnexParser.g:15336:1: rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15363:1: rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 : ( ruleValueExpression ) ; public final void rule__CommunicationAction__ParametersAssignment_0_1_0_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15340:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15341:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15367:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15368:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15341:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15342:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15368:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15369:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getParametersValueExpressionParserRuleCall_0_1_0_1_1_0()); @@ -50299,17 +50394,17 @@ public final void rule__CommunicationAction__ParametersAssignment_0_1_0_1_1() th // $ANTLR start "rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1" - // InternalBehaviorAnnexParser.g:15351:1: rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15378:1: rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 : ( ruleValueExpression ) ; public final void rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15355:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15356:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15382:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15383:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15356:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15357:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15383:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15384:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getParametersValueExpressionParserRuleCall_0_1_0_1_2_1_0()); @@ -50344,23 +50439,23 @@ public final void rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1() // $ANTLR start "rule__CommunicationAction__DequeueAssignment_0_1_1_0" - // InternalBehaviorAnnexParser.g:15366:1: rule__CommunicationAction__DequeueAssignment_0_1_1_0 : ( ( QuestionMark ) ) ; + // InternalBehaviorAnnexParser.g:15393:1: rule__CommunicationAction__DequeueAssignment_0_1_1_0 : ( ( QuestionMark ) ) ; public final void rule__CommunicationAction__DequeueAssignment_0_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15370:1: ( ( ( QuestionMark ) ) ) - // InternalBehaviorAnnexParser.g:15371:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:15397:1: ( ( ( QuestionMark ) ) ) + // InternalBehaviorAnnexParser.g:15398:2: ( ( QuestionMark ) ) { - // InternalBehaviorAnnexParser.g:15371:2: ( ( QuestionMark ) ) - // InternalBehaviorAnnexParser.g:15372:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:15398:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:15399:3: ( QuestionMark ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getDequeueQuestionMarkKeyword_0_1_1_0_0()); } - // InternalBehaviorAnnexParser.g:15373:3: ( QuestionMark ) - // InternalBehaviorAnnexParser.g:15374:4: QuestionMark + // InternalBehaviorAnnexParser.g:15400:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:15401:4: QuestionMark { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getDequeueQuestionMarkKeyword_0_1_1_0_0()); @@ -50397,17 +50492,17 @@ public final void rule__CommunicationAction__DequeueAssignment_0_1_1_0() throws // $ANTLR start "rule__CommunicationAction__TargetAssignment_0_1_1_1_1" - // InternalBehaviorAnnexParser.g:15385:1: rule__CommunicationAction__TargetAssignment_0_1_1_1_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15412:1: rule__CommunicationAction__TargetAssignment_0_1_1_1_1 : ( ruleReference ) ; public final void rule__CommunicationAction__TargetAssignment_0_1_1_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15389:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15390:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15416:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15417:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15390:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15391:3: ruleReference + // InternalBehaviorAnnexParser.g:15417:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15418:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getTargetReferenceParserRuleCall_0_1_1_1_1_0()); @@ -50442,23 +50537,23 @@ public final void rule__CommunicationAction__TargetAssignment_0_1_1_1_1() throws // $ANTLR start "rule__CommunicationAction__FreezeAssignment_0_1_2" - // InternalBehaviorAnnexParser.g:15400:1: rule__CommunicationAction__FreezeAssignment_0_1_2 : ( ( GreaterThanSignGreaterThanSign ) ) ; + // InternalBehaviorAnnexParser.g:15427:1: rule__CommunicationAction__FreezeAssignment_0_1_2 : ( ( GreaterThanSignGreaterThanSign ) ) ; public final void rule__CommunicationAction__FreezeAssignment_0_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15404:1: ( ( ( GreaterThanSignGreaterThanSign ) ) ) - // InternalBehaviorAnnexParser.g:15405:2: ( ( GreaterThanSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15431:1: ( ( ( GreaterThanSignGreaterThanSign ) ) ) + // InternalBehaviorAnnexParser.g:15432:2: ( ( GreaterThanSignGreaterThanSign ) ) { - // InternalBehaviorAnnexParser.g:15405:2: ( ( GreaterThanSignGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:15406:3: ( GreaterThanSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15432:2: ( ( GreaterThanSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15433:3: ( GreaterThanSignGreaterThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getFreezeGreaterThanSignGreaterThanSignKeyword_0_1_2_0()); } - // InternalBehaviorAnnexParser.g:15407:3: ( GreaterThanSignGreaterThanSign ) - // InternalBehaviorAnnexParser.g:15408:4: GreaterThanSignGreaterThanSign + // InternalBehaviorAnnexParser.g:15434:3: ( GreaterThanSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15435:4: GreaterThanSignGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getFreezeGreaterThanSignGreaterThanSignKeyword_0_1_2_0()); @@ -50495,23 +50590,23 @@ public final void rule__CommunicationAction__FreezeAssignment_0_1_2() throws Rec // $ANTLR start "rule__CommunicationAction__LockAssignment_0_1_3" - // InternalBehaviorAnnexParser.g:15419:1: rule__CommunicationAction__LockAssignment_0_1_3 : ( ( ExclamationMarkLessThanSign ) ) ; + // InternalBehaviorAnnexParser.g:15446:1: rule__CommunicationAction__LockAssignment_0_1_3 : ( ( ExclamationMarkLessThanSign ) ) ; public final void rule__CommunicationAction__LockAssignment_0_1_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15423:1: ( ( ( ExclamationMarkLessThanSign ) ) ) - // InternalBehaviorAnnexParser.g:15424:2: ( ( ExclamationMarkLessThanSign ) ) + // InternalBehaviorAnnexParser.g:15450:1: ( ( ( ExclamationMarkLessThanSign ) ) ) + // InternalBehaviorAnnexParser.g:15451:2: ( ( ExclamationMarkLessThanSign ) ) { - // InternalBehaviorAnnexParser.g:15424:2: ( ( ExclamationMarkLessThanSign ) ) - // InternalBehaviorAnnexParser.g:15425:3: ( ExclamationMarkLessThanSign ) + // InternalBehaviorAnnexParser.g:15451:2: ( ( ExclamationMarkLessThanSign ) ) + // InternalBehaviorAnnexParser.g:15452:3: ( ExclamationMarkLessThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getLockExclamationMarkLessThanSignKeyword_0_1_3_0()); } - // InternalBehaviorAnnexParser.g:15426:3: ( ExclamationMarkLessThanSign ) - // InternalBehaviorAnnexParser.g:15427:4: ExclamationMarkLessThanSign + // InternalBehaviorAnnexParser.g:15453:3: ( ExclamationMarkLessThanSign ) + // InternalBehaviorAnnexParser.g:15454:4: ExclamationMarkLessThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getLockExclamationMarkLessThanSignKeyword_0_1_3_0()); @@ -50548,23 +50643,23 @@ public final void rule__CommunicationAction__LockAssignment_0_1_3() throws Recog // $ANTLR start "rule__CommunicationAction__UnlockAssignment_0_1_4" - // InternalBehaviorAnnexParser.g:15438:1: rule__CommunicationAction__UnlockAssignment_0_1_4 : ( ( ExclamationMarkGreaterThanSign ) ) ; + // InternalBehaviorAnnexParser.g:15465:1: rule__CommunicationAction__UnlockAssignment_0_1_4 : ( ( ExclamationMarkGreaterThanSign ) ) ; public final void rule__CommunicationAction__UnlockAssignment_0_1_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15442:1: ( ( ( ExclamationMarkGreaterThanSign ) ) ) - // InternalBehaviorAnnexParser.g:15443:2: ( ( ExclamationMarkGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15469:1: ( ( ( ExclamationMarkGreaterThanSign ) ) ) + // InternalBehaviorAnnexParser.g:15470:2: ( ( ExclamationMarkGreaterThanSign ) ) { - // InternalBehaviorAnnexParser.g:15443:2: ( ( ExclamationMarkGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:15444:3: ( ExclamationMarkGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15470:2: ( ( ExclamationMarkGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15471:3: ( ExclamationMarkGreaterThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getUnlockExclamationMarkGreaterThanSignKeyword_0_1_4_0()); } - // InternalBehaviorAnnexParser.g:15445:3: ( ExclamationMarkGreaterThanSign ) - // InternalBehaviorAnnexParser.g:15446:4: ExclamationMarkGreaterThanSign + // InternalBehaviorAnnexParser.g:15472:3: ( ExclamationMarkGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15473:4: ExclamationMarkGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getUnlockExclamationMarkGreaterThanSignKeyword_0_1_4_0()); @@ -50601,23 +50696,23 @@ public final void rule__CommunicationAction__UnlockAssignment_0_1_4() throws Rec // $ANTLR start "rule__CommunicationAction__AllAssignment_1_0" - // InternalBehaviorAnnexParser.g:15457:1: rule__CommunicationAction__AllAssignment_1_0 : ( ( Asterisk ) ) ; + // InternalBehaviorAnnexParser.g:15484:1: rule__CommunicationAction__AllAssignment_1_0 : ( ( Asterisk ) ) ; public final void rule__CommunicationAction__AllAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15461:1: ( ( ( Asterisk ) ) ) - // InternalBehaviorAnnexParser.g:15462:2: ( ( Asterisk ) ) + // InternalBehaviorAnnexParser.g:15488:1: ( ( ( Asterisk ) ) ) + // InternalBehaviorAnnexParser.g:15489:2: ( ( Asterisk ) ) { - // InternalBehaviorAnnexParser.g:15462:2: ( ( Asterisk ) ) - // InternalBehaviorAnnexParser.g:15463:3: ( Asterisk ) + // InternalBehaviorAnnexParser.g:15489:2: ( ( Asterisk ) ) + // InternalBehaviorAnnexParser.g:15490:3: ( Asterisk ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllAsteriskKeyword_1_0_0()); } - // InternalBehaviorAnnexParser.g:15464:3: ( Asterisk ) - // InternalBehaviorAnnexParser.g:15465:4: Asterisk + // InternalBehaviorAnnexParser.g:15491:3: ( Asterisk ) + // InternalBehaviorAnnexParser.g:15492:4: Asterisk { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllAsteriskKeyword_1_0_0()); @@ -50654,23 +50749,23 @@ public final void rule__CommunicationAction__AllAssignment_1_0() throws Recognit // $ANTLR start "rule__CommunicationAction__AllLockAssignment_1_1_0" - // InternalBehaviorAnnexParser.g:15476:1: rule__CommunicationAction__AllLockAssignment_1_1_0 : ( ( ExclamationMarkLessThanSign ) ) ; + // InternalBehaviorAnnexParser.g:15503:1: rule__CommunicationAction__AllLockAssignment_1_1_0 : ( ( ExclamationMarkLessThanSign ) ) ; public final void rule__CommunicationAction__AllLockAssignment_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15480:1: ( ( ( ExclamationMarkLessThanSign ) ) ) - // InternalBehaviorAnnexParser.g:15481:2: ( ( ExclamationMarkLessThanSign ) ) + // InternalBehaviorAnnexParser.g:15507:1: ( ( ( ExclamationMarkLessThanSign ) ) ) + // InternalBehaviorAnnexParser.g:15508:2: ( ( ExclamationMarkLessThanSign ) ) { - // InternalBehaviorAnnexParser.g:15481:2: ( ( ExclamationMarkLessThanSign ) ) - // InternalBehaviorAnnexParser.g:15482:3: ( ExclamationMarkLessThanSign ) + // InternalBehaviorAnnexParser.g:15508:2: ( ( ExclamationMarkLessThanSign ) ) + // InternalBehaviorAnnexParser.g:15509:3: ( ExclamationMarkLessThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllLockExclamationMarkLessThanSignKeyword_1_1_0_0()); } - // InternalBehaviorAnnexParser.g:15483:3: ( ExclamationMarkLessThanSign ) - // InternalBehaviorAnnexParser.g:15484:4: ExclamationMarkLessThanSign + // InternalBehaviorAnnexParser.g:15510:3: ( ExclamationMarkLessThanSign ) + // InternalBehaviorAnnexParser.g:15511:4: ExclamationMarkLessThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllLockExclamationMarkLessThanSignKeyword_1_1_0_0()); @@ -50707,23 +50802,23 @@ public final void rule__CommunicationAction__AllLockAssignment_1_1_0() throws Re // $ANTLR start "rule__CommunicationAction__AllUnlockAssignment_1_1_1" - // InternalBehaviorAnnexParser.g:15495:1: rule__CommunicationAction__AllUnlockAssignment_1_1_1 : ( ( ExclamationMarkGreaterThanSign ) ) ; + // InternalBehaviorAnnexParser.g:15522:1: rule__CommunicationAction__AllUnlockAssignment_1_1_1 : ( ( ExclamationMarkGreaterThanSign ) ) ; public final void rule__CommunicationAction__AllUnlockAssignment_1_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15499:1: ( ( ( ExclamationMarkGreaterThanSign ) ) ) - // InternalBehaviorAnnexParser.g:15500:2: ( ( ExclamationMarkGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15526:1: ( ( ( ExclamationMarkGreaterThanSign ) ) ) + // InternalBehaviorAnnexParser.g:15527:2: ( ( ExclamationMarkGreaterThanSign ) ) { - // InternalBehaviorAnnexParser.g:15500:2: ( ( ExclamationMarkGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:15501:3: ( ExclamationMarkGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15527:2: ( ( ExclamationMarkGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15528:3: ( ExclamationMarkGreaterThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllUnlockExclamationMarkGreaterThanSignKeyword_1_1_1_0()); } - // InternalBehaviorAnnexParser.g:15502:3: ( ExclamationMarkGreaterThanSign ) - // InternalBehaviorAnnexParser.g:15503:4: ExclamationMarkGreaterThanSign + // InternalBehaviorAnnexParser.g:15529:3: ( ExclamationMarkGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15530:4: ExclamationMarkGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllUnlockExclamationMarkGreaterThanSignKeyword_1_1_1_0()); @@ -50760,17 +50855,17 @@ public final void rule__CommunicationAction__AllUnlockAssignment_1_1_1() throws // $ANTLR start "rule__TimedAction__LowerTimeAssignment_2" - // InternalBehaviorAnnexParser.g:15514:1: rule__TimedAction__LowerTimeAssignment_2 : ( ruleBehaviorTime ) ; + // InternalBehaviorAnnexParser.g:15541:1: rule__TimedAction__LowerTimeAssignment_2 : ( ruleBehaviorTime ) ; public final void rule__TimedAction__LowerTimeAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15518:1: ( ( ruleBehaviorTime ) ) - // InternalBehaviorAnnexParser.g:15519:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15545:1: ( ( ruleBehaviorTime ) ) + // InternalBehaviorAnnexParser.g:15546:2: ( ruleBehaviorTime ) { - // InternalBehaviorAnnexParser.g:15519:2: ( ruleBehaviorTime ) - // InternalBehaviorAnnexParser.g:15520:3: ruleBehaviorTime + // InternalBehaviorAnnexParser.g:15546:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15547:3: ruleBehaviorTime { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getLowerTimeBehaviorTimeParserRuleCall_2_0()); @@ -50805,17 +50900,17 @@ public final void rule__TimedAction__LowerTimeAssignment_2() throws RecognitionE // $ANTLR start "rule__TimedAction__UpperTimeAssignment_3_1" - // InternalBehaviorAnnexParser.g:15529:1: rule__TimedAction__UpperTimeAssignment_3_1 : ( ruleBehaviorTime ) ; + // InternalBehaviorAnnexParser.g:15556:1: rule__TimedAction__UpperTimeAssignment_3_1 : ( ruleBehaviorTime ) ; public final void rule__TimedAction__UpperTimeAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15533:1: ( ( ruleBehaviorTime ) ) - // InternalBehaviorAnnexParser.g:15534:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15560:1: ( ( ruleBehaviorTime ) ) + // InternalBehaviorAnnexParser.g:15561:2: ( ruleBehaviorTime ) { - // InternalBehaviorAnnexParser.g:15534:2: ( ruleBehaviorTime ) - // InternalBehaviorAnnexParser.g:15535:3: ruleBehaviorTime + // InternalBehaviorAnnexParser.g:15561:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15562:3: ruleBehaviorTime { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getUpperTimeBehaviorTimeParserRuleCall_3_1_0()); @@ -50850,23 +50945,23 @@ public final void rule__TimedAction__UpperTimeAssignment_3_1() throws Recognitio // $ANTLR start "rule__TimedAction__ProcessorsAssignment_5_3" - // InternalBehaviorAnnexParser.g:15544:1: rule__TimedAction__ProcessorsAssignment_5_3 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:15571:1: rule__TimedAction__ProcessorsAssignment_5_3 : ( ( ruleQCREF ) ) ; public final void rule__TimedAction__ProcessorsAssignment_5_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15548:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:15549:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15575:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:15576:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:15549:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:15550:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15576:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15577:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getProcessorsComponentClassifierCrossReference_5_3_0()); } - // InternalBehaviorAnnexParser.g:15551:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:15552:4: ruleQCREF + // InternalBehaviorAnnexParser.g:15578:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15579:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getProcessorsComponentClassifierQCREFParserRuleCall_5_3_0_1()); @@ -50907,23 +51002,23 @@ public final void rule__TimedAction__ProcessorsAssignment_5_3() throws Recogniti // $ANTLR start "rule__TimedAction__ProcessorsAssignment_5_4_1" - // InternalBehaviorAnnexParser.g:15563:1: rule__TimedAction__ProcessorsAssignment_5_4_1 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:15590:1: rule__TimedAction__ProcessorsAssignment_5_4_1 : ( ( ruleQCREF ) ) ; public final void rule__TimedAction__ProcessorsAssignment_5_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15567:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:15568:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15594:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:15595:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:15568:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:15569:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15595:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15596:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getProcessorsComponentClassifierCrossReference_5_4_1_0()); } - // InternalBehaviorAnnexParser.g:15570:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:15571:4: ruleQCREF + // InternalBehaviorAnnexParser.g:15597:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15598:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getProcessorsComponentClassifierQCREFParserRuleCall_5_4_1_0_1()); @@ -50964,17 +51059,17 @@ public final void rule__TimedAction__ProcessorsAssignment_5_4_1() throws Recogni // $ANTLR start "rule__IfStatement__ConditionAssignment_2" - // InternalBehaviorAnnexParser.g:15582:1: rule__IfStatement__ConditionAssignment_2 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15609:1: rule__IfStatement__ConditionAssignment_2 : ( ruleValueExpression ) ; public final void rule__IfStatement__ConditionAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15586:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15587:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15613:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15614:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15587:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15588:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15614:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15615:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getConditionValueExpressionParserRuleCall_2_0()); @@ -51009,17 +51104,17 @@ public final void rule__IfStatement__ConditionAssignment_2() throws RecognitionE // $ANTLR start "rule__IfStatement__ThenActionsAssignment_4" - // InternalBehaviorAnnexParser.g:15597:1: rule__IfStatement__ThenActionsAssignment_4 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15624:1: rule__IfStatement__ThenActionsAssignment_4 : ( ruleBehaviorActions ) ; public final void rule__IfStatement__ThenActionsAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15601:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15602:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15628:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15629:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15602:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15603:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15629:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15630:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getThenActionsBehaviorActionsParserRuleCall_4_0()); @@ -51054,17 +51149,17 @@ public final void rule__IfStatement__ThenActionsAssignment_4() throws Recognitio // $ANTLR start "rule__IfStatement__ElseIfsAssignment_5" - // InternalBehaviorAnnexParser.g:15612:1: rule__IfStatement__ElseIfsAssignment_5 : ( ruleElseIfClause ) ; + // InternalBehaviorAnnexParser.g:15639:1: rule__IfStatement__ElseIfsAssignment_5 : ( ruleElseIfClause ) ; public final void rule__IfStatement__ElseIfsAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15616:1: ( ( ruleElseIfClause ) ) - // InternalBehaviorAnnexParser.g:15617:2: ( ruleElseIfClause ) + // InternalBehaviorAnnexParser.g:15643:1: ( ( ruleElseIfClause ) ) + // InternalBehaviorAnnexParser.g:15644:2: ( ruleElseIfClause ) { - // InternalBehaviorAnnexParser.g:15617:2: ( ruleElseIfClause ) - // InternalBehaviorAnnexParser.g:15618:3: ruleElseIfClause + // InternalBehaviorAnnexParser.g:15644:2: ( ruleElseIfClause ) + // InternalBehaviorAnnexParser.g:15645:3: ruleElseIfClause { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getElseIfsElseIfClauseParserRuleCall_5_0()); @@ -51099,17 +51194,17 @@ public final void rule__IfStatement__ElseIfsAssignment_5() throws RecognitionExc // $ANTLR start "rule__IfStatement__ElseActionsAssignment_6_1" - // InternalBehaviorAnnexParser.g:15627:1: rule__IfStatement__ElseActionsAssignment_6_1 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15654:1: rule__IfStatement__ElseActionsAssignment_6_1 : ( ruleBehaviorActions ) ; public final void rule__IfStatement__ElseActionsAssignment_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15631:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15632:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15658:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15659:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15632:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15633:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15659:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15660:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getElseActionsBehaviorActionsParserRuleCall_6_1_0()); @@ -51144,17 +51239,17 @@ public final void rule__IfStatement__ElseActionsAssignment_6_1() throws Recognit // $ANTLR start "rule__ElseIfClause__ConditionAssignment_2" - // InternalBehaviorAnnexParser.g:15642:1: rule__ElseIfClause__ConditionAssignment_2 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15669:1: rule__ElseIfClause__ConditionAssignment_2 : ( ruleValueExpression ) ; public final void rule__ElseIfClause__ConditionAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15646:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15647:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15673:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15674:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15647:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15648:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15674:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15675:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getElseIfClauseAccess().getConditionValueExpressionParserRuleCall_2_0()); @@ -51189,17 +51284,17 @@ public final void rule__ElseIfClause__ConditionAssignment_2() throws Recognition // $ANTLR start "rule__ElseIfClause__ActionsAssignment_4" - // InternalBehaviorAnnexParser.g:15657:1: rule__ElseIfClause__ActionsAssignment_4 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15684:1: rule__ElseIfClause__ActionsAssignment_4 : ( ruleBehaviorActions ) ; public final void rule__ElseIfClause__ActionsAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15661:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15662:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15688:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15689:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15662:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15663:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15689:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15690:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getElseIfClauseAccess().getActionsBehaviorActionsParserRuleCall_4_0()); @@ -51234,23 +51329,23 @@ public final void rule__ElseIfClause__ActionsAssignment_4() throws RecognitionEx // $ANTLR start "rule__ForStatement__ForAssignment_0_0" - // InternalBehaviorAnnexParser.g:15672:1: rule__ForStatement__ForAssignment_0_0 : ( ( For ) ) ; + // InternalBehaviorAnnexParser.g:15699:1: rule__ForStatement__ForAssignment_0_0 : ( ( For ) ) ; public final void rule__ForStatement__ForAssignment_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15676:1: ( ( ( For ) ) ) - // InternalBehaviorAnnexParser.g:15677:2: ( ( For ) ) + // InternalBehaviorAnnexParser.g:15703:1: ( ( ( For ) ) ) + // InternalBehaviorAnnexParser.g:15704:2: ( ( For ) ) { - // InternalBehaviorAnnexParser.g:15677:2: ( ( For ) ) - // InternalBehaviorAnnexParser.g:15678:3: ( For ) + // InternalBehaviorAnnexParser.g:15704:2: ( ( For ) ) + // InternalBehaviorAnnexParser.g:15705:3: ( For ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getForForKeyword_0_0_0()); } - // InternalBehaviorAnnexParser.g:15679:3: ( For ) - // InternalBehaviorAnnexParser.g:15680:4: For + // InternalBehaviorAnnexParser.g:15706:3: ( For ) + // InternalBehaviorAnnexParser.g:15707:4: For { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getForForKeyword_0_0_0()); @@ -51287,23 +51382,23 @@ public final void rule__ForStatement__ForAssignment_0_0() throws RecognitionExce // $ANTLR start "rule__ForStatement__ForallAssignment_0_1" - // InternalBehaviorAnnexParser.g:15691:1: rule__ForStatement__ForallAssignment_0_1 : ( ( Forall ) ) ; + // InternalBehaviorAnnexParser.g:15718:1: rule__ForStatement__ForallAssignment_0_1 : ( ( Forall ) ) ; public final void rule__ForStatement__ForallAssignment_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15695:1: ( ( ( Forall ) ) ) - // InternalBehaviorAnnexParser.g:15696:2: ( ( Forall ) ) + // InternalBehaviorAnnexParser.g:15722:1: ( ( ( Forall ) ) ) + // InternalBehaviorAnnexParser.g:15723:2: ( ( Forall ) ) { - // InternalBehaviorAnnexParser.g:15696:2: ( ( Forall ) ) - // InternalBehaviorAnnexParser.g:15697:3: ( Forall ) + // InternalBehaviorAnnexParser.g:15723:2: ( ( Forall ) ) + // InternalBehaviorAnnexParser.g:15724:3: ( Forall ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getForallForallKeyword_0_1_0()); } - // InternalBehaviorAnnexParser.g:15698:3: ( Forall ) - // InternalBehaviorAnnexParser.g:15699:4: Forall + // InternalBehaviorAnnexParser.g:15725:3: ( Forall ) + // InternalBehaviorAnnexParser.g:15726:4: Forall { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getForallForallKeyword_0_1_0()); @@ -51340,17 +51435,17 @@ public final void rule__ForStatement__ForallAssignment_0_1() throws RecognitionE // $ANTLR start "rule__ForStatement__VariableAssignment_2" - // InternalBehaviorAnnexParser.g:15710:1: rule__ForStatement__VariableAssignment_2 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:15737:1: rule__ForStatement__VariableAssignment_2 : ( RULE_ID ) ; public final void rule__ForStatement__VariableAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15714:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:15715:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:15741:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:15742:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:15715:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:15716:3: RULE_ID + // InternalBehaviorAnnexParser.g:15742:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:15743:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getVariableIDTerminalRuleCall_2_0()); @@ -51380,27 +51475,27 @@ public final void rule__ForStatement__VariableAssignment_2() throws RecognitionE // $ANTLR end "rule__ForStatement__VariableAssignment_2" - // $ANTLR start "rule__ForStatement__DataClassifierAssignment_4" - // InternalBehaviorAnnexParser.g:15725:1: rule__ForStatement__DataClassifierAssignment_4 : ( ( ruleQCREF ) ) ; - public final void rule__ForStatement__DataClassifierAssignment_4() throws RecognitionException { + // $ANTLR start "rule__ForStatement__DataClassifierAssignment_3_1" + // InternalBehaviorAnnexParser.g:15752:1: rule__ForStatement__DataClassifierAssignment_3_1 : ( ( ruleQCREF ) ) ; + public final void rule__ForStatement__DataClassifierAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15729:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:15730:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15756:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:15757:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:15730:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:15731:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15757:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15758:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_4_0()); + before(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_3_1_0()); } - // InternalBehaviorAnnexParser.g:15732:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:15733:4: ruleQCREF + // InternalBehaviorAnnexParser.g:15759:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15760:4: ruleQCREF { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_4_0_1()); + before(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_3_1_0_1()); } pushFollow(FollowSets000.FOLLOW_2); ruleQCREF(); @@ -51408,13 +51503,13 @@ public final void rule__ForStatement__DataClassifierAssignment_4() throws Recogn state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_4_0_1()); + after(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_3_1_0_1()); } } if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_4_0()); + after(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_3_1_0()); } } @@ -51434,24 +51529,24 @@ public final void rule__ForStatement__DataClassifierAssignment_4() throws Recogn } return ; } - // $ANTLR end "rule__ForStatement__DataClassifierAssignment_4" + // $ANTLR end "rule__ForStatement__DataClassifierAssignment_3_1" - // $ANTLR start "rule__ForStatement__ValuesAssignment_6" - // InternalBehaviorAnnexParser.g:15744:1: rule__ForStatement__ValuesAssignment_6 : ( ruleElementValues ) ; - public final void rule__ForStatement__ValuesAssignment_6() throws RecognitionException { + // $ANTLR start "rule__ForStatement__ValuesAssignment_5" + // InternalBehaviorAnnexParser.g:15771:1: rule__ForStatement__ValuesAssignment_5 : ( ruleElementValues ) ; + public final void rule__ForStatement__ValuesAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15748:1: ( ( ruleElementValues ) ) - // InternalBehaviorAnnexParser.g:15749:2: ( ruleElementValues ) + // InternalBehaviorAnnexParser.g:15775:1: ( ( ruleElementValues ) ) + // InternalBehaviorAnnexParser.g:15776:2: ( ruleElementValues ) { - // InternalBehaviorAnnexParser.g:15749:2: ( ruleElementValues ) - // InternalBehaviorAnnexParser.g:15750:3: ruleElementValues + // InternalBehaviorAnnexParser.g:15776:2: ( ruleElementValues ) + // InternalBehaviorAnnexParser.g:15777:3: ruleElementValues { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_6_0()); + before(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_5_0()); } pushFollow(FollowSets000.FOLLOW_2); ruleElementValues(); @@ -51459,7 +51554,7 @@ public final void rule__ForStatement__ValuesAssignment_6() throws RecognitionExc state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_6_0()); + after(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_5_0()); } } @@ -51479,24 +51574,24 @@ public final void rule__ForStatement__ValuesAssignment_6() throws RecognitionExc } return ; } - // $ANTLR end "rule__ForStatement__ValuesAssignment_6" + // $ANTLR end "rule__ForStatement__ValuesAssignment_5" - // $ANTLR start "rule__ForStatement__ActionsAssignment_9" - // InternalBehaviorAnnexParser.g:15759:1: rule__ForStatement__ActionsAssignment_9 : ( ruleBehaviorActions ) ; - public final void rule__ForStatement__ActionsAssignment_9() throws RecognitionException { + // $ANTLR start "rule__ForStatement__ActionsAssignment_8" + // InternalBehaviorAnnexParser.g:15786:1: rule__ForStatement__ActionsAssignment_8 : ( ruleBehaviorActions ) ; + public final void rule__ForStatement__ActionsAssignment_8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15763:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15764:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15790:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15791:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15764:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15765:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15791:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15792:3: ruleBehaviorActions { if ( state.backtracking==0 ) { - before(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_9_0()); + before(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_8_0()); } pushFollow(FollowSets000.FOLLOW_2); ruleBehaviorActions(); @@ -51504,7 +51599,7 @@ public final void rule__ForStatement__ActionsAssignment_9() throws RecognitionEx state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_9_0()); + after(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_8_0()); } } @@ -51524,21 +51619,21 @@ public final void rule__ForStatement__ActionsAssignment_9() throws RecognitionEx } return ; } - // $ANTLR end "rule__ForStatement__ActionsAssignment_9" + // $ANTLR end "rule__ForStatement__ActionsAssignment_8" // $ANTLR start "rule__WhileStatement__ConditionAssignment_2" - // InternalBehaviorAnnexParser.g:15774:1: rule__WhileStatement__ConditionAssignment_2 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15801:1: rule__WhileStatement__ConditionAssignment_2 : ( ruleValueExpression ) ; public final void rule__WhileStatement__ConditionAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15778:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15779:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15805:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15806:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15779:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15780:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15806:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15807:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getConditionValueExpressionParserRuleCall_2_0()); @@ -51573,17 +51668,17 @@ public final void rule__WhileStatement__ConditionAssignment_2() throws Recogniti // $ANTLR start "rule__WhileStatement__ActionsAssignment_5" - // InternalBehaviorAnnexParser.g:15789:1: rule__WhileStatement__ActionsAssignment_5 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15816:1: rule__WhileStatement__ActionsAssignment_5 : ( ruleBehaviorActions ) ; public final void rule__WhileStatement__ActionsAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15793:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15794:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15820:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15821:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15794:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15795:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15821:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15822:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getActionsBehaviorActionsParserRuleCall_5_0()); @@ -51618,17 +51713,17 @@ public final void rule__WhileStatement__ActionsAssignment_5() throws Recognition // $ANTLR start "rule__DoUntilStatement__ActionsAssignment_1" - // InternalBehaviorAnnexParser.g:15804:1: rule__DoUntilStatement__ActionsAssignment_1 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15831:1: rule__DoUntilStatement__ActionsAssignment_1 : ( ruleBehaviorActions ) ; public final void rule__DoUntilStatement__ActionsAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15808:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15809:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15835:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15836:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15809:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15810:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15836:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15837:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getActionsBehaviorActionsParserRuleCall_1_0()); @@ -51663,17 +51758,17 @@ public final void rule__DoUntilStatement__ActionsAssignment_1() throws Recogniti // $ANTLR start "rule__DoUntilStatement__ConditionAssignment_4" - // InternalBehaviorAnnexParser.g:15819:1: rule__DoUntilStatement__ConditionAssignment_4 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15846:1: rule__DoUntilStatement__ConditionAssignment_4 : ( ruleValueExpression ) ; public final void rule__DoUntilStatement__ConditionAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15823:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15824:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15850:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15851:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15824:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15825:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15851:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15852:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getConditionValueExpressionParserRuleCall_4_0()); @@ -51708,17 +51803,17 @@ public final void rule__DoUntilStatement__ConditionAssignment_4() throws Recogni // $ANTLR start "rule__ElementValues__LowerAssignment_0" - // InternalBehaviorAnnexParser.g:15834:1: rule__ElementValues__LowerAssignment_0 : ( ruleIntegerValue ) ; + // InternalBehaviorAnnexParser.g:15861:1: rule__ElementValues__LowerAssignment_0 : ( ruleIntegerValue ) ; public final void rule__ElementValues__LowerAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15838:1: ( ( ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:15839:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15865:1: ( ( ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:15866:2: ( ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:15839:2: ( ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:15840:3: ruleIntegerValue + // InternalBehaviorAnnexParser.g:15866:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15867:3: ruleIntegerValue { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getLowerIntegerValueParserRuleCall_0_0()); @@ -51753,17 +51848,17 @@ public final void rule__ElementValues__LowerAssignment_0() throws RecognitionExc // $ANTLR start "rule__ElementValues__UpperAssignment_1_1" - // InternalBehaviorAnnexParser.g:15849:1: rule__ElementValues__UpperAssignment_1_1 : ( ruleIntegerValue ) ; + // InternalBehaviorAnnexParser.g:15876:1: rule__ElementValues__UpperAssignment_1_1 : ( ruleIntegerValue ) ; public final void rule__ElementValues__UpperAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15853:1: ( ( ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:15854:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15880:1: ( ( ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:15881:2: ( ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:15854:2: ( ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:15855:3: ruleIntegerValue + // InternalBehaviorAnnexParser.g:15881:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15882:3: ruleIntegerValue { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getUpperIntegerValueParserRuleCall_1_1_0()); @@ -51798,17 +51893,17 @@ public final void rule__ElementValues__UpperAssignment_1_1() throws RecognitionE // $ANTLR start "rule__BehaviorTime__ValueAssignment_0" - // InternalBehaviorAnnexParser.g:15864:1: rule__BehaviorTime__ValueAssignment_0 : ( ruleIntegerValue ) ; + // InternalBehaviorAnnexParser.g:15891:1: rule__BehaviorTime__ValueAssignment_0 : ( ruleIntegerValue ) ; public final void rule__BehaviorTime__ValueAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15868:1: ( ( ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:15869:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15895:1: ( ( ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:15896:2: ( ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:15869:2: ( ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:15870:3: ruleIntegerValue + // InternalBehaviorAnnexParser.g:15896:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15897:3: ruleIntegerValue { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTimeAccess().getValueIntegerValueParserRuleCall_0_0()); @@ -51843,23 +51938,23 @@ public final void rule__BehaviorTime__ValueAssignment_0() throws RecognitionExce // $ANTLR start "rule__BehaviorTime__UnitAssignment_1" - // InternalBehaviorAnnexParser.g:15879:1: rule__BehaviorTime__UnitAssignment_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:15906:1: rule__BehaviorTime__UnitAssignment_1 : ( ( RULE_ID ) ) ; public final void rule__BehaviorTime__UnitAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15883:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:15884:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:15910:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:15911:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:15884:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:15885:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:15911:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:15912:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTimeAccess().getUnitUnitLiteralCrossReference_1_0()); } - // InternalBehaviorAnnexParser.g:15886:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:15887:4: RULE_ID + // InternalBehaviorAnnexParser.g:15913:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:15914:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTimeAccess().getUnitUnitLiteralIDTerminalRuleCall_1_0_1()); @@ -51896,17 +51991,17 @@ public final void rule__BehaviorTime__UnitAssignment_1() throws RecognitionExcep // $ANTLR start "rule__ValueExpression__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:15898:1: rule__ValueExpression__OperatorAssignment_1_1 : ( ruleLogicalOperator ) ; + // InternalBehaviorAnnexParser.g:15925:1: rule__ValueExpression__OperatorAssignment_1_1 : ( ruleLogicalOperator ) ; public final void rule__ValueExpression__OperatorAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15902:1: ( ( ruleLogicalOperator ) ) - // InternalBehaviorAnnexParser.g:15903:2: ( ruleLogicalOperator ) + // InternalBehaviorAnnexParser.g:15929:1: ( ( ruleLogicalOperator ) ) + // InternalBehaviorAnnexParser.g:15930:2: ( ruleLogicalOperator ) { - // InternalBehaviorAnnexParser.g:15903:2: ( ruleLogicalOperator ) - // InternalBehaviorAnnexParser.g:15904:3: ruleLogicalOperator + // InternalBehaviorAnnexParser.g:15930:2: ( ruleLogicalOperator ) + // InternalBehaviorAnnexParser.g:15931:3: ruleLogicalOperator { if ( state.backtracking==0 ) { before(grammarAccess.getValueExpressionAccess().getOperatorLogicalOperatorParserRuleCall_1_1_0()); @@ -51941,17 +52036,17 @@ public final void rule__ValueExpression__OperatorAssignment_1_1() throws Recogni // $ANTLR start "rule__ValueExpression__RightAssignment_1_2" - // InternalBehaviorAnnexParser.g:15913:1: rule__ValueExpression__RightAssignment_1_2 : ( ruleRelation ) ; + // InternalBehaviorAnnexParser.g:15940:1: rule__ValueExpression__RightAssignment_1_2 : ( ruleRelation ) ; public final void rule__ValueExpression__RightAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15917:1: ( ( ruleRelation ) ) - // InternalBehaviorAnnexParser.g:15918:2: ( ruleRelation ) + // InternalBehaviorAnnexParser.g:15944:1: ( ( ruleRelation ) ) + // InternalBehaviorAnnexParser.g:15945:2: ( ruleRelation ) { - // InternalBehaviorAnnexParser.g:15918:2: ( ruleRelation ) - // InternalBehaviorAnnexParser.g:15919:3: ruleRelation + // InternalBehaviorAnnexParser.g:15945:2: ( ruleRelation ) + // InternalBehaviorAnnexParser.g:15946:3: ruleRelation { if ( state.backtracking==0 ) { before(grammarAccess.getValueExpressionAccess().getRightRelationParserRuleCall_1_2_0()); @@ -51986,17 +52081,17 @@ public final void rule__ValueExpression__RightAssignment_1_2() throws Recognitio // $ANTLR start "rule__Relation__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:15928:1: rule__Relation__OperatorAssignment_1_1 : ( ruleRelationalOperator ) ; + // InternalBehaviorAnnexParser.g:15955:1: rule__Relation__OperatorAssignment_1_1 : ( ruleRelationalOperator ) ; public final void rule__Relation__OperatorAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15932:1: ( ( ruleRelationalOperator ) ) - // InternalBehaviorAnnexParser.g:15933:2: ( ruleRelationalOperator ) + // InternalBehaviorAnnexParser.g:15959:1: ( ( ruleRelationalOperator ) ) + // InternalBehaviorAnnexParser.g:15960:2: ( ruleRelationalOperator ) { - // InternalBehaviorAnnexParser.g:15933:2: ( ruleRelationalOperator ) - // InternalBehaviorAnnexParser.g:15934:3: ruleRelationalOperator + // InternalBehaviorAnnexParser.g:15960:2: ( ruleRelationalOperator ) + // InternalBehaviorAnnexParser.g:15961:3: ruleRelationalOperator { if ( state.backtracking==0 ) { before(grammarAccess.getRelationAccess().getOperatorRelationalOperatorParserRuleCall_1_1_0()); @@ -52031,17 +52126,17 @@ public final void rule__Relation__OperatorAssignment_1_1() throws RecognitionExc // $ANTLR start "rule__Relation__RightAssignment_1_2" - // InternalBehaviorAnnexParser.g:15943:1: rule__Relation__RightAssignment_1_2 : ( ruleSimpleExpression ) ; + // InternalBehaviorAnnexParser.g:15970:1: rule__Relation__RightAssignment_1_2 : ( ruleSimpleExpression ) ; public final void rule__Relation__RightAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15947:1: ( ( ruleSimpleExpression ) ) - // InternalBehaviorAnnexParser.g:15948:2: ( ruleSimpleExpression ) + // InternalBehaviorAnnexParser.g:15974:1: ( ( ruleSimpleExpression ) ) + // InternalBehaviorAnnexParser.g:15975:2: ( ruleSimpleExpression ) { - // InternalBehaviorAnnexParser.g:15948:2: ( ruleSimpleExpression ) - // InternalBehaviorAnnexParser.g:15949:3: ruleSimpleExpression + // InternalBehaviorAnnexParser.g:15975:2: ( ruleSimpleExpression ) + // InternalBehaviorAnnexParser.g:15976:3: ruleSimpleExpression { if ( state.backtracking==0 ) { before(grammarAccess.getRelationAccess().getRightSimpleExpressionParserRuleCall_1_2_0()); @@ -52076,17 +52171,17 @@ public final void rule__Relation__RightAssignment_1_2() throws RecognitionExcept // $ANTLR start "rule__SimpleExpression__OperatorAssignment_0_0_1" - // InternalBehaviorAnnexParser.g:15958:1: rule__SimpleExpression__OperatorAssignment_0_0_1 : ( ruleUnaryAddingOperator ) ; + // InternalBehaviorAnnexParser.g:15985:1: rule__SimpleExpression__OperatorAssignment_0_0_1 : ( ruleUnaryAddingOperator ) ; public final void rule__SimpleExpression__OperatorAssignment_0_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15962:1: ( ( ruleUnaryAddingOperator ) ) - // InternalBehaviorAnnexParser.g:15963:2: ( ruleUnaryAddingOperator ) + // InternalBehaviorAnnexParser.g:15989:1: ( ( ruleUnaryAddingOperator ) ) + // InternalBehaviorAnnexParser.g:15990:2: ( ruleUnaryAddingOperator ) { - // InternalBehaviorAnnexParser.g:15963:2: ( ruleUnaryAddingOperator ) - // InternalBehaviorAnnexParser.g:15964:3: ruleUnaryAddingOperator + // InternalBehaviorAnnexParser.g:15990:2: ( ruleUnaryAddingOperator ) + // InternalBehaviorAnnexParser.g:15991:3: ruleUnaryAddingOperator { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getOperatorUnaryAddingOperatorParserRuleCall_0_0_1_0()); @@ -52121,17 +52216,17 @@ public final void rule__SimpleExpression__OperatorAssignment_0_0_1() throws Reco // $ANTLR start "rule__SimpleExpression__OperandAssignment_0_0_2" - // InternalBehaviorAnnexParser.g:15973:1: rule__SimpleExpression__OperandAssignment_0_0_2 : ( ruleTerm ) ; + // InternalBehaviorAnnexParser.g:16000:1: rule__SimpleExpression__OperandAssignment_0_0_2 : ( ruleTerm ) ; public final void rule__SimpleExpression__OperandAssignment_0_0_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15977:1: ( ( ruleTerm ) ) - // InternalBehaviorAnnexParser.g:15978:2: ( ruleTerm ) + // InternalBehaviorAnnexParser.g:16004:1: ( ( ruleTerm ) ) + // InternalBehaviorAnnexParser.g:16005:2: ( ruleTerm ) { - // InternalBehaviorAnnexParser.g:15978:2: ( ruleTerm ) - // InternalBehaviorAnnexParser.g:15979:3: ruleTerm + // InternalBehaviorAnnexParser.g:16005:2: ( ruleTerm ) + // InternalBehaviorAnnexParser.g:16006:3: ruleTerm { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getOperandTermParserRuleCall_0_0_2_0()); @@ -52166,17 +52261,17 @@ public final void rule__SimpleExpression__OperandAssignment_0_0_2() throws Recog // $ANTLR start "rule__SimpleExpression__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:15988:1: rule__SimpleExpression__OperatorAssignment_1_1 : ( ruleBinaryAddingOperator ) ; + // InternalBehaviorAnnexParser.g:16015:1: rule__SimpleExpression__OperatorAssignment_1_1 : ( ruleBinaryAddingOperator ) ; public final void rule__SimpleExpression__OperatorAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15992:1: ( ( ruleBinaryAddingOperator ) ) - // InternalBehaviorAnnexParser.g:15993:2: ( ruleBinaryAddingOperator ) + // InternalBehaviorAnnexParser.g:16019:1: ( ( ruleBinaryAddingOperator ) ) + // InternalBehaviorAnnexParser.g:16020:2: ( ruleBinaryAddingOperator ) { - // InternalBehaviorAnnexParser.g:15993:2: ( ruleBinaryAddingOperator ) - // InternalBehaviorAnnexParser.g:15994:3: ruleBinaryAddingOperator + // InternalBehaviorAnnexParser.g:16020:2: ( ruleBinaryAddingOperator ) + // InternalBehaviorAnnexParser.g:16021:3: ruleBinaryAddingOperator { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getOperatorBinaryAddingOperatorParserRuleCall_1_1_0()); @@ -52211,17 +52306,17 @@ public final void rule__SimpleExpression__OperatorAssignment_1_1() throws Recogn // $ANTLR start "rule__SimpleExpression__RightAssignment_1_2" - // InternalBehaviorAnnexParser.g:16003:1: rule__SimpleExpression__RightAssignment_1_2 : ( ruleTerm ) ; + // InternalBehaviorAnnexParser.g:16030:1: rule__SimpleExpression__RightAssignment_1_2 : ( ruleTerm ) ; public final void rule__SimpleExpression__RightAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16007:1: ( ( ruleTerm ) ) - // InternalBehaviorAnnexParser.g:16008:2: ( ruleTerm ) + // InternalBehaviorAnnexParser.g:16034:1: ( ( ruleTerm ) ) + // InternalBehaviorAnnexParser.g:16035:2: ( ruleTerm ) { - // InternalBehaviorAnnexParser.g:16008:2: ( ruleTerm ) - // InternalBehaviorAnnexParser.g:16009:3: ruleTerm + // InternalBehaviorAnnexParser.g:16035:2: ( ruleTerm ) + // InternalBehaviorAnnexParser.g:16036:3: ruleTerm { if ( state.backtracking==0 ) { before(grammarAccess.getSimpleExpressionAccess().getRightTermParserRuleCall_1_2_0()); @@ -52256,17 +52351,17 @@ public final void rule__SimpleExpression__RightAssignment_1_2() throws Recogniti // $ANTLR start "rule__Term__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:16018:1: rule__Term__OperatorAssignment_1_1 : ( ruleMultiplyingOperator ) ; + // InternalBehaviorAnnexParser.g:16045:1: rule__Term__OperatorAssignment_1_1 : ( ruleMultiplyingOperator ) ; public final void rule__Term__OperatorAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16022:1: ( ( ruleMultiplyingOperator ) ) - // InternalBehaviorAnnexParser.g:16023:2: ( ruleMultiplyingOperator ) + // InternalBehaviorAnnexParser.g:16049:1: ( ( ruleMultiplyingOperator ) ) + // InternalBehaviorAnnexParser.g:16050:2: ( ruleMultiplyingOperator ) { - // InternalBehaviorAnnexParser.g:16023:2: ( ruleMultiplyingOperator ) - // InternalBehaviorAnnexParser.g:16024:3: ruleMultiplyingOperator + // InternalBehaviorAnnexParser.g:16050:2: ( ruleMultiplyingOperator ) + // InternalBehaviorAnnexParser.g:16051:3: ruleMultiplyingOperator { if ( state.backtracking==0 ) { before(grammarAccess.getTermAccess().getOperatorMultiplyingOperatorParserRuleCall_1_1_0()); @@ -52301,17 +52396,17 @@ public final void rule__Term__OperatorAssignment_1_1() throws RecognitionExcepti // $ANTLR start "rule__Term__RightAssignment_1_2" - // InternalBehaviorAnnexParser.g:16033:1: rule__Term__RightAssignment_1_2 : ( ruleFactor ) ; + // InternalBehaviorAnnexParser.g:16060:1: rule__Term__RightAssignment_1_2 : ( ruleFactor ) ; public final void rule__Term__RightAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16037:1: ( ( ruleFactor ) ) - // InternalBehaviorAnnexParser.g:16038:2: ( ruleFactor ) + // InternalBehaviorAnnexParser.g:16064:1: ( ( ruleFactor ) ) + // InternalBehaviorAnnexParser.g:16065:2: ( ruleFactor ) { - // InternalBehaviorAnnexParser.g:16038:2: ( ruleFactor ) - // InternalBehaviorAnnexParser.g:16039:3: ruleFactor + // InternalBehaviorAnnexParser.g:16065:2: ( ruleFactor ) + // InternalBehaviorAnnexParser.g:16066:3: ruleFactor { if ( state.backtracking==0 ) { before(grammarAccess.getTermAccess().getRightFactorParserRuleCall_1_2_0()); @@ -52346,17 +52441,17 @@ public final void rule__Term__RightAssignment_1_2() throws RecognitionException // $ANTLR start "rule__Factor__OperatorAssignment_0_1_1" - // InternalBehaviorAnnexParser.g:16048:1: rule__Factor__OperatorAssignment_0_1_1 : ( ruleBinaryNumericOperator ) ; + // InternalBehaviorAnnexParser.g:16075:1: rule__Factor__OperatorAssignment_0_1_1 : ( ruleBinaryNumericOperator ) ; public final void rule__Factor__OperatorAssignment_0_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16052:1: ( ( ruleBinaryNumericOperator ) ) - // InternalBehaviorAnnexParser.g:16053:2: ( ruleBinaryNumericOperator ) + // InternalBehaviorAnnexParser.g:16079:1: ( ( ruleBinaryNumericOperator ) ) + // InternalBehaviorAnnexParser.g:16080:2: ( ruleBinaryNumericOperator ) { - // InternalBehaviorAnnexParser.g:16053:2: ( ruleBinaryNumericOperator ) - // InternalBehaviorAnnexParser.g:16054:3: ruleBinaryNumericOperator + // InternalBehaviorAnnexParser.g:16080:2: ( ruleBinaryNumericOperator ) + // InternalBehaviorAnnexParser.g:16081:3: ruleBinaryNumericOperator { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0()); @@ -52391,17 +52486,17 @@ public final void rule__Factor__OperatorAssignment_0_1_1() throws RecognitionExc // $ANTLR start "rule__Factor__RightAssignment_0_1_2" - // InternalBehaviorAnnexParser.g:16063:1: rule__Factor__RightAssignment_0_1_2 : ( ruleValue ) ; + // InternalBehaviorAnnexParser.g:16090:1: rule__Factor__RightAssignment_0_1_2 : ( ruleValue ) ; public final void rule__Factor__RightAssignment_0_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16067:1: ( ( ruleValue ) ) - // InternalBehaviorAnnexParser.g:16068:2: ( ruleValue ) + // InternalBehaviorAnnexParser.g:16094:1: ( ( ruleValue ) ) + // InternalBehaviorAnnexParser.g:16095:2: ( ruleValue ) { - // InternalBehaviorAnnexParser.g:16068:2: ( ruleValue ) - // InternalBehaviorAnnexParser.g:16069:3: ruleValue + // InternalBehaviorAnnexParser.g:16095:2: ( ruleValue ) + // InternalBehaviorAnnexParser.g:16096:3: ruleValue { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getRightValueParserRuleCall_0_1_2_0()); @@ -52436,17 +52531,17 @@ public final void rule__Factor__RightAssignment_0_1_2() throws RecognitionExcept // $ANTLR start "rule__Factor__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:16078:1: rule__Factor__OperatorAssignment_1_1 : ( ruleUnaryValueOperator ) ; + // InternalBehaviorAnnexParser.g:16105:1: rule__Factor__OperatorAssignment_1_1 : ( ruleUnaryValueOperator ) ; public final void rule__Factor__OperatorAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16082:1: ( ( ruleUnaryValueOperator ) ) - // InternalBehaviorAnnexParser.g:16083:2: ( ruleUnaryValueOperator ) + // InternalBehaviorAnnexParser.g:16109:1: ( ( ruleUnaryValueOperator ) ) + // InternalBehaviorAnnexParser.g:16110:2: ( ruleUnaryValueOperator ) { - // InternalBehaviorAnnexParser.g:16083:2: ( ruleUnaryValueOperator ) - // InternalBehaviorAnnexParser.g:16084:3: ruleUnaryValueOperator + // InternalBehaviorAnnexParser.g:16110:2: ( ruleUnaryValueOperator ) + // InternalBehaviorAnnexParser.g:16111:3: ruleUnaryValueOperator { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getOperatorUnaryValueOperatorParserRuleCall_1_1_0()); @@ -52481,17 +52576,17 @@ public final void rule__Factor__OperatorAssignment_1_1() throws RecognitionExcep // $ANTLR start "rule__Factor__OperandAssignment_1_2" - // InternalBehaviorAnnexParser.g:16093:1: rule__Factor__OperandAssignment_1_2 : ( ruleValue ) ; + // InternalBehaviorAnnexParser.g:16120:1: rule__Factor__OperandAssignment_1_2 : ( ruleValue ) ; public final void rule__Factor__OperandAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16097:1: ( ( ruleValue ) ) - // InternalBehaviorAnnexParser.g:16098:2: ( ruleValue ) + // InternalBehaviorAnnexParser.g:16124:1: ( ( ruleValue ) ) + // InternalBehaviorAnnexParser.g:16125:2: ( ruleValue ) { - // InternalBehaviorAnnexParser.g:16098:2: ( ruleValue ) - // InternalBehaviorAnnexParser.g:16099:3: ruleValue + // InternalBehaviorAnnexParser.g:16125:2: ( ruleValue ) + // InternalBehaviorAnnexParser.g:16126:3: ruleValue { if ( state.backtracking==0 ) { before(grammarAccess.getFactorAccess().getOperandValueParserRuleCall_1_2_0()); @@ -52526,17 +52621,17 @@ public final void rule__Factor__OperandAssignment_1_2() throws RecognitionExcept // $ANTLR start "rule__ParenthesizedExpression__ExpressionAssignment_1" - // InternalBehaviorAnnexParser.g:16108:1: rule__ParenthesizedExpression__ExpressionAssignment_1 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:16135:1: rule__ParenthesizedExpression__ExpressionAssignment_1 : ( ruleValueExpression ) ; public final void rule__ParenthesizedExpression__ExpressionAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16112:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:16113:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:16139:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:16140:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:16113:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:16114:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:16140:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:16141:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getParenthesizedExpressionAccess().getExpressionValueExpressionParserRuleCall_1_0()); @@ -52571,17 +52666,17 @@ public final void rule__ParenthesizedExpression__ExpressionAssignment_1() throws // $ANTLR start "rule__BehaviorIntegerLiteral__ValueAssignment" - // InternalBehaviorAnnexParser.g:16123:1: rule__BehaviorIntegerLiteral__ValueAssignment : ( RULE_INTEGER_LIT ) ; + // InternalBehaviorAnnexParser.g:16150:1: rule__BehaviorIntegerLiteral__ValueAssignment : ( RULE_INTEGER_LIT ) ; public final void rule__BehaviorIntegerLiteral__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16127:1: ( ( RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:16128:2: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:16154:1: ( ( RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:16155:2: ( RULE_INTEGER_LIT ) { - // InternalBehaviorAnnexParser.g:16128:2: ( RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:16129:3: RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:16155:2: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:16156:3: RULE_INTEGER_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorIntegerLiteralAccess().getValueINTEGER_LITTerminalRuleCall_0()); @@ -52612,17 +52707,17 @@ public final void rule__BehaviorIntegerLiteral__ValueAssignment() throws Recogni // $ANTLR start "rule__BehaviorRealLiteral__ValueAssignment" - // InternalBehaviorAnnexParser.g:16138:1: rule__BehaviorRealLiteral__ValueAssignment : ( RULE_REAL_LIT ) ; + // InternalBehaviorAnnexParser.g:16165:1: rule__BehaviorRealLiteral__ValueAssignment : ( RULE_REAL_LIT ) ; public final void rule__BehaviorRealLiteral__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16142:1: ( ( RULE_REAL_LIT ) ) - // InternalBehaviorAnnexParser.g:16143:2: ( RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:16169:1: ( ( RULE_REAL_LIT ) ) + // InternalBehaviorAnnexParser.g:16170:2: ( RULE_REAL_LIT ) { - // InternalBehaviorAnnexParser.g:16143:2: ( RULE_REAL_LIT ) - // InternalBehaviorAnnexParser.g:16144:3: RULE_REAL_LIT + // InternalBehaviorAnnexParser.g:16170:2: ( RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:16171:3: RULE_REAL_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorRealLiteralAccess().getValueREAL_LITTerminalRuleCall_0()); @@ -52653,17 +52748,17 @@ public final void rule__BehaviorRealLiteral__ValueAssignment() throws Recognitio // $ANTLR start "rule__BehaviorStringLiteral__ValueAssignment" - // InternalBehaviorAnnexParser.g:16153:1: rule__BehaviorStringLiteral__ValueAssignment : ( RULE_STRING ) ; + // InternalBehaviorAnnexParser.g:16180:1: rule__BehaviorStringLiteral__ValueAssignment : ( RULE_STRING ) ; public final void rule__BehaviorStringLiteral__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16157:1: ( ( RULE_STRING ) ) - // InternalBehaviorAnnexParser.g:16158:2: ( RULE_STRING ) + // InternalBehaviorAnnexParser.g:16184:1: ( ( RULE_STRING ) ) + // InternalBehaviorAnnexParser.g:16185:2: ( RULE_STRING ) { - // InternalBehaviorAnnexParser.g:16158:2: ( RULE_STRING ) - // InternalBehaviorAnnexParser.g:16159:3: RULE_STRING + // InternalBehaviorAnnexParser.g:16185:2: ( RULE_STRING ) + // InternalBehaviorAnnexParser.g:16186:3: RULE_STRING { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); @@ -52694,23 +52789,23 @@ public final void rule__BehaviorStringLiteral__ValueAssignment() throws Recognit // $ANTLR start "rule__BehaviorBooleanLiteral__ValueAssignment_1_0" - // InternalBehaviorAnnexParser.g:16168:1: rule__BehaviorBooleanLiteral__ValueAssignment_1_0 : ( ( True ) ) ; + // InternalBehaviorAnnexParser.g:16195:1: rule__BehaviorBooleanLiteral__ValueAssignment_1_0 : ( ( True ) ) ; public final void rule__BehaviorBooleanLiteral__ValueAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16172:1: ( ( ( True ) ) ) - // InternalBehaviorAnnexParser.g:16173:2: ( ( True ) ) + // InternalBehaviorAnnexParser.g:16199:1: ( ( ( True ) ) ) + // InternalBehaviorAnnexParser.g:16200:2: ( ( True ) ) { - // InternalBehaviorAnnexParser.g:16173:2: ( ( True ) ) - // InternalBehaviorAnnexParser.g:16174:3: ( True ) + // InternalBehaviorAnnexParser.g:16200:2: ( ( True ) ) + // InternalBehaviorAnnexParser.g:16201:3: ( True ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getValueTrueKeyword_1_0_0()); } - // InternalBehaviorAnnexParser.g:16175:3: ( True ) - // InternalBehaviorAnnexParser.g:16176:4: True + // InternalBehaviorAnnexParser.g:16202:3: ( True ) + // InternalBehaviorAnnexParser.g:16203:4: True { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getValueTrueKeyword_1_0_0()); @@ -52747,17 +52842,17 @@ public final void rule__BehaviorBooleanLiteral__ValueAssignment_1_0() throws Rec // $ANTLR start "rule__ReferenceExpression__ReferenceAssignment_0" - // InternalBehaviorAnnexParser.g:16187:1: rule__ReferenceExpression__ReferenceAssignment_0 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:16214:1: rule__ReferenceExpression__ReferenceAssignment_0 : ( ruleReference ) ; public final void rule__ReferenceExpression__ReferenceAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16191:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:16192:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:16218:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:16219:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:16192:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:16193:3: ruleReference + // InternalBehaviorAnnexParser.g:16219:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:16220:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getReferenceReferenceParserRuleCall_0_0()); @@ -52792,17 +52887,17 @@ public final void rule__ReferenceExpression__ReferenceAssignment_0() throws Reco // $ANTLR start "rule__ReferenceExpression__PropertyAssignment_1_0" - // InternalBehaviorAnnexParser.g:16202:1: rule__ReferenceExpression__PropertyAssignment_1_0 : ( rulePropertyReferenceTail ) ; + // InternalBehaviorAnnexParser.g:16229:1: rule__ReferenceExpression__PropertyAssignment_1_0 : ( rulePropertyReferenceTail ) ; public final void rule__ReferenceExpression__PropertyAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16206:1: ( ( rulePropertyReferenceTail ) ) - // InternalBehaviorAnnexParser.g:16207:2: ( rulePropertyReferenceTail ) + // InternalBehaviorAnnexParser.g:16233:1: ( ( rulePropertyReferenceTail ) ) + // InternalBehaviorAnnexParser.g:16234:2: ( rulePropertyReferenceTail ) { - // InternalBehaviorAnnexParser.g:16207:2: ( rulePropertyReferenceTail ) - // InternalBehaviorAnnexParser.g:16208:3: rulePropertyReferenceTail + // InternalBehaviorAnnexParser.g:16234:2: ( rulePropertyReferenceTail ) + // InternalBehaviorAnnexParser.g:16235:3: rulePropertyReferenceTail { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getPropertyPropertyReferenceTailParserRuleCall_1_0_0()); @@ -52837,23 +52932,23 @@ public final void rule__ReferenceExpression__PropertyAssignment_1_0() throws Rec // $ANTLR start "rule__ReferenceExpression__DequeueAssignment_1_1" - // InternalBehaviorAnnexParser.g:16217:1: rule__ReferenceExpression__DequeueAssignment_1_1 : ( ( QuestionMark ) ) ; + // InternalBehaviorAnnexParser.g:16244:1: rule__ReferenceExpression__DequeueAssignment_1_1 : ( ( QuestionMark ) ) ; public final void rule__ReferenceExpression__DequeueAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16221:1: ( ( ( QuestionMark ) ) ) - // InternalBehaviorAnnexParser.g:16222:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:16248:1: ( ( ( QuestionMark ) ) ) + // InternalBehaviorAnnexParser.g:16249:2: ( ( QuestionMark ) ) { - // InternalBehaviorAnnexParser.g:16222:2: ( ( QuestionMark ) ) - // InternalBehaviorAnnexParser.g:16223:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:16249:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:16250:3: ( QuestionMark ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getDequeueQuestionMarkKeyword_1_1_0()); } - // InternalBehaviorAnnexParser.g:16224:3: ( QuestionMark ) - // InternalBehaviorAnnexParser.g:16225:4: QuestionMark + // InternalBehaviorAnnexParser.g:16251:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:16252:4: QuestionMark { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getDequeueQuestionMarkKeyword_1_1_0()); @@ -52890,23 +52985,23 @@ public final void rule__ReferenceExpression__DequeueAssignment_1_1() throws Reco // $ANTLR start "rule__ReferenceExpression__CountAssignment_1_2_1_0" - // InternalBehaviorAnnexParser.g:16236:1: rule__ReferenceExpression__CountAssignment_1_2_1_0 : ( ( Count ) ) ; + // InternalBehaviorAnnexParser.g:16263:1: rule__ReferenceExpression__CountAssignment_1_2_1_0 : ( ( Count ) ) ; public final void rule__ReferenceExpression__CountAssignment_1_2_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16240:1: ( ( ( Count ) ) ) - // InternalBehaviorAnnexParser.g:16241:2: ( ( Count ) ) + // InternalBehaviorAnnexParser.g:16267:1: ( ( ( Count ) ) ) + // InternalBehaviorAnnexParser.g:16268:2: ( ( Count ) ) { - // InternalBehaviorAnnexParser.g:16241:2: ( ( Count ) ) - // InternalBehaviorAnnexParser.g:16242:3: ( Count ) + // InternalBehaviorAnnexParser.g:16268:2: ( ( Count ) ) + // InternalBehaviorAnnexParser.g:16269:3: ( Count ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getCountCountKeyword_1_2_1_0_0()); } - // InternalBehaviorAnnexParser.g:16243:3: ( Count ) - // InternalBehaviorAnnexParser.g:16244:4: Count + // InternalBehaviorAnnexParser.g:16270:3: ( Count ) + // InternalBehaviorAnnexParser.g:16271:4: Count { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getCountCountKeyword_1_2_1_0_0()); @@ -52943,23 +53038,23 @@ public final void rule__ReferenceExpression__CountAssignment_1_2_1_0() throws Re // $ANTLR start "rule__ReferenceExpression__FreshAssignment_1_2_1_1" - // InternalBehaviorAnnexParser.g:16255:1: rule__ReferenceExpression__FreshAssignment_1_2_1_1 : ( ( Fresh ) ) ; + // InternalBehaviorAnnexParser.g:16282:1: rule__ReferenceExpression__FreshAssignment_1_2_1_1 : ( ( Fresh ) ) ; public final void rule__ReferenceExpression__FreshAssignment_1_2_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16259:1: ( ( ( Fresh ) ) ) - // InternalBehaviorAnnexParser.g:16260:2: ( ( Fresh ) ) + // InternalBehaviorAnnexParser.g:16286:1: ( ( ( Fresh ) ) ) + // InternalBehaviorAnnexParser.g:16287:2: ( ( Fresh ) ) { - // InternalBehaviorAnnexParser.g:16260:2: ( ( Fresh ) ) - // InternalBehaviorAnnexParser.g:16261:3: ( Fresh ) + // InternalBehaviorAnnexParser.g:16287:2: ( ( Fresh ) ) + // InternalBehaviorAnnexParser.g:16288:3: ( Fresh ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getFreshFreshKeyword_1_2_1_1_0()); } - // InternalBehaviorAnnexParser.g:16262:3: ( Fresh ) - // InternalBehaviorAnnexParser.g:16263:4: Fresh + // InternalBehaviorAnnexParser.g:16289:3: ( Fresh ) + // InternalBehaviorAnnexParser.g:16290:4: Fresh { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getFreshFreshKeyword_1_2_1_1_0()); @@ -52996,23 +53091,23 @@ public final void rule__ReferenceExpression__FreshAssignment_1_2_1_1() throws Re // $ANTLR start "rule__ReferenceExpression__UpdatedAssignment_1_2_1_2" - // InternalBehaviorAnnexParser.g:16274:1: rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 : ( ( Updated ) ) ; + // InternalBehaviorAnnexParser.g:16301:1: rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 : ( ( Updated ) ) ; public final void rule__ReferenceExpression__UpdatedAssignment_1_2_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16278:1: ( ( ( Updated ) ) ) - // InternalBehaviorAnnexParser.g:16279:2: ( ( Updated ) ) + // InternalBehaviorAnnexParser.g:16305:1: ( ( ( Updated ) ) ) + // InternalBehaviorAnnexParser.g:16306:2: ( ( Updated ) ) { - // InternalBehaviorAnnexParser.g:16279:2: ( ( Updated ) ) - // InternalBehaviorAnnexParser.g:16280:3: ( Updated ) + // InternalBehaviorAnnexParser.g:16306:2: ( ( Updated ) ) + // InternalBehaviorAnnexParser.g:16307:3: ( Updated ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getUpdatedUpdatedKeyword_1_2_1_2_0()); } - // InternalBehaviorAnnexParser.g:16281:3: ( Updated ) - // InternalBehaviorAnnexParser.g:16282:4: Updated + // InternalBehaviorAnnexParser.g:16308:3: ( Updated ) + // InternalBehaviorAnnexParser.g:16309:4: Updated { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getUpdatedUpdatedKeyword_1_2_1_2_0()); @@ -53049,17 +53144,17 @@ public final void rule__ReferenceExpression__UpdatedAssignment_1_2_1_2() throws // $ANTLR start "rule__HashPropertyReference__PropertyAssignment_1" - // InternalBehaviorAnnexParser.g:16293:1: rule__HashPropertyReference__PropertyAssignment_1 : ( ruleQualifiedName ) ; + // InternalBehaviorAnnexParser.g:16320:1: rule__HashPropertyReference__PropertyAssignment_1 : ( ruleQualifiedName ) ; public final void rule__HashPropertyReference__PropertyAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16297:1: ( ( ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:16298:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16324:1: ( ( ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:16325:2: ( ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:16298:2: ( ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:16299:3: ruleQualifiedName + // InternalBehaviorAnnexParser.g:16325:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16326:3: ruleQualifiedName { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getPropertyQualifiedNameParserRuleCall_1_0()); @@ -53094,17 +53189,17 @@ public final void rule__HashPropertyReference__PropertyAssignment_1() throws Rec // $ANTLR start "rule__HashPropertyReference__IndexesAssignment_2" - // InternalBehaviorAnnexParser.g:16308:1: rule__HashPropertyReference__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; + // InternalBehaviorAnnexParser.g:16335:1: rule__HashPropertyReference__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; public final void rule__HashPropertyReference__IndexesAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16312:1: ( ( rulePropertyArrayIndex ) ) - // InternalBehaviorAnnexParser.g:16313:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16339:1: ( ( rulePropertyArrayIndex ) ) + // InternalBehaviorAnnexParser.g:16340:2: ( rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:16313:2: ( rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:16314:3: rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:16340:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16341:3: rulePropertyArrayIndex { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getIndexesPropertyArrayIndexParserRuleCall_2_0()); @@ -53139,17 +53234,17 @@ public final void rule__HashPropertyReference__IndexesAssignment_2() throws Reco // $ANTLR start "rule__HashPropertyReference__FieldsAssignment_3" - // InternalBehaviorAnnexParser.g:16323:1: rule__HashPropertyReference__FieldsAssignment_3 : ( ruleNamedPropertyField ) ; + // InternalBehaviorAnnexParser.g:16350:1: rule__HashPropertyReference__FieldsAssignment_3 : ( ruleNamedPropertyField ) ; public final void rule__HashPropertyReference__FieldsAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16327:1: ( ( ruleNamedPropertyField ) ) - // InternalBehaviorAnnexParser.g:16328:2: ( ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:16354:1: ( ( ruleNamedPropertyField ) ) + // InternalBehaviorAnnexParser.g:16355:2: ( ruleNamedPropertyField ) { - // InternalBehaviorAnnexParser.g:16328:2: ( ruleNamedPropertyField ) - // InternalBehaviorAnnexParser.g:16329:3: ruleNamedPropertyField + // InternalBehaviorAnnexParser.g:16355:2: ( ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:16356:3: ruleNamedPropertyField { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getFieldsNamedPropertyFieldParserRuleCall_3_0()); @@ -53184,17 +53279,17 @@ public final void rule__HashPropertyReference__FieldsAssignment_3() throws Recog // $ANTLR start "rule__PropertyReferenceTail__PropertyAssignment_1" - // InternalBehaviorAnnexParser.g:16338:1: rule__PropertyReferenceTail__PropertyAssignment_1 : ( ruleQualifiedName ) ; + // InternalBehaviorAnnexParser.g:16365:1: rule__PropertyReferenceTail__PropertyAssignment_1 : ( ruleQualifiedName ) ; public final void rule__PropertyReferenceTail__PropertyAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16342:1: ( ( ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:16343:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16369:1: ( ( ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:16370:2: ( ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:16343:2: ( ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:16344:3: ruleQualifiedName + // InternalBehaviorAnnexParser.g:16370:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16371:3: ruleQualifiedName { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getPropertyQualifiedNameParserRuleCall_1_0()); @@ -53229,17 +53324,17 @@ public final void rule__PropertyReferenceTail__PropertyAssignment_1() throws Rec // $ANTLR start "rule__PropertyReferenceTail__IndexesAssignment_2" - // InternalBehaviorAnnexParser.g:16353:1: rule__PropertyReferenceTail__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; + // InternalBehaviorAnnexParser.g:16380:1: rule__PropertyReferenceTail__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; public final void rule__PropertyReferenceTail__IndexesAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16357:1: ( ( rulePropertyArrayIndex ) ) - // InternalBehaviorAnnexParser.g:16358:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16384:1: ( ( rulePropertyArrayIndex ) ) + // InternalBehaviorAnnexParser.g:16385:2: ( rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:16358:2: ( rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:16359:3: rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:16385:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16386:3: rulePropertyArrayIndex { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getIndexesPropertyArrayIndexParserRuleCall_2_0()); @@ -53274,17 +53369,17 @@ public final void rule__PropertyReferenceTail__IndexesAssignment_2() throws Reco // $ANTLR start "rule__PropertyReferenceTail__FieldsAssignment_3" - // InternalBehaviorAnnexParser.g:16368:1: rule__PropertyReferenceTail__FieldsAssignment_3 : ( ruleNamedPropertyField ) ; + // InternalBehaviorAnnexParser.g:16395:1: rule__PropertyReferenceTail__FieldsAssignment_3 : ( ruleNamedPropertyField ) ; public final void rule__PropertyReferenceTail__FieldsAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16372:1: ( ( ruleNamedPropertyField ) ) - // InternalBehaviorAnnexParser.g:16373:2: ( ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:16399:1: ( ( ruleNamedPropertyField ) ) + // InternalBehaviorAnnexParser.g:16400:2: ( ruleNamedPropertyField ) { - // InternalBehaviorAnnexParser.g:16373:2: ( ruleNamedPropertyField ) - // InternalBehaviorAnnexParser.g:16374:3: ruleNamedPropertyField + // InternalBehaviorAnnexParser.g:16400:2: ( ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:16401:3: ruleNamedPropertyField { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getFieldsNamedPropertyFieldParserRuleCall_3_0()); @@ -53319,17 +53414,17 @@ public final void rule__PropertyReferenceTail__FieldsAssignment_3() throws Recog // $ANTLR start "rule__NamedPropertyField__NameAssignment_1" - // InternalBehaviorAnnexParser.g:16383:1: rule__NamedPropertyField__NameAssignment_1 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:16410:1: rule__NamedPropertyField__NameAssignment_1 : ( RULE_ID ) ; public final void rule__NamedPropertyField__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16387:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16388:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16414:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16415:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:16388:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16389:3: RULE_ID + // InternalBehaviorAnnexParser.g:16415:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16416:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getNameIDTerminalRuleCall_1_0()); @@ -53360,17 +53455,17 @@ public final void rule__NamedPropertyField__NameAssignment_1() throws Recognitio // $ANTLR start "rule__NamedPropertyField__IndexesAssignment_2" - // InternalBehaviorAnnexParser.g:16398:1: rule__NamedPropertyField__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; + // InternalBehaviorAnnexParser.g:16425:1: rule__NamedPropertyField__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; public final void rule__NamedPropertyField__IndexesAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16402:1: ( ( rulePropertyArrayIndex ) ) - // InternalBehaviorAnnexParser.g:16403:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16429:1: ( ( rulePropertyArrayIndex ) ) + // InternalBehaviorAnnexParser.g:16430:2: ( rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:16403:2: ( rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:16404:3: rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:16430:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16431:3: rulePropertyArrayIndex { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getIndexesPropertyArrayIndexParserRuleCall_2_0()); @@ -53405,17 +53500,17 @@ public final void rule__NamedPropertyField__IndexesAssignment_2() throws Recogni // $ANTLR start "rule__PropertyArrayIndex__ValueAssignment_1" - // InternalBehaviorAnnexParser.g:16413:1: rule__PropertyArrayIndex__ValueAssignment_1 : ( rulePropertyIndexValue ) ; + // InternalBehaviorAnnexParser.g:16440:1: rule__PropertyArrayIndex__ValueAssignment_1 : ( rulePropertyIndexValue ) ; public final void rule__PropertyArrayIndex__ValueAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16417:1: ( ( rulePropertyIndexValue ) ) - // InternalBehaviorAnnexParser.g:16418:2: ( rulePropertyIndexValue ) + // InternalBehaviorAnnexParser.g:16444:1: ( ( rulePropertyIndexValue ) ) + // InternalBehaviorAnnexParser.g:16445:2: ( rulePropertyIndexValue ) { - // InternalBehaviorAnnexParser.g:16418:2: ( rulePropertyIndexValue ) - // InternalBehaviorAnnexParser.g:16419:3: rulePropertyIndexValue + // InternalBehaviorAnnexParser.g:16445:2: ( rulePropertyIndexValue ) + // InternalBehaviorAnnexParser.g:16446:3: rulePropertyIndexValue { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyArrayIndexAccess().getValuePropertyIndexValueParserRuleCall_1_0()); @@ -53450,17 +53545,17 @@ public final void rule__PropertyArrayIndex__ValueAssignment_1() throws Recogniti // $ANTLR start "rule__PropertyIndexPropertyReference__PropertyAssignment_1" - // InternalBehaviorAnnexParser.g:16428:1: rule__PropertyIndexPropertyReference__PropertyAssignment_1 : ( ruleQualifiedName ) ; + // InternalBehaviorAnnexParser.g:16455:1: rule__PropertyIndexPropertyReference__PropertyAssignment_1 : ( ruleQualifiedName ) ; public final void rule__PropertyIndexPropertyReference__PropertyAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16432:1: ( ( ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:16433:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16459:1: ( ( ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:16460:2: ( ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:16433:2: ( ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:16434:3: ruleQualifiedName + // InternalBehaviorAnnexParser.g:16460:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16461:3: ruleQualifiedName { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexPropertyReferenceAccess().getPropertyQualifiedNameParserRuleCall_1_0()); @@ -53495,17 +53590,17 @@ public final void rule__PropertyIndexPropertyReference__PropertyAssignment_1() t // $ANTLR start "rule__UnindexedReferenceExpression__ReferenceAssignment_0" - // InternalBehaviorAnnexParser.g:16443:1: rule__UnindexedReferenceExpression__ReferenceAssignment_0 : ( ruleUnindexedReference ) ; + // InternalBehaviorAnnexParser.g:16470:1: rule__UnindexedReferenceExpression__ReferenceAssignment_0 : ( ruleUnindexedReference ) ; public final void rule__UnindexedReferenceExpression__ReferenceAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16447:1: ( ( ruleUnindexedReference ) ) - // InternalBehaviorAnnexParser.g:16448:2: ( ruleUnindexedReference ) + // InternalBehaviorAnnexParser.g:16474:1: ( ( ruleUnindexedReference ) ) + // InternalBehaviorAnnexParser.g:16475:2: ( ruleUnindexedReference ) { - // InternalBehaviorAnnexParser.g:16448:2: ( ruleUnindexedReference ) - // InternalBehaviorAnnexParser.g:16449:3: ruleUnindexedReference + // InternalBehaviorAnnexParser.g:16475:2: ( ruleUnindexedReference ) + // InternalBehaviorAnnexParser.g:16476:3: ruleUnindexedReference { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getReferenceUnindexedReferenceParserRuleCall_0_0()); @@ -53540,23 +53635,23 @@ public final void rule__UnindexedReferenceExpression__ReferenceAssignment_0() th // $ANTLR start "rule__UnindexedReferenceExpression__DequeueAssignment_1_0" - // InternalBehaviorAnnexParser.g:16458:1: rule__UnindexedReferenceExpression__DequeueAssignment_1_0 : ( ( QuestionMark ) ) ; + // InternalBehaviorAnnexParser.g:16485:1: rule__UnindexedReferenceExpression__DequeueAssignment_1_0 : ( ( QuestionMark ) ) ; public final void rule__UnindexedReferenceExpression__DequeueAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16462:1: ( ( ( QuestionMark ) ) ) - // InternalBehaviorAnnexParser.g:16463:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:16489:1: ( ( ( QuestionMark ) ) ) + // InternalBehaviorAnnexParser.g:16490:2: ( ( QuestionMark ) ) { - // InternalBehaviorAnnexParser.g:16463:2: ( ( QuestionMark ) ) - // InternalBehaviorAnnexParser.g:16464:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:16490:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:16491:3: ( QuestionMark ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getDequeueQuestionMarkKeyword_1_0_0()); } - // InternalBehaviorAnnexParser.g:16465:3: ( QuestionMark ) - // InternalBehaviorAnnexParser.g:16466:4: QuestionMark + // InternalBehaviorAnnexParser.g:16492:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:16493:4: QuestionMark { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getDequeueQuestionMarkKeyword_1_0_0()); @@ -53593,23 +53688,23 @@ public final void rule__UnindexedReferenceExpression__DequeueAssignment_1_0() th // $ANTLR start "rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0" - // InternalBehaviorAnnexParser.g:16477:1: rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 : ( ( Count ) ) ; + // InternalBehaviorAnnexParser.g:16504:1: rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 : ( ( Count ) ) ; public final void rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16481:1: ( ( ( Count ) ) ) - // InternalBehaviorAnnexParser.g:16482:2: ( ( Count ) ) + // InternalBehaviorAnnexParser.g:16508:1: ( ( ( Count ) ) ) + // InternalBehaviorAnnexParser.g:16509:2: ( ( Count ) ) { - // InternalBehaviorAnnexParser.g:16482:2: ( ( Count ) ) - // InternalBehaviorAnnexParser.g:16483:3: ( Count ) + // InternalBehaviorAnnexParser.g:16509:2: ( ( Count ) ) + // InternalBehaviorAnnexParser.g:16510:3: ( Count ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getCountCountKeyword_1_1_1_0_0()); } - // InternalBehaviorAnnexParser.g:16484:3: ( Count ) - // InternalBehaviorAnnexParser.g:16485:4: Count + // InternalBehaviorAnnexParser.g:16511:3: ( Count ) + // InternalBehaviorAnnexParser.g:16512:4: Count { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getCountCountKeyword_1_1_1_0_0()); @@ -53646,23 +53741,23 @@ public final void rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0() // $ANTLR start "rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1" - // InternalBehaviorAnnexParser.g:16496:1: rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 : ( ( Fresh ) ) ; + // InternalBehaviorAnnexParser.g:16523:1: rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 : ( ( Fresh ) ) ; public final void rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16500:1: ( ( ( Fresh ) ) ) - // InternalBehaviorAnnexParser.g:16501:2: ( ( Fresh ) ) + // InternalBehaviorAnnexParser.g:16527:1: ( ( ( Fresh ) ) ) + // InternalBehaviorAnnexParser.g:16528:2: ( ( Fresh ) ) { - // InternalBehaviorAnnexParser.g:16501:2: ( ( Fresh ) ) - // InternalBehaviorAnnexParser.g:16502:3: ( Fresh ) + // InternalBehaviorAnnexParser.g:16528:2: ( ( Fresh ) ) + // InternalBehaviorAnnexParser.g:16529:3: ( Fresh ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getFreshFreshKeyword_1_1_1_1_0()); } - // InternalBehaviorAnnexParser.g:16503:3: ( Fresh ) - // InternalBehaviorAnnexParser.g:16504:4: Fresh + // InternalBehaviorAnnexParser.g:16530:3: ( Fresh ) + // InternalBehaviorAnnexParser.g:16531:4: Fresh { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getFreshFreshKeyword_1_1_1_1_0()); @@ -53699,23 +53794,23 @@ public final void rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1() // $ANTLR start "rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2" - // InternalBehaviorAnnexParser.g:16515:1: rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 : ( ( Updated ) ) ; + // InternalBehaviorAnnexParser.g:16542:1: rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 : ( ( Updated ) ) ; public final void rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16519:1: ( ( ( Updated ) ) ) - // InternalBehaviorAnnexParser.g:16520:2: ( ( Updated ) ) + // InternalBehaviorAnnexParser.g:16546:1: ( ( ( Updated ) ) ) + // InternalBehaviorAnnexParser.g:16547:2: ( ( Updated ) ) { - // InternalBehaviorAnnexParser.g:16520:2: ( ( Updated ) ) - // InternalBehaviorAnnexParser.g:16521:3: ( Updated ) + // InternalBehaviorAnnexParser.g:16547:2: ( ( Updated ) ) + // InternalBehaviorAnnexParser.g:16548:3: ( Updated ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getUpdatedUpdatedKeyword_1_1_1_2_0()); } - // InternalBehaviorAnnexParser.g:16522:3: ( Updated ) - // InternalBehaviorAnnexParser.g:16523:4: Updated + // InternalBehaviorAnnexParser.g:16549:3: ( Updated ) + // InternalBehaviorAnnexParser.g:16550:4: Updated { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getUpdatedUpdatedKeyword_1_1_1_2_0()); @@ -53752,17 +53847,17 @@ public final void rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2( // $ANTLR start "rule__UnindexedReference__SegmentsAssignment_0" - // InternalBehaviorAnnexParser.g:16534:1: rule__UnindexedReference__SegmentsAssignment_0 : ( ruleUnindexedReferenceSegment ) ; + // InternalBehaviorAnnexParser.g:16561:1: rule__UnindexedReference__SegmentsAssignment_0 : ( ruleUnindexedReferenceSegment ) ; public final void rule__UnindexedReference__SegmentsAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16538:1: ( ( ruleUnindexedReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:16539:2: ( ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:16565:1: ( ( ruleUnindexedReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:16566:2: ( ruleUnindexedReferenceSegment ) { - // InternalBehaviorAnnexParser.g:16539:2: ( ruleUnindexedReferenceSegment ) - // InternalBehaviorAnnexParser.g:16540:3: ruleUnindexedReferenceSegment + // InternalBehaviorAnnexParser.g:16566:2: ( ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:16567:3: ruleUnindexedReferenceSegment { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceAccess().getSegmentsUnindexedReferenceSegmentParserRuleCall_0_0()); @@ -53797,17 +53892,17 @@ public final void rule__UnindexedReference__SegmentsAssignment_0() throws Recogn // $ANTLR start "rule__UnindexedReference__TailsAssignment_1" - // InternalBehaviorAnnexParser.g:16549:1: rule__UnindexedReference__TailsAssignment_1 : ( ruleUnindexedReferenceTail ) ; + // InternalBehaviorAnnexParser.g:16576:1: rule__UnindexedReference__TailsAssignment_1 : ( ruleUnindexedReferenceTail ) ; public final void rule__UnindexedReference__TailsAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16553:1: ( ( ruleUnindexedReferenceTail ) ) - // InternalBehaviorAnnexParser.g:16554:2: ( ruleUnindexedReferenceTail ) + // InternalBehaviorAnnexParser.g:16580:1: ( ( ruleUnindexedReferenceTail ) ) + // InternalBehaviorAnnexParser.g:16581:2: ( ruleUnindexedReferenceTail ) { - // InternalBehaviorAnnexParser.g:16554:2: ( ruleUnindexedReferenceTail ) - // InternalBehaviorAnnexParser.g:16555:3: ruleUnindexedReferenceTail + // InternalBehaviorAnnexParser.g:16581:2: ( ruleUnindexedReferenceTail ) + // InternalBehaviorAnnexParser.g:16582:3: ruleUnindexedReferenceTail { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceAccess().getTailsUnindexedReferenceTailParserRuleCall_1_0()); @@ -53842,17 +53937,17 @@ public final void rule__UnindexedReference__TailsAssignment_1() throws Recogniti // $ANTLR start "rule__UnindexedReferenceTail__SeparatorAssignment_0" - // InternalBehaviorAnnexParser.g:16564:1: rule__UnindexedReferenceTail__SeparatorAssignment_0 : ( ruleReferenceSeparator ) ; + // InternalBehaviorAnnexParser.g:16591:1: rule__UnindexedReferenceTail__SeparatorAssignment_0 : ( ruleReferenceSeparator ) ; public final void rule__UnindexedReferenceTail__SeparatorAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16568:1: ( ( ruleReferenceSeparator ) ) - // InternalBehaviorAnnexParser.g:16569:2: ( ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:16595:1: ( ( ruleReferenceSeparator ) ) + // InternalBehaviorAnnexParser.g:16596:2: ( ruleReferenceSeparator ) { - // InternalBehaviorAnnexParser.g:16569:2: ( ruleReferenceSeparator ) - // InternalBehaviorAnnexParser.g:16570:3: ruleReferenceSeparator + // InternalBehaviorAnnexParser.g:16596:2: ( ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:16597:3: ruleReferenceSeparator { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceTailAccess().getSeparatorReferenceSeparatorParserRuleCall_0_0()); @@ -53887,17 +53982,17 @@ public final void rule__UnindexedReferenceTail__SeparatorAssignment_0() throws R // $ANTLR start "rule__UnindexedReferenceTail__SegmentAssignment_1" - // InternalBehaviorAnnexParser.g:16579:1: rule__UnindexedReferenceTail__SegmentAssignment_1 : ( ruleUnindexedReferenceSegment ) ; + // InternalBehaviorAnnexParser.g:16606:1: rule__UnindexedReferenceTail__SegmentAssignment_1 : ( ruleUnindexedReferenceSegment ) ; public final void rule__UnindexedReferenceTail__SegmentAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16583:1: ( ( ruleUnindexedReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:16584:2: ( ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:16610:1: ( ( ruleUnindexedReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:16611:2: ( ruleUnindexedReferenceSegment ) { - // InternalBehaviorAnnexParser.g:16584:2: ( ruleUnindexedReferenceSegment ) - // InternalBehaviorAnnexParser.g:16585:3: ruleUnindexedReferenceSegment + // InternalBehaviorAnnexParser.g:16611:2: ( ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:16612:3: ruleUnindexedReferenceSegment { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceTailAccess().getSegmentUnindexedReferenceSegmentParserRuleCall_1_0()); @@ -53932,17 +54027,17 @@ public final void rule__UnindexedReferenceTail__SegmentAssignment_1() throws Rec // $ANTLR start "rule__UnindexedReferenceSegment__NameAssignment" - // InternalBehaviorAnnexParser.g:16594:1: rule__UnindexedReferenceSegment__NameAssignment : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:16621:1: rule__UnindexedReferenceSegment__NameAssignment : ( RULE_ID ) ; public final void rule__UnindexedReferenceSegment__NameAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16598:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16599:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16625:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16626:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:16599:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16600:3: RULE_ID + // InternalBehaviorAnnexParser.g:16626:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16627:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceSegmentAccess().getNameIDTerminalRuleCall_0()); @@ -53973,17 +54068,17 @@ public final void rule__UnindexedReferenceSegment__NameAssignment() throws Recog // $ANTLR start "rule__Reference__SegmentsAssignment_0" - // InternalBehaviorAnnexParser.g:16609:1: rule__Reference__SegmentsAssignment_0 : ( ruleReferenceSegment ) ; + // InternalBehaviorAnnexParser.g:16636:1: rule__Reference__SegmentsAssignment_0 : ( ruleReferenceSegment ) ; public final void rule__Reference__SegmentsAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16613:1: ( ( ruleReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:16614:2: ( ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:16640:1: ( ( ruleReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:16641:2: ( ruleReferenceSegment ) { - // InternalBehaviorAnnexParser.g:16614:2: ( ruleReferenceSegment ) - // InternalBehaviorAnnexParser.g:16615:3: ruleReferenceSegment + // InternalBehaviorAnnexParser.g:16641:2: ( ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:16642:3: ruleReferenceSegment { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceAccess().getSegmentsReferenceSegmentParserRuleCall_0_0()); @@ -54018,17 +54113,17 @@ public final void rule__Reference__SegmentsAssignment_0() throws RecognitionExce // $ANTLR start "rule__Reference__TailsAssignment_1" - // InternalBehaviorAnnexParser.g:16624:1: rule__Reference__TailsAssignment_1 : ( ruleReferenceTail ) ; + // InternalBehaviorAnnexParser.g:16651:1: rule__Reference__TailsAssignment_1 : ( ruleReferenceTail ) ; public final void rule__Reference__TailsAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16628:1: ( ( ruleReferenceTail ) ) - // InternalBehaviorAnnexParser.g:16629:2: ( ruleReferenceTail ) + // InternalBehaviorAnnexParser.g:16655:1: ( ( ruleReferenceTail ) ) + // InternalBehaviorAnnexParser.g:16656:2: ( ruleReferenceTail ) { - // InternalBehaviorAnnexParser.g:16629:2: ( ruleReferenceTail ) - // InternalBehaviorAnnexParser.g:16630:3: ruleReferenceTail + // InternalBehaviorAnnexParser.g:16656:2: ( ruleReferenceTail ) + // InternalBehaviorAnnexParser.g:16657:3: ruleReferenceTail { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceAccess().getTailsReferenceTailParserRuleCall_1_0()); @@ -54063,17 +54158,17 @@ public final void rule__Reference__TailsAssignment_1() throws RecognitionExcepti // $ANTLR start "rule__ReferenceTail__SeparatorAssignment_0" - // InternalBehaviorAnnexParser.g:16639:1: rule__ReferenceTail__SeparatorAssignment_0 : ( ruleReferenceSeparator ) ; + // InternalBehaviorAnnexParser.g:16666:1: rule__ReferenceTail__SeparatorAssignment_0 : ( ruleReferenceSeparator ) ; public final void rule__ReferenceTail__SeparatorAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16643:1: ( ( ruleReferenceSeparator ) ) - // InternalBehaviorAnnexParser.g:16644:2: ( ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:16670:1: ( ( ruleReferenceSeparator ) ) + // InternalBehaviorAnnexParser.g:16671:2: ( ruleReferenceSeparator ) { - // InternalBehaviorAnnexParser.g:16644:2: ( ruleReferenceSeparator ) - // InternalBehaviorAnnexParser.g:16645:3: ruleReferenceSeparator + // InternalBehaviorAnnexParser.g:16671:2: ( ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:16672:3: ruleReferenceSeparator { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTailAccess().getSeparatorReferenceSeparatorParserRuleCall_0_0()); @@ -54108,17 +54203,17 @@ public final void rule__ReferenceTail__SeparatorAssignment_0() throws Recognitio // $ANTLR start "rule__ReferenceTail__SegmentAssignment_1" - // InternalBehaviorAnnexParser.g:16654:1: rule__ReferenceTail__SegmentAssignment_1 : ( ruleReferenceSegment ) ; + // InternalBehaviorAnnexParser.g:16681:1: rule__ReferenceTail__SegmentAssignment_1 : ( ruleReferenceSegment ) ; public final void rule__ReferenceTail__SegmentAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16658:1: ( ( ruleReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:16659:2: ( ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:16685:1: ( ( ruleReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:16686:2: ( ruleReferenceSegment ) { - // InternalBehaviorAnnexParser.g:16659:2: ( ruleReferenceSegment ) - // InternalBehaviorAnnexParser.g:16660:3: ruleReferenceSegment + // InternalBehaviorAnnexParser.g:16686:2: ( ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:16687:3: ruleReferenceSegment { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTailAccess().getSegmentReferenceSegmentParserRuleCall_1_0()); @@ -54153,17 +54248,17 @@ public final void rule__ReferenceTail__SegmentAssignment_1() throws RecognitionE // $ANTLR start "rule__ReferenceSegment__NameAssignment_0" - // InternalBehaviorAnnexParser.g:16669:1: rule__ReferenceSegment__NameAssignment_0 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:16696:1: rule__ReferenceSegment__NameAssignment_0 : ( RULE_ID ) ; public final void rule__ReferenceSegment__NameAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16673:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16674:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16700:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16701:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:16674:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16675:3: RULE_ID + // InternalBehaviorAnnexParser.g:16701:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16702:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSegmentAccess().getNameIDTerminalRuleCall_0_0()); @@ -54194,17 +54289,17 @@ public final void rule__ReferenceSegment__NameAssignment_0() throws RecognitionE // $ANTLR start "rule__ReferenceSegment__IndexesAssignment_1" - // InternalBehaviorAnnexParser.g:16684:1: rule__ReferenceSegment__IndexesAssignment_1 : ( ruleArrayIndex ) ; + // InternalBehaviorAnnexParser.g:16711:1: rule__ReferenceSegment__IndexesAssignment_1 : ( ruleArrayIndex ) ; public final void rule__ReferenceSegment__IndexesAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16688:1: ( ( ruleArrayIndex ) ) - // InternalBehaviorAnnexParser.g:16689:2: ( ruleArrayIndex ) + // InternalBehaviorAnnexParser.g:16715:1: ( ( ruleArrayIndex ) ) + // InternalBehaviorAnnexParser.g:16716:2: ( ruleArrayIndex ) { - // InternalBehaviorAnnexParser.g:16689:2: ( ruleArrayIndex ) - // InternalBehaviorAnnexParser.g:16690:3: ruleArrayIndex + // InternalBehaviorAnnexParser.g:16716:2: ( ruleArrayIndex ) + // InternalBehaviorAnnexParser.g:16717:3: ruleArrayIndex { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSegmentAccess().getIndexesArrayIndexParserRuleCall_1_0()); @@ -54239,17 +54334,17 @@ public final void rule__ReferenceSegment__IndexesAssignment_1() throws Recogniti // $ANTLR start "rule__ArrayIndex__ValueAssignment_1" - // InternalBehaviorAnnexParser.g:16699:1: rule__ArrayIndex__ValueAssignment_1 : ( ruleIntegerValue ) ; + // InternalBehaviorAnnexParser.g:16726:1: rule__ArrayIndex__ValueAssignment_1 : ( ruleIntegerValue ) ; public final void rule__ArrayIndex__ValueAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16703:1: ( ( ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:16704:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:16730:1: ( ( ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:16731:2: ( ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:16704:2: ( ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:16705:3: ruleIntegerValue + // InternalBehaviorAnnexParser.g:16731:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:16732:3: ruleIntegerValue { if ( state.backtracking==0 ) { before(grammarAccess.getArrayIndexAccess().getValueIntegerValueParserRuleCall_1_0()); @@ -54284,23 +54379,23 @@ public final void rule__ArrayIndex__ValueAssignment_1() throws RecognitionExcept // $ANTLR start "rule__ContainedPropertyAssociation__PropertyAssignment_0" - // InternalBehaviorAnnexParser.g:16714:1: rule__ContainedPropertyAssociation__PropertyAssignment_0 : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:16741:1: rule__ContainedPropertyAssociation__PropertyAssignment_0 : ( ( ruleQPREF ) ) ; public final void rule__ContainedPropertyAssociation__PropertyAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16718:1: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:16719:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:16745:1: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:16746:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:16719:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:16720:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:16746:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:16747:3: ( ruleQPREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getPropertyPropertyCrossReference_0_0()); } - // InternalBehaviorAnnexParser.g:16721:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:16722:4: ruleQPREF + // InternalBehaviorAnnexParser.g:16748:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:16749:4: ruleQPREF { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getPropertyPropertyQPREFParserRuleCall_0_0_1()); @@ -54341,23 +54436,23 @@ public final void rule__ContainedPropertyAssociation__PropertyAssignment_0() thr // $ANTLR start "rule__ContainedPropertyAssociation__AppendAssignment_1_1" - // InternalBehaviorAnnexParser.g:16733:1: rule__ContainedPropertyAssociation__AppendAssignment_1_1 : ( ( PlusSignEqualsSignGreaterThanSign ) ) ; + // InternalBehaviorAnnexParser.g:16760:1: rule__ContainedPropertyAssociation__AppendAssignment_1_1 : ( ( PlusSignEqualsSignGreaterThanSign ) ) ; public final void rule__ContainedPropertyAssociation__AppendAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16737:1: ( ( ( PlusSignEqualsSignGreaterThanSign ) ) ) - // InternalBehaviorAnnexParser.g:16738:2: ( ( PlusSignEqualsSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:16764:1: ( ( ( PlusSignEqualsSignGreaterThanSign ) ) ) + // InternalBehaviorAnnexParser.g:16765:2: ( ( PlusSignEqualsSignGreaterThanSign ) ) { - // InternalBehaviorAnnexParser.g:16738:2: ( ( PlusSignEqualsSignGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:16739:3: ( PlusSignEqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:16765:2: ( ( PlusSignEqualsSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:16766:3: ( PlusSignEqualsSignGreaterThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppendPlusSignEqualsSignGreaterThanSignKeyword_1_1_0()); } - // InternalBehaviorAnnexParser.g:16740:3: ( PlusSignEqualsSignGreaterThanSign ) - // InternalBehaviorAnnexParser.g:16741:4: PlusSignEqualsSignGreaterThanSign + // InternalBehaviorAnnexParser.g:16767:3: ( PlusSignEqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:16768:4: PlusSignEqualsSignGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppendPlusSignEqualsSignGreaterThanSignKeyword_1_1_0()); @@ -54394,23 +54489,23 @@ public final void rule__ContainedPropertyAssociation__AppendAssignment_1_1() thr // $ANTLR start "rule__ContainedPropertyAssociation__ConstantAssignment_2" - // InternalBehaviorAnnexParser.g:16752:1: rule__ContainedPropertyAssociation__ConstantAssignment_2 : ( ( Constant ) ) ; + // InternalBehaviorAnnexParser.g:16779:1: rule__ContainedPropertyAssociation__ConstantAssignment_2 : ( ( Constant ) ) ; public final void rule__ContainedPropertyAssociation__ConstantAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16756:1: ( ( ( Constant ) ) ) - // InternalBehaviorAnnexParser.g:16757:2: ( ( Constant ) ) + // InternalBehaviorAnnexParser.g:16783:1: ( ( ( Constant ) ) ) + // InternalBehaviorAnnexParser.g:16784:2: ( ( Constant ) ) { - // InternalBehaviorAnnexParser.g:16757:2: ( ( Constant ) ) - // InternalBehaviorAnnexParser.g:16758:3: ( Constant ) + // InternalBehaviorAnnexParser.g:16784:2: ( ( Constant ) ) + // InternalBehaviorAnnexParser.g:16785:3: ( Constant ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getConstantConstantKeyword_2_0()); } - // InternalBehaviorAnnexParser.g:16759:3: ( Constant ) - // InternalBehaviorAnnexParser.g:16760:4: Constant + // InternalBehaviorAnnexParser.g:16786:3: ( Constant ) + // InternalBehaviorAnnexParser.g:16787:4: Constant { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getConstantConstantKeyword_2_0()); @@ -54447,17 +54542,17 @@ public final void rule__ContainedPropertyAssociation__ConstantAssignment_2() thr // $ANTLR start "rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0" - // InternalBehaviorAnnexParser.g:16771:1: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 : ( ruleOptionalModalPropertyValue ) ; + // InternalBehaviorAnnexParser.g:16798:1: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 : ( ruleOptionalModalPropertyValue ) ; public final void rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16775:1: ( ( ruleOptionalModalPropertyValue ) ) - // InternalBehaviorAnnexParser.g:16776:2: ( ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:16802:1: ( ( ruleOptionalModalPropertyValue ) ) + // InternalBehaviorAnnexParser.g:16803:2: ( ruleOptionalModalPropertyValue ) { - // InternalBehaviorAnnexParser.g:16776:2: ( ruleOptionalModalPropertyValue ) - // InternalBehaviorAnnexParser.g:16777:3: ruleOptionalModalPropertyValue + // InternalBehaviorAnnexParser.g:16803:2: ( ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:16804:3: ruleOptionalModalPropertyValue { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueOptionalModalPropertyValueParserRuleCall_3_0_0()); @@ -54492,17 +54587,17 @@ public final void rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0() // $ANTLR start "rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1" - // InternalBehaviorAnnexParser.g:16786:1: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 : ( ruleOptionalModalPropertyValue ) ; + // InternalBehaviorAnnexParser.g:16813:1: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 : ( ruleOptionalModalPropertyValue ) ; public final void rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16790:1: ( ( ruleOptionalModalPropertyValue ) ) - // InternalBehaviorAnnexParser.g:16791:2: ( ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:16817:1: ( ( ruleOptionalModalPropertyValue ) ) + // InternalBehaviorAnnexParser.g:16818:2: ( ruleOptionalModalPropertyValue ) { - // InternalBehaviorAnnexParser.g:16791:2: ( ruleOptionalModalPropertyValue ) - // InternalBehaviorAnnexParser.g:16792:3: ruleOptionalModalPropertyValue + // InternalBehaviorAnnexParser.g:16818:2: ( ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:16819:3: ruleOptionalModalPropertyValue { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueOptionalModalPropertyValueParserRuleCall_3_1_1_0()); @@ -54537,17 +54632,17 @@ public final void rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 // $ANTLR start "rule__ContainedPropertyAssociation__AppliesToAssignment_4_2" - // InternalBehaviorAnnexParser.g:16801:1: rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 : ( ruleContainmentPath ) ; + // InternalBehaviorAnnexParser.g:16828:1: rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 : ( ruleContainmentPath ) ; public final void rule__ContainedPropertyAssociation__AppliesToAssignment_4_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16805:1: ( ( ruleContainmentPath ) ) - // InternalBehaviorAnnexParser.g:16806:2: ( ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:16832:1: ( ( ruleContainmentPath ) ) + // InternalBehaviorAnnexParser.g:16833:2: ( ruleContainmentPath ) { - // InternalBehaviorAnnexParser.g:16806:2: ( ruleContainmentPath ) - // InternalBehaviorAnnexParser.g:16807:3: ruleContainmentPath + // InternalBehaviorAnnexParser.g:16833:2: ( ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:16834:3: ruleContainmentPath { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToContainmentPathParserRuleCall_4_2_0()); @@ -54582,17 +54677,17 @@ public final void rule__ContainedPropertyAssociation__AppliesToAssignment_4_2() // $ANTLR start "rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1" - // InternalBehaviorAnnexParser.g:16816:1: rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 : ( ruleContainmentPath ) ; + // InternalBehaviorAnnexParser.g:16843:1: rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 : ( ruleContainmentPath ) ; public final void rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16820:1: ( ( ruleContainmentPath ) ) - // InternalBehaviorAnnexParser.g:16821:2: ( ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:16847:1: ( ( ruleContainmentPath ) ) + // InternalBehaviorAnnexParser.g:16848:2: ( ruleContainmentPath ) { - // InternalBehaviorAnnexParser.g:16821:2: ( ruleContainmentPath ) - // InternalBehaviorAnnexParser.g:16822:3: ruleContainmentPath + // InternalBehaviorAnnexParser.g:16848:2: ( ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:16849:3: ruleContainmentPath { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToContainmentPathParserRuleCall_4_3_1_0()); @@ -54627,23 +54722,23 @@ public final void rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1( // $ANTLR start "rule__ContainedPropertyAssociation__InBindingAssignment_5_3" - // InternalBehaviorAnnexParser.g:16831:1: rule__ContainedPropertyAssociation__InBindingAssignment_5_3 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:16858:1: rule__ContainedPropertyAssociation__InBindingAssignment_5_3 : ( ( ruleQCREF ) ) ; public final void rule__ContainedPropertyAssociation__InBindingAssignment_5_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16835:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:16836:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:16862:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:16863:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:16836:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:16837:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:16863:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:16864:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getInBindingClassifierCrossReference_5_3_0()); } - // InternalBehaviorAnnexParser.g:16838:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:16839:4: ruleQCREF + // InternalBehaviorAnnexParser.g:16865:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:16866:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getInBindingClassifierQCREFParserRuleCall_5_3_0_1()); @@ -54684,17 +54779,17 @@ public final void rule__ContainedPropertyAssociation__InBindingAssignment_5_3() // $ANTLR start "rule__ContainmentPath__PathAssignment" - // InternalBehaviorAnnexParser.g:16850:1: rule__ContainmentPath__PathAssignment : ( ruleContainmentPathElement ) ; + // InternalBehaviorAnnexParser.g:16877:1: rule__ContainmentPath__PathAssignment : ( ruleContainmentPathElement ) ; public final void rule__ContainmentPath__PathAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16854:1: ( ( ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:16855:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:16881:1: ( ( ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:16882:2: ( ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:16855:2: ( ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:16856:3: ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:16882:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:16883:3: ruleContainmentPathElement { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathAccess().getPathContainmentPathElementParserRuleCall_0()); @@ -54729,17 +54824,17 @@ public final void rule__ContainmentPath__PathAssignment() throws RecognitionExce // $ANTLR start "rule__OptionalModalPropertyValue__OwnedValueAssignment_0" - // InternalBehaviorAnnexParser.g:16865:1: rule__OptionalModalPropertyValue__OwnedValueAssignment_0 : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:16892:1: rule__OptionalModalPropertyValue__OwnedValueAssignment_0 : ( rulePropertyExpression ) ; public final void rule__OptionalModalPropertyValue__OwnedValueAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16869:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:16870:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:16896:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:16897:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:16870:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:16871:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:16897:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:16898:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getOwnedValuePropertyExpressionParserRuleCall_0_0()); @@ -54774,23 +54869,23 @@ public final void rule__OptionalModalPropertyValue__OwnedValueAssignment_0() thr // $ANTLR start "rule__OptionalModalPropertyValue__InModeAssignment_1_3" - // InternalBehaviorAnnexParser.g:16880:1: rule__OptionalModalPropertyValue__InModeAssignment_1_3 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:16907:1: rule__OptionalModalPropertyValue__InModeAssignment_1_3 : ( ( RULE_ID ) ) ; public final void rule__OptionalModalPropertyValue__InModeAssignment_1_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16884:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:16885:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16911:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:16912:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:16885:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16886:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16912:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16913:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeModeCrossReference_1_3_0()); } - // InternalBehaviorAnnexParser.g:16887:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16888:4: RULE_ID + // InternalBehaviorAnnexParser.g:16914:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16915:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeModeIDTerminalRuleCall_1_3_0_1()); @@ -54827,23 +54922,23 @@ public final void rule__OptionalModalPropertyValue__InModeAssignment_1_3() throw // $ANTLR start "rule__OptionalModalPropertyValue__InModeAssignment_1_4_1" - // InternalBehaviorAnnexParser.g:16899:1: rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:16926:1: rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 : ( ( RULE_ID ) ) ; public final void rule__OptionalModalPropertyValue__InModeAssignment_1_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16903:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:16904:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16930:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:16931:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:16904:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16905:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16931:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16932:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeModeCrossReference_1_4_1_0()); } - // InternalBehaviorAnnexParser.g:16906:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16907:4: RULE_ID + // InternalBehaviorAnnexParser.g:16933:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16934:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeModeIDTerminalRuleCall_1_4_1_0_1()); @@ -54880,17 +54975,17 @@ public final void rule__OptionalModalPropertyValue__InModeAssignment_1_4_1() thr // $ANTLR start "rule__PropertyValue__OwnedValueAssignment" - // InternalBehaviorAnnexParser.g:16918:1: rule__PropertyValue__OwnedValueAssignment : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:16945:1: rule__PropertyValue__OwnedValueAssignment : ( rulePropertyExpression ) ; public final void rule__PropertyValue__OwnedValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16922:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:16923:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:16949:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:16950:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:16923:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:16924:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:16950:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:16951:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyValueAccess().getOwnedValuePropertyExpressionParserRuleCall_0()); @@ -54925,23 +55020,23 @@ public final void rule__PropertyValue__OwnedValueAssignment() throws Recognition // $ANTLR start "rule__LiteralorReferenceTerm__NamedValueAssignment" - // InternalBehaviorAnnexParser.g:16933:1: rule__LiteralorReferenceTerm__NamedValueAssignment : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:16960:1: rule__LiteralorReferenceTerm__NamedValueAssignment : ( ( ruleQPREF ) ) ; public final void rule__LiteralorReferenceTerm__NamedValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16937:1: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:16938:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:16964:1: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:16965:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:16938:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:16939:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:16965:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:16966:3: ( ruleQPREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getLiteralorReferenceTermAccess().getNamedValueAbstractNamedValueCrossReference_0()); } - // InternalBehaviorAnnexParser.g:16940:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:16941:4: ruleQPREF + // InternalBehaviorAnnexParser.g:16967:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:16968:4: ruleQPREF { if ( state.backtracking==0 ) { before(grammarAccess.getLiteralorReferenceTermAccess().getNamedValueAbstractNamedValueQPREFParserRuleCall_0_1()); @@ -54982,23 +55077,23 @@ public final void rule__LiteralorReferenceTerm__NamedValueAssignment() throws Re // $ANTLR start "rule__BooleanLiteral__ValueAssignment_1_0" - // InternalBehaviorAnnexParser.g:16952:1: rule__BooleanLiteral__ValueAssignment_1_0 : ( ( True ) ) ; + // InternalBehaviorAnnexParser.g:16979:1: rule__BooleanLiteral__ValueAssignment_1_0 : ( ( True ) ) ; public final void rule__BooleanLiteral__ValueAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16956:1: ( ( ( True ) ) ) - // InternalBehaviorAnnexParser.g:16957:2: ( ( True ) ) + // InternalBehaviorAnnexParser.g:16983:1: ( ( ( True ) ) ) + // InternalBehaviorAnnexParser.g:16984:2: ( ( True ) ) { - // InternalBehaviorAnnexParser.g:16957:2: ( ( True ) ) - // InternalBehaviorAnnexParser.g:16958:3: ( True ) + // InternalBehaviorAnnexParser.g:16984:2: ( ( True ) ) + // InternalBehaviorAnnexParser.g:16985:3: ( True ) { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getValueTrueKeyword_1_0_0()); } - // InternalBehaviorAnnexParser.g:16959:3: ( True ) - // InternalBehaviorAnnexParser.g:16960:4: True + // InternalBehaviorAnnexParser.g:16986:3: ( True ) + // InternalBehaviorAnnexParser.g:16987:4: True { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getValueTrueKeyword_1_0_0()); @@ -55035,23 +55130,23 @@ public final void rule__BooleanLiteral__ValueAssignment_1_0() throws Recognition // $ANTLR start "rule__ConstantValue__NamedValueAssignment" - // InternalBehaviorAnnexParser.g:16971:1: rule__ConstantValue__NamedValueAssignment : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:16998:1: rule__ConstantValue__NamedValueAssignment : ( ( ruleQPREF ) ) ; public final void rule__ConstantValue__NamedValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16975:1: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:16976:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:17002:1: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:17003:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:16976:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:16977:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:17003:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:17004:3: ( ruleQPREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getConstantValueAccess().getNamedValuePropertyConstantCrossReference_0()); } - // InternalBehaviorAnnexParser.g:16978:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:16979:4: ruleQPREF + // InternalBehaviorAnnexParser.g:17005:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:17006:4: ruleQPREF { if ( state.backtracking==0 ) { before(grammarAccess.getConstantValueAccess().getNamedValuePropertyConstantQPREFParserRuleCall_0_1()); @@ -55092,17 +55187,17 @@ public final void rule__ConstantValue__NamedValueAssignment() throws Recognition // $ANTLR start "rule__ReferenceTerm__PathAssignment_2" - // InternalBehaviorAnnexParser.g:16990:1: rule__ReferenceTerm__PathAssignment_2 : ( ruleContainmentPathElement ) ; + // InternalBehaviorAnnexParser.g:17017:1: rule__ReferenceTerm__PathAssignment_2 : ( ruleContainmentPathElement ) ; public final void rule__ReferenceTerm__PathAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16994:1: ( ( ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:16995:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:17021:1: ( ( ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:17022:2: ( ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:16995:2: ( ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:16996:3: ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:17022:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:17023:3: ruleContainmentPathElement { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getPathContainmentPathElementParserRuleCall_2_0()); @@ -55137,17 +55232,17 @@ public final void rule__ReferenceTerm__PathAssignment_2() throws RecognitionExce // $ANTLR start "rule__RecordTerm__OwnedFieldValueAssignment_1" - // InternalBehaviorAnnexParser.g:17005:1: rule__RecordTerm__OwnedFieldValueAssignment_1 : ( ruleFieldPropertyAssociation ) ; + // InternalBehaviorAnnexParser.g:17032:1: rule__RecordTerm__OwnedFieldValueAssignment_1 : ( ruleFieldPropertyAssociation ) ; public final void rule__RecordTerm__OwnedFieldValueAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17009:1: ( ( ruleFieldPropertyAssociation ) ) - // InternalBehaviorAnnexParser.g:17010:2: ( ruleFieldPropertyAssociation ) + // InternalBehaviorAnnexParser.g:17036:1: ( ( ruleFieldPropertyAssociation ) ) + // InternalBehaviorAnnexParser.g:17037:2: ( ruleFieldPropertyAssociation ) { - // InternalBehaviorAnnexParser.g:17010:2: ( ruleFieldPropertyAssociation ) - // InternalBehaviorAnnexParser.g:17011:3: ruleFieldPropertyAssociation + // InternalBehaviorAnnexParser.g:17037:2: ( ruleFieldPropertyAssociation ) + // InternalBehaviorAnnexParser.g:17038:3: ruleFieldPropertyAssociation { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getOwnedFieldValueFieldPropertyAssociationParserRuleCall_1_0()); @@ -55182,17 +55277,17 @@ public final void rule__RecordTerm__OwnedFieldValueAssignment_1() throws Recogni // $ANTLR start "rule__ComputedTerm__FunctionAssignment_2" - // InternalBehaviorAnnexParser.g:17020:1: rule__ComputedTerm__FunctionAssignment_2 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:17047:1: rule__ComputedTerm__FunctionAssignment_2 : ( RULE_ID ) ; public final void rule__ComputedTerm__FunctionAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17024:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:17025:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17051:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17052:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:17025:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:17026:3: RULE_ID + // InternalBehaviorAnnexParser.g:17052:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17053:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getFunctionIDTerminalRuleCall_2_0()); @@ -55223,23 +55318,23 @@ public final void rule__ComputedTerm__FunctionAssignment_2() throws RecognitionE // $ANTLR start "rule__ComponentClassifierTerm__ClassifierAssignment_2" - // InternalBehaviorAnnexParser.g:17035:1: rule__ComponentClassifierTerm__ClassifierAssignment_2 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:17062:1: rule__ComponentClassifierTerm__ClassifierAssignment_2 : ( ( ruleQCREF ) ) ; public final void rule__ComponentClassifierTerm__ClassifierAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17039:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:17040:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:17066:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:17067:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:17040:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:17041:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:17067:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:17068:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getClassifierComponentClassifierCrossReference_2_0()); } - // InternalBehaviorAnnexParser.g:17042:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:17043:4: ruleQCREF + // InternalBehaviorAnnexParser.g:17069:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:17070:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getClassifierComponentClassifierQCREFParserRuleCall_2_0_1()); @@ -55280,17 +55375,17 @@ public final void rule__ComponentClassifierTerm__ClassifierAssignment_2() throws // $ANTLR start "rule__ListTerm__OwnedListElementAssignment_2_0" - // InternalBehaviorAnnexParser.g:17054:1: rule__ListTerm__OwnedListElementAssignment_2_0 : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:17081:1: rule__ListTerm__OwnedListElementAssignment_2_0 : ( rulePropertyExpression ) ; public final void rule__ListTerm__OwnedListElementAssignment_2_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17058:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:17059:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17085:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:17086:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:17059:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:17060:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:17086:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17087:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getOwnedListElementPropertyExpressionParserRuleCall_2_0_0()); @@ -55325,17 +55420,17 @@ public final void rule__ListTerm__OwnedListElementAssignment_2_0() throws Recogn // $ANTLR start "rule__ListTerm__OwnedListElementAssignment_2_1_1" - // InternalBehaviorAnnexParser.g:17069:1: rule__ListTerm__OwnedListElementAssignment_2_1_1 : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:17096:1: rule__ListTerm__OwnedListElementAssignment_2_1_1 : ( rulePropertyExpression ) ; public final void rule__ListTerm__OwnedListElementAssignment_2_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17073:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:17074:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17100:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:17101:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:17074:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:17075:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:17101:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17102:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getOwnedListElementPropertyExpressionParserRuleCall_2_1_1_0()); @@ -55370,23 +55465,23 @@ public final void rule__ListTerm__OwnedListElementAssignment_2_1_1() throws Reco // $ANTLR start "rule__FieldPropertyAssociation__PropertyAssignment_0" - // InternalBehaviorAnnexParser.g:17084:1: rule__FieldPropertyAssociation__PropertyAssignment_0 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:17111:1: rule__FieldPropertyAssociation__PropertyAssignment_0 : ( ( RULE_ID ) ) ; public final void rule__FieldPropertyAssociation__PropertyAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17088:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:17089:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17115:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:17116:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:17089:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:17090:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17116:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17117:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getPropertyBasicPropertyCrossReference_0_0()); } - // InternalBehaviorAnnexParser.g:17091:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:17092:4: RULE_ID + // InternalBehaviorAnnexParser.g:17118:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17119:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getPropertyBasicPropertyIDTerminalRuleCall_0_0_1()); @@ -55423,17 +55518,17 @@ public final void rule__FieldPropertyAssociation__PropertyAssignment_0() throws // $ANTLR start "rule__FieldPropertyAssociation__OwnedValueAssignment_2" - // InternalBehaviorAnnexParser.g:17103:1: rule__FieldPropertyAssociation__OwnedValueAssignment_2 : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:17130:1: rule__FieldPropertyAssociation__OwnedValueAssignment_2 : ( rulePropertyExpression ) ; public final void rule__FieldPropertyAssociation__OwnedValueAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17107:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:17108:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17134:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:17135:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:17108:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:17109:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:17135:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17136:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getOwnedValuePropertyExpressionParserRuleCall_2_0()); @@ -55468,23 +55563,23 @@ public final void rule__FieldPropertyAssociation__OwnedValueAssignment_2() throw // $ANTLR start "rule__ContainmentPathElement__NamedElementAssignment_0_0" - // InternalBehaviorAnnexParser.g:17118:1: rule__ContainmentPathElement__NamedElementAssignment_0_0 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:17145:1: rule__ContainmentPathElement__NamedElementAssignment_0_0 : ( ( RULE_ID ) ) ; public final void rule__ContainmentPathElement__NamedElementAssignment_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17122:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:17123:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17149:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:17150:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:17123:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:17124:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17150:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17151:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getNamedElementNamedElementCrossReference_0_0_0()); } - // InternalBehaviorAnnexParser.g:17125:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:17126:4: RULE_ID + // InternalBehaviorAnnexParser.g:17152:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17153:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getNamedElementNamedElementIDTerminalRuleCall_0_0_0_1()); @@ -55521,17 +55616,17 @@ public final void rule__ContainmentPathElement__NamedElementAssignment_0_0() thr // $ANTLR start "rule__ContainmentPathElement__ArrayRangeAssignment_0_1" - // InternalBehaviorAnnexParser.g:17137:1: rule__ContainmentPathElement__ArrayRangeAssignment_0_1 : ( ruleArrayRange ) ; + // InternalBehaviorAnnexParser.g:17164:1: rule__ContainmentPathElement__ArrayRangeAssignment_0_1 : ( ruleArrayRange ) ; public final void rule__ContainmentPathElement__ArrayRangeAssignment_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17141:1: ( ( ruleArrayRange ) ) - // InternalBehaviorAnnexParser.g:17142:2: ( ruleArrayRange ) + // InternalBehaviorAnnexParser.g:17168:1: ( ( ruleArrayRange ) ) + // InternalBehaviorAnnexParser.g:17169:2: ( ruleArrayRange ) { - // InternalBehaviorAnnexParser.g:17142:2: ( ruleArrayRange ) - // InternalBehaviorAnnexParser.g:17143:3: ruleArrayRange + // InternalBehaviorAnnexParser.g:17169:2: ( ruleArrayRange ) + // InternalBehaviorAnnexParser.g:17170:3: ruleArrayRange { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getArrayRangeArrayRangeParserRuleCall_0_1_0()); @@ -55566,17 +55661,17 @@ public final void rule__ContainmentPathElement__ArrayRangeAssignment_0_1() throw // $ANTLR start "rule__ContainmentPathElement__PathAssignment_1_1" - // InternalBehaviorAnnexParser.g:17152:1: rule__ContainmentPathElement__PathAssignment_1_1 : ( ruleContainmentPathElement ) ; + // InternalBehaviorAnnexParser.g:17179:1: rule__ContainmentPathElement__PathAssignment_1_1 : ( ruleContainmentPathElement ) ; public final void rule__ContainmentPathElement__PathAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17156:1: ( ( ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:17157:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:17183:1: ( ( ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:17184:2: ( ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:17157:2: ( ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:17158:3: ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:17184:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:17185:3: ruleContainmentPathElement { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getPathContainmentPathElementParserRuleCall_1_1_0()); @@ -55611,17 +55706,17 @@ public final void rule__ContainmentPathElement__PathAssignment_1_1() throws Reco // $ANTLR start "rule__StringTerm__ValueAssignment" - // InternalBehaviorAnnexParser.g:17167:1: rule__StringTerm__ValueAssignment : ( ruleNoQuoteString ) ; + // InternalBehaviorAnnexParser.g:17194:1: rule__StringTerm__ValueAssignment : ( ruleNoQuoteString ) ; public final void rule__StringTerm__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17171:1: ( ( ruleNoQuoteString ) ) - // InternalBehaviorAnnexParser.g:17172:2: ( ruleNoQuoteString ) + // InternalBehaviorAnnexParser.g:17198:1: ( ( ruleNoQuoteString ) ) + // InternalBehaviorAnnexParser.g:17199:2: ( ruleNoQuoteString ) { - // InternalBehaviorAnnexParser.g:17172:2: ( ruleNoQuoteString ) - // InternalBehaviorAnnexParser.g:17173:3: ruleNoQuoteString + // InternalBehaviorAnnexParser.g:17199:2: ( ruleNoQuoteString ) + // InternalBehaviorAnnexParser.g:17200:3: ruleNoQuoteString { if ( state.backtracking==0 ) { before(grammarAccess.getStringTermAccess().getValueNoQuoteStringParserRuleCall_0()); @@ -55656,17 +55751,17 @@ public final void rule__StringTerm__ValueAssignment() throws RecognitionExceptio // $ANTLR start "rule__ArrayRange__LowerBoundAssignment_2" - // InternalBehaviorAnnexParser.g:17182:1: rule__ArrayRange__LowerBoundAssignment_2 : ( ruleINTVALUE ) ; + // InternalBehaviorAnnexParser.g:17209:1: rule__ArrayRange__LowerBoundAssignment_2 : ( ruleINTVALUE ) ; public final void rule__ArrayRange__LowerBoundAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17186:1: ( ( ruleINTVALUE ) ) - // InternalBehaviorAnnexParser.g:17187:2: ( ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:17213:1: ( ( ruleINTVALUE ) ) + // InternalBehaviorAnnexParser.g:17214:2: ( ruleINTVALUE ) { - // InternalBehaviorAnnexParser.g:17187:2: ( ruleINTVALUE ) - // InternalBehaviorAnnexParser.g:17188:3: ruleINTVALUE + // InternalBehaviorAnnexParser.g:17214:2: ( ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:17215:3: ruleINTVALUE { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getLowerBoundINTVALUEParserRuleCall_2_0()); @@ -55701,17 +55796,17 @@ public final void rule__ArrayRange__LowerBoundAssignment_2() throws RecognitionE // $ANTLR start "rule__ArrayRange__UpperBoundAssignment_3_1" - // InternalBehaviorAnnexParser.g:17197:1: rule__ArrayRange__UpperBoundAssignment_3_1 : ( ruleINTVALUE ) ; + // InternalBehaviorAnnexParser.g:17224:1: rule__ArrayRange__UpperBoundAssignment_3_1 : ( ruleINTVALUE ) ; public final void rule__ArrayRange__UpperBoundAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17201:1: ( ( ruleINTVALUE ) ) - // InternalBehaviorAnnexParser.g:17202:2: ( ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:17228:1: ( ( ruleINTVALUE ) ) + // InternalBehaviorAnnexParser.g:17229:2: ( ruleINTVALUE ) { - // InternalBehaviorAnnexParser.g:17202:2: ( ruleINTVALUE ) - // InternalBehaviorAnnexParser.g:17203:3: ruleINTVALUE + // InternalBehaviorAnnexParser.g:17229:2: ( ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:17230:3: ruleINTVALUE { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getUpperBoundINTVALUEParserRuleCall_3_1_0()); @@ -55746,17 +55841,17 @@ public final void rule__ArrayRange__UpperBoundAssignment_3_1() throws Recognitio // $ANTLR start "rule__SignedConstant__OpAssignment_0" - // InternalBehaviorAnnexParser.g:17212:1: rule__SignedConstant__OpAssignment_0 : ( rulePlusMinus ) ; + // InternalBehaviorAnnexParser.g:17239:1: rule__SignedConstant__OpAssignment_0 : ( rulePlusMinus ) ; public final void rule__SignedConstant__OpAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17216:1: ( ( rulePlusMinus ) ) - // InternalBehaviorAnnexParser.g:17217:2: ( rulePlusMinus ) + // InternalBehaviorAnnexParser.g:17243:1: ( ( rulePlusMinus ) ) + // InternalBehaviorAnnexParser.g:17244:2: ( rulePlusMinus ) { - // InternalBehaviorAnnexParser.g:17217:2: ( rulePlusMinus ) - // InternalBehaviorAnnexParser.g:17218:3: rulePlusMinus + // InternalBehaviorAnnexParser.g:17244:2: ( rulePlusMinus ) + // InternalBehaviorAnnexParser.g:17245:3: rulePlusMinus { if ( state.backtracking==0 ) { before(grammarAccess.getSignedConstantAccess().getOpPlusMinusParserRuleCall_0_0()); @@ -55791,17 +55886,17 @@ public final void rule__SignedConstant__OpAssignment_0() throws RecognitionExcep // $ANTLR start "rule__SignedConstant__OwnedPropertyExpressionAssignment_1" - // InternalBehaviorAnnexParser.g:17227:1: rule__SignedConstant__OwnedPropertyExpressionAssignment_1 : ( ruleConstantValue ) ; + // InternalBehaviorAnnexParser.g:17254:1: rule__SignedConstant__OwnedPropertyExpressionAssignment_1 : ( ruleConstantValue ) ; public final void rule__SignedConstant__OwnedPropertyExpressionAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17231:1: ( ( ruleConstantValue ) ) - // InternalBehaviorAnnexParser.g:17232:2: ( ruleConstantValue ) + // InternalBehaviorAnnexParser.g:17258:1: ( ( ruleConstantValue ) ) + // InternalBehaviorAnnexParser.g:17259:2: ( ruleConstantValue ) { - // InternalBehaviorAnnexParser.g:17232:2: ( ruleConstantValue ) - // InternalBehaviorAnnexParser.g:17233:3: ruleConstantValue + // InternalBehaviorAnnexParser.g:17259:2: ( ruleConstantValue ) + // InternalBehaviorAnnexParser.g:17260:3: ruleConstantValue { if ( state.backtracking==0 ) { before(grammarAccess.getSignedConstantAccess().getOwnedPropertyExpressionConstantValueParserRuleCall_1_0()); @@ -55836,17 +55931,17 @@ public final void rule__SignedConstant__OwnedPropertyExpressionAssignment_1() th // $ANTLR start "rule__IntegerTerm__ValueAssignment_0" - // InternalBehaviorAnnexParser.g:17242:1: rule__IntegerTerm__ValueAssignment_0 : ( ruleSignedInt ) ; + // InternalBehaviorAnnexParser.g:17269:1: rule__IntegerTerm__ValueAssignment_0 : ( ruleSignedInt ) ; public final void rule__IntegerTerm__ValueAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17246:1: ( ( ruleSignedInt ) ) - // InternalBehaviorAnnexParser.g:17247:2: ( ruleSignedInt ) + // InternalBehaviorAnnexParser.g:17273:1: ( ( ruleSignedInt ) ) + // InternalBehaviorAnnexParser.g:17274:2: ( ruleSignedInt ) { - // InternalBehaviorAnnexParser.g:17247:2: ( ruleSignedInt ) - // InternalBehaviorAnnexParser.g:17248:3: ruleSignedInt + // InternalBehaviorAnnexParser.g:17274:2: ( ruleSignedInt ) + // InternalBehaviorAnnexParser.g:17275:3: ruleSignedInt { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getValueSignedIntParserRuleCall_0_0()); @@ -55881,23 +55976,23 @@ public final void rule__IntegerTerm__ValueAssignment_0() throws RecognitionExcep // $ANTLR start "rule__IntegerTerm__UnitAssignment_1" - // InternalBehaviorAnnexParser.g:17257:1: rule__IntegerTerm__UnitAssignment_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:17284:1: rule__IntegerTerm__UnitAssignment_1 : ( ( RULE_ID ) ) ; public final void rule__IntegerTerm__UnitAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17261:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:17262:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17288:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:17289:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:17262:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:17263:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17289:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17290:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getUnitUnitLiteralCrossReference_1_0()); } - // InternalBehaviorAnnexParser.g:17264:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:17265:4: RULE_ID + // InternalBehaviorAnnexParser.g:17291:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17292:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getUnitUnitLiteralIDTerminalRuleCall_1_0_1()); @@ -55934,17 +56029,17 @@ public final void rule__IntegerTerm__UnitAssignment_1() throws RecognitionExcept // $ANTLR start "rule__RealTerm__ValueAssignment_0" - // InternalBehaviorAnnexParser.g:17276:1: rule__RealTerm__ValueAssignment_0 : ( ruleSignedReal ) ; + // InternalBehaviorAnnexParser.g:17303:1: rule__RealTerm__ValueAssignment_0 : ( ruleSignedReal ) ; public final void rule__RealTerm__ValueAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17280:1: ( ( ruleSignedReal ) ) - // InternalBehaviorAnnexParser.g:17281:2: ( ruleSignedReal ) + // InternalBehaviorAnnexParser.g:17307:1: ( ( ruleSignedReal ) ) + // InternalBehaviorAnnexParser.g:17308:2: ( ruleSignedReal ) { - // InternalBehaviorAnnexParser.g:17281:2: ( ruleSignedReal ) - // InternalBehaviorAnnexParser.g:17282:3: ruleSignedReal + // InternalBehaviorAnnexParser.g:17308:2: ( ruleSignedReal ) + // InternalBehaviorAnnexParser.g:17309:3: ruleSignedReal { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getValueSignedRealParserRuleCall_0_0()); @@ -55979,23 +56074,23 @@ public final void rule__RealTerm__ValueAssignment_0() throws RecognitionExceptio // $ANTLR start "rule__RealTerm__UnitAssignment_1" - // InternalBehaviorAnnexParser.g:17291:1: rule__RealTerm__UnitAssignment_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:17318:1: rule__RealTerm__UnitAssignment_1 : ( ( RULE_ID ) ) ; public final void rule__RealTerm__UnitAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17295:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:17296:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17322:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:17323:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:17296:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:17297:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17323:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17324:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getUnitUnitLiteralCrossReference_1_0()); } - // InternalBehaviorAnnexParser.g:17298:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:17299:4: RULE_ID + // InternalBehaviorAnnexParser.g:17325:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17326:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getUnitUnitLiteralIDTerminalRuleCall_1_0_1()); @@ -56032,17 +56127,17 @@ public final void rule__RealTerm__UnitAssignment_1() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__MinimumAssignment_0" - // InternalBehaviorAnnexParser.g:17310:1: rule__NumericRangeTerm__MinimumAssignment_0 : ( ruleNumAlt ) ; + // InternalBehaviorAnnexParser.g:17337:1: rule__NumericRangeTerm__MinimumAssignment_0 : ( ruleNumAlt ) ; public final void rule__NumericRangeTerm__MinimumAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17314:1: ( ( ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:17315:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17341:1: ( ( ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:17342:2: ( ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:17315:2: ( ruleNumAlt ) - // InternalBehaviorAnnexParser.g:17316:3: ruleNumAlt + // InternalBehaviorAnnexParser.g:17342:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17343:3: ruleNumAlt { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getMinimumNumAltParserRuleCall_0_0()); @@ -56077,17 +56172,17 @@ public final void rule__NumericRangeTerm__MinimumAssignment_0() throws Recogniti // $ANTLR start "rule__NumericRangeTerm__MaximumAssignment_2" - // InternalBehaviorAnnexParser.g:17325:1: rule__NumericRangeTerm__MaximumAssignment_2 : ( ruleNumAlt ) ; + // InternalBehaviorAnnexParser.g:17352:1: rule__NumericRangeTerm__MaximumAssignment_2 : ( ruleNumAlt ) ; public final void rule__NumericRangeTerm__MaximumAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17329:1: ( ( ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:17330:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17356:1: ( ( ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:17357:2: ( ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:17330:2: ( ruleNumAlt ) - // InternalBehaviorAnnexParser.g:17331:3: ruleNumAlt + // InternalBehaviorAnnexParser.g:17357:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17358:3: ruleNumAlt { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getMaximumNumAltParserRuleCall_2_0()); @@ -56122,17 +56217,17 @@ public final void rule__NumericRangeTerm__MaximumAssignment_2() throws Recogniti // $ANTLR start "rule__NumericRangeTerm__DeltaAssignment_3_1" - // InternalBehaviorAnnexParser.g:17340:1: rule__NumericRangeTerm__DeltaAssignment_3_1 : ( ruleNumAlt ) ; + // InternalBehaviorAnnexParser.g:17367:1: rule__NumericRangeTerm__DeltaAssignment_3_1 : ( ruleNumAlt ) ; public final void rule__NumericRangeTerm__DeltaAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17344:1: ( ( ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:17345:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17371:1: ( ( ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:17372:2: ( ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:17345:2: ( ruleNumAlt ) - // InternalBehaviorAnnexParser.g:17346:3: ruleNumAlt + // InternalBehaviorAnnexParser.g:17372:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17373:3: ruleNumAlt { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getDeltaNumAltParserRuleCall_3_1_0()); @@ -56435,7 +56530,7 @@ private static class FollowSets000 { public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000040202000000L}); public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000002000002L}); public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x2000000000000000L}); - public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x4000000000000000L,0x0000000000004000L}); public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000080000000L}); public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0020000000000000L}); diff --git a/ba/org.osate.xtext.aadl2.ba/.launch/Generate Language Infrastructure (org.osate.xtext.aadl2.ba).launch b/ba/org.osate.xtext.aadl2.ba/.launch/Generate Language Infrastructure (org.osate.xtext.aadl2.ba).launch index 52ae5d5b8d..b3b034f434 100644 --- a/ba/org.osate.xtext.aadl2.ba/.launch/Generate Language Infrastructure (org.osate.xtext.aadl2.ba).launch +++ b/ba/org.osate.xtext.aadl2.ba/.launch/Generate Language Infrastructure (org.osate.xtext.aadl2.ba).launch @@ -1,14 +1,20 @@ - - - - - - - - - - - + + + + + + + + + + + + + + + + + diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/BehaviorAnnex.xtextbin b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/BehaviorAnnex.xtextbin index f938dcbaf2..25cdf3e7e3 100644 Binary files a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/BehaviorAnnex.xtextbin and b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/BehaviorAnnex.xtextbin differ diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/parser/antlr/internal/InternalBehaviorAnnexParser.g b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/parser/antlr/internal/InternalBehaviorAnnexParser.g index a13ae0dbbe..8bc3f861d4 100644 --- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/parser/antlr/internal/InternalBehaviorAnnexParser.g +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/parser/antlr/internal/InternalBehaviorAnnexParser.g @@ -2690,34 +2690,36 @@ ruleForStatement returns [EObject current=null] } ) ) - otherlv_4=Colon - { - newLeafNode(otherlv_4, grammarAccess.getForStatementAccess().getColonKeyword_3()); - } ( + otherlv_4=Colon + { + newLeafNode(otherlv_4, grammarAccess.getForStatementAccess().getColonKeyword_3_0()); + } ( - { - if ($current==null) { - $current = createModelElement(grammarAccess.getForStatementRule()); + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getForStatementRule()); + } } - } - { - newCompositeNode(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_4_0()); - } - ruleQCREF - { - afterParserOrEnumRuleCall(); - } + { + newCompositeNode(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_3_1_0()); + } + ruleQCREF + { + afterParserOrEnumRuleCall(); + } + ) ) - ) + )? otherlv_6=In { - newLeafNode(otherlv_6, grammarAccess.getForStatementAccess().getInKeyword_5()); + newLeafNode(otherlv_6, grammarAccess.getForStatementAccess().getInKeyword_4()); } ( ( { - newCompositeNode(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_6_0()); + newCompositeNode(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_5_0()); } lv_values_7_0=ruleElementValues { @@ -2735,16 +2737,16 @@ ruleForStatement returns [EObject current=null] ) otherlv_8=RightParenthesis { - newLeafNode(otherlv_8, grammarAccess.getForStatementAccess().getRightParenthesisKeyword_7()); + newLeafNode(otherlv_8, grammarAccess.getForStatementAccess().getRightParenthesisKeyword_6()); } otherlv_9=LeftCurlyBracket { - newLeafNode(otherlv_9, grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_8()); + newLeafNode(otherlv_9, grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_7()); } ( ( { - newCompositeNode(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_9_0()); + newCompositeNode(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_8_0()); } lv_actions_10_0=ruleBehaviorActions { @@ -2762,7 +2764,7 @@ ruleForStatement returns [EObject current=null] ) otherlv_11=RightCurlyBracket { - newLeafNode(otherlv_11, grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_10()); + newLeafNode(otherlv_11, grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_9()); } ) ; diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/parser/antlr/internal/InternalBehaviorAnnexParser.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/parser/antlr/internal/InternalBehaviorAnnexParser.java index 9adb1b8061..2b2c5e9ae2 100644 --- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/parser/antlr/internal/InternalBehaviorAnnexParser.java +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/parser/antlr/internal/InternalBehaviorAnnexParser.java @@ -7384,7 +7384,7 @@ public final EObject entryRuleForStatement() throws RecognitionException { // $ANTLR start "ruleForStatement" - // InternalBehaviorAnnexParser.g:2632:1: ruleForStatement returns [EObject current=null] : ( ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) otherlv_2= LeftParenthesis ( (lv_variable_3_0= RULE_ID ) ) otherlv_4= Colon ( ( ruleQCREF ) ) otherlv_6= In ( (lv_values_7_0= ruleElementValues ) ) otherlv_8= RightParenthesis otherlv_9= LeftCurlyBracket ( (lv_actions_10_0= ruleBehaviorActions ) ) otherlv_11= RightCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:2632:1: ruleForStatement returns [EObject current=null] : ( ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) otherlv_2= LeftParenthesis ( (lv_variable_3_0= RULE_ID ) ) (otherlv_4= Colon ( ( ruleQCREF ) ) )? otherlv_6= In ( (lv_values_7_0= ruleElementValues ) ) otherlv_8= RightParenthesis otherlv_9= LeftCurlyBracket ( (lv_actions_10_0= ruleBehaviorActions ) ) otherlv_11= RightCurlyBracket ) ; public final EObject ruleForStatement() throws RecognitionException { EObject current = null; @@ -7406,11 +7406,11 @@ public final EObject ruleForStatement() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:2638:2: ( ( ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) otherlv_2= LeftParenthesis ( (lv_variable_3_0= RULE_ID ) ) otherlv_4= Colon ( ( ruleQCREF ) ) otherlv_6= In ( (lv_values_7_0= ruleElementValues ) ) otherlv_8= RightParenthesis otherlv_9= LeftCurlyBracket ( (lv_actions_10_0= ruleBehaviorActions ) ) otherlv_11= RightCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:2639:2: ( ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) otherlv_2= LeftParenthesis ( (lv_variable_3_0= RULE_ID ) ) otherlv_4= Colon ( ( ruleQCREF ) ) otherlv_6= In ( (lv_values_7_0= ruleElementValues ) ) otherlv_8= RightParenthesis otherlv_9= LeftCurlyBracket ( (lv_actions_10_0= ruleBehaviorActions ) ) otherlv_11= RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:2638:2: ( ( ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) otherlv_2= LeftParenthesis ( (lv_variable_3_0= RULE_ID ) ) (otherlv_4= Colon ( ( ruleQCREF ) ) )? otherlv_6= In ( (lv_values_7_0= ruleElementValues ) ) otherlv_8= RightParenthesis otherlv_9= LeftCurlyBracket ( (lv_actions_10_0= ruleBehaviorActions ) ) otherlv_11= RightCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:2639:2: ( ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) otherlv_2= LeftParenthesis ( (lv_variable_3_0= RULE_ID ) ) (otherlv_4= Colon ( ( ruleQCREF ) ) )? otherlv_6= In ( (lv_values_7_0= ruleElementValues ) ) otherlv_8= RightParenthesis otherlv_9= LeftCurlyBracket ( (lv_actions_10_0= ruleBehaviorActions ) ) otherlv_11= RightCurlyBracket ) { - // InternalBehaviorAnnexParser.g:2639:2: ( ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) otherlv_2= LeftParenthesis ( (lv_variable_3_0= RULE_ID ) ) otherlv_4= Colon ( ( ruleQCREF ) ) otherlv_6= In ( (lv_values_7_0= ruleElementValues ) ) otherlv_8= RightParenthesis otherlv_9= LeftCurlyBracket ( (lv_actions_10_0= ruleBehaviorActions ) ) otherlv_11= RightCurlyBracket ) - // InternalBehaviorAnnexParser.g:2640:3: ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) otherlv_2= LeftParenthesis ( (lv_variable_3_0= RULE_ID ) ) otherlv_4= Colon ( ( ruleQCREF ) ) otherlv_6= In ( (lv_values_7_0= ruleElementValues ) ) otherlv_8= RightParenthesis otherlv_9= LeftCurlyBracket ( (lv_actions_10_0= ruleBehaviorActions ) ) otherlv_11= RightCurlyBracket + // InternalBehaviorAnnexParser.g:2639:2: ( ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) otherlv_2= LeftParenthesis ( (lv_variable_3_0= RULE_ID ) ) (otherlv_4= Colon ( ( ruleQCREF ) ) )? otherlv_6= In ( (lv_values_7_0= ruleElementValues ) ) otherlv_8= RightParenthesis otherlv_9= LeftCurlyBracket ( (lv_actions_10_0= ruleBehaviorActions ) ) otherlv_11= RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:2640:3: ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) otherlv_2= LeftParenthesis ( (lv_variable_3_0= RULE_ID ) ) (otherlv_4= Colon ( ( ruleQCREF ) ) )? otherlv_6= In ( (lv_values_7_0= ruleElementValues ) ) otherlv_8= RightParenthesis otherlv_9= LeftCurlyBracket ( (lv_actions_10_0= ruleBehaviorActions ) ) otherlv_11= RightCurlyBracket { // InternalBehaviorAnnexParser.g:2640:3: ( ( (lv_for_0_0= For ) ) | ( (lv_forall_1_0= Forall ) ) ) int alt54=2; @@ -7509,7 +7509,7 @@ else if ( (LA54_0==Forall) ) { // InternalBehaviorAnnexParser.g:2676:4: (lv_variable_3_0= RULE_ID ) // InternalBehaviorAnnexParser.g:2677:5: lv_variable_3_0= RULE_ID { - lv_variable_3_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_24); if (state.failed) return current; + lv_variable_3_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_58); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_variable_3_0, grammarAccess.getForStatementAccess().getVariableIDTerminalRuleCall_2_0()); @@ -7533,61 +7533,78 @@ else if ( (LA54_0==Forall) ) { } - otherlv_4=(Token)match(input,Colon,FollowSets000.FOLLOW_3); if (state.failed) return current; - if ( state.backtracking==0 ) { + // InternalBehaviorAnnexParser.g:2693:3: (otherlv_4= Colon ( ( ruleQCREF ) ) )? + int alt55=2; + int LA55_0 = input.LA(1); - newLeafNode(otherlv_4, grammarAccess.getForStatementAccess().getColonKeyword_3()); - + if ( (LA55_0==Colon) ) { + alt55=1; } - // InternalBehaviorAnnexParser.g:2697:3: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:2698:4: ( ruleQCREF ) - { - // InternalBehaviorAnnexParser.g:2698:4: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:2699:5: ruleQCREF - { - if ( state.backtracking==0 ) { + switch (alt55) { + case 1 : + // InternalBehaviorAnnexParser.g:2694:4: otherlv_4= Colon ( ( ruleQCREF ) ) + { + otherlv_4=(Token)match(input,Colon,FollowSets000.FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { - if (current==null) { - current = createModelElement(grammarAccess.getForStatementRule()); - } - - } - if ( state.backtracking==0 ) { + newLeafNode(otherlv_4, grammarAccess.getForStatementAccess().getColonKeyword_3_0()); + + } + // InternalBehaviorAnnexParser.g:2698:4: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:2699:5: ( ruleQCREF ) + { + // InternalBehaviorAnnexParser.g:2699:5: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:2700:6: ruleQCREF + { + if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_4_0()); - - } - pushFollow(FollowSets000.FOLLOW_58); - ruleQCREF(); + if (current==null) { + current = createModelElement(grammarAccess.getForStatementRule()); + } + + } + if ( state.backtracking==0 ) { - state._fsp--; - if (state.failed) return current; - if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_3_1_0()); + + } + pushFollow(FollowSets000.FOLLOW_59); + ruleQCREF(); - afterParserOrEnumRuleCall(); - - } + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { - } + afterParserOrEnumRuleCall(); + + } + } + + + } + + + } + break; } otherlv_6=(Token)match(input,In,FollowSets000.FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { - newLeafNode(otherlv_6, grammarAccess.getForStatementAccess().getInKeyword_5()); + newLeafNode(otherlv_6, grammarAccess.getForStatementAccess().getInKeyword_4()); } - // InternalBehaviorAnnexParser.g:2717:3: ( (lv_values_7_0= ruleElementValues ) ) - // InternalBehaviorAnnexParser.g:2718:4: (lv_values_7_0= ruleElementValues ) + // InternalBehaviorAnnexParser.g:2719:3: ( (lv_values_7_0= ruleElementValues ) ) + // InternalBehaviorAnnexParser.g:2720:4: (lv_values_7_0= ruleElementValues ) { - // InternalBehaviorAnnexParser.g:2718:4: (lv_values_7_0= ruleElementValues ) - // InternalBehaviorAnnexParser.g:2719:5: lv_values_7_0= ruleElementValues + // InternalBehaviorAnnexParser.g:2720:4: (lv_values_7_0= ruleElementValues ) + // InternalBehaviorAnnexParser.g:2721:5: lv_values_7_0= ruleElementValues { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_6_0()); + newCompositeNode(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_5_0()); } pushFollow(FollowSets000.FOLLOW_39); @@ -7614,27 +7631,27 @@ else if ( (LA54_0==Forall) ) { } - otherlv_8=(Token)match(input,RightParenthesis,FollowSets000.FOLLOW_59); if (state.failed) return current; + otherlv_8=(Token)match(input,RightParenthesis,FollowSets000.FOLLOW_60); if (state.failed) return current; if ( state.backtracking==0 ) { - newLeafNode(otherlv_8, grammarAccess.getForStatementAccess().getRightParenthesisKeyword_7()); + newLeafNode(otherlv_8, grammarAccess.getForStatementAccess().getRightParenthesisKeyword_6()); } otherlv_9=(Token)match(input,LeftCurlyBracket,FollowSets000.FOLLOW_40); if (state.failed) return current; if ( state.backtracking==0 ) { - newLeafNode(otherlv_9, grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_8()); + newLeafNode(otherlv_9, grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_7()); } - // InternalBehaviorAnnexParser.g:2744:3: ( (lv_actions_10_0= ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:2745:4: (lv_actions_10_0= ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:2746:3: ( (lv_actions_10_0= ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:2747:4: (lv_actions_10_0= ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:2745:4: (lv_actions_10_0= ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:2746:5: lv_actions_10_0= ruleBehaviorActions + // InternalBehaviorAnnexParser.g:2747:4: (lv_actions_10_0= ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:2748:5: lv_actions_10_0= ruleBehaviorActions { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_9_0()); + newCompositeNode(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_8_0()); } pushFollow(FollowSets000.FOLLOW_41); @@ -7664,7 +7681,7 @@ else if ( (LA54_0==Forall) ) { otherlv_11=(Token)match(input,RightCurlyBracket,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { - newLeafNode(otherlv_11, grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_10()); + newLeafNode(otherlv_11, grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_9()); } @@ -7692,7 +7709,7 @@ else if ( (LA54_0==Forall) ) { // $ANTLR start "entryRuleWhileStatement" - // InternalBehaviorAnnexParser.g:2771:1: entryRuleWhileStatement returns [EObject current=null] : iv_ruleWhileStatement= ruleWhileStatement EOF ; + // InternalBehaviorAnnexParser.g:2773:1: entryRuleWhileStatement returns [EObject current=null] : iv_ruleWhileStatement= ruleWhileStatement EOF ; public final EObject entryRuleWhileStatement() throws RecognitionException { EObject current = null; @@ -7700,8 +7717,8 @@ public final EObject entryRuleWhileStatement() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2771:55: (iv_ruleWhileStatement= ruleWhileStatement EOF ) - // InternalBehaviorAnnexParser.g:2772:2: iv_ruleWhileStatement= ruleWhileStatement EOF + // InternalBehaviorAnnexParser.g:2773:55: (iv_ruleWhileStatement= ruleWhileStatement EOF ) + // InternalBehaviorAnnexParser.g:2774:2: iv_ruleWhileStatement= ruleWhileStatement EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getWhileStatementRule()); @@ -7732,7 +7749,7 @@ public final EObject entryRuleWhileStatement() throws RecognitionException { // $ANTLR start "ruleWhileStatement" - // InternalBehaviorAnnexParser.g:2778:1: ruleWhileStatement returns [EObject current=null] : (otherlv_0= While otherlv_1= LeftParenthesis ( (lv_condition_2_0= ruleValueExpression ) ) otherlv_3= RightParenthesis otherlv_4= LeftCurlyBracket ( (lv_actions_5_0= ruleBehaviorActions ) ) otherlv_6= RightCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:2780:1: ruleWhileStatement returns [EObject current=null] : (otherlv_0= While otherlv_1= LeftParenthesis ( (lv_condition_2_0= ruleValueExpression ) ) otherlv_3= RightParenthesis otherlv_4= LeftCurlyBracket ( (lv_actions_5_0= ruleBehaviorActions ) ) otherlv_6= RightCurlyBracket ) ; public final EObject ruleWhileStatement() throws RecognitionException { EObject current = null; @@ -7750,11 +7767,11 @@ public final EObject ruleWhileStatement() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:2784:2: ( (otherlv_0= While otherlv_1= LeftParenthesis ( (lv_condition_2_0= ruleValueExpression ) ) otherlv_3= RightParenthesis otherlv_4= LeftCurlyBracket ( (lv_actions_5_0= ruleBehaviorActions ) ) otherlv_6= RightCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:2785:2: (otherlv_0= While otherlv_1= LeftParenthesis ( (lv_condition_2_0= ruleValueExpression ) ) otherlv_3= RightParenthesis otherlv_4= LeftCurlyBracket ( (lv_actions_5_0= ruleBehaviorActions ) ) otherlv_6= RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:2786:2: ( (otherlv_0= While otherlv_1= LeftParenthesis ( (lv_condition_2_0= ruleValueExpression ) ) otherlv_3= RightParenthesis otherlv_4= LeftCurlyBracket ( (lv_actions_5_0= ruleBehaviorActions ) ) otherlv_6= RightCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:2787:2: (otherlv_0= While otherlv_1= LeftParenthesis ( (lv_condition_2_0= ruleValueExpression ) ) otherlv_3= RightParenthesis otherlv_4= LeftCurlyBracket ( (lv_actions_5_0= ruleBehaviorActions ) ) otherlv_6= RightCurlyBracket ) { - // InternalBehaviorAnnexParser.g:2785:2: (otherlv_0= While otherlv_1= LeftParenthesis ( (lv_condition_2_0= ruleValueExpression ) ) otherlv_3= RightParenthesis otherlv_4= LeftCurlyBracket ( (lv_actions_5_0= ruleBehaviorActions ) ) otherlv_6= RightCurlyBracket ) - // InternalBehaviorAnnexParser.g:2786:3: otherlv_0= While otherlv_1= LeftParenthesis ( (lv_condition_2_0= ruleValueExpression ) ) otherlv_3= RightParenthesis otherlv_4= LeftCurlyBracket ( (lv_actions_5_0= ruleBehaviorActions ) ) otherlv_6= RightCurlyBracket + // InternalBehaviorAnnexParser.g:2787:2: (otherlv_0= While otherlv_1= LeftParenthesis ( (lv_condition_2_0= ruleValueExpression ) ) otherlv_3= RightParenthesis otherlv_4= LeftCurlyBracket ( (lv_actions_5_0= ruleBehaviorActions ) ) otherlv_6= RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:2788:3: otherlv_0= While otherlv_1= LeftParenthesis ( (lv_condition_2_0= ruleValueExpression ) ) otherlv_3= RightParenthesis otherlv_4= LeftCurlyBracket ( (lv_actions_5_0= ruleBehaviorActions ) ) otherlv_6= RightCurlyBracket { otherlv_0=(Token)match(input,While,FollowSets000.FOLLOW_31); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -7768,11 +7785,11 @@ public final EObject ruleWhileStatement() throws RecognitionException { newLeafNode(otherlv_1, grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); } - // InternalBehaviorAnnexParser.g:2794:3: ( (lv_condition_2_0= ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:2795:4: (lv_condition_2_0= ruleValueExpression ) + // InternalBehaviorAnnexParser.g:2796:3: ( (lv_condition_2_0= ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:2797:4: (lv_condition_2_0= ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:2795:4: (lv_condition_2_0= ruleValueExpression ) - // InternalBehaviorAnnexParser.g:2796:5: lv_condition_2_0= ruleValueExpression + // InternalBehaviorAnnexParser.g:2797:4: (lv_condition_2_0= ruleValueExpression ) + // InternalBehaviorAnnexParser.g:2798:5: lv_condition_2_0= ruleValueExpression { if ( state.backtracking==0 ) { @@ -7803,7 +7820,7 @@ public final EObject ruleWhileStatement() throws RecognitionException { } - otherlv_3=(Token)match(input,RightParenthesis,FollowSets000.FOLLOW_59); if (state.failed) return current; + otherlv_3=(Token)match(input,RightParenthesis,FollowSets000.FOLLOW_60); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); @@ -7815,11 +7832,11 @@ public final EObject ruleWhileStatement() throws RecognitionException { newLeafNode(otherlv_4, grammarAccess.getWhileStatementAccess().getLeftCurlyBracketKeyword_4()); } - // InternalBehaviorAnnexParser.g:2821:3: ( (lv_actions_5_0= ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:2822:4: (lv_actions_5_0= ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:2823:3: ( (lv_actions_5_0= ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:2824:4: (lv_actions_5_0= ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:2822:4: (lv_actions_5_0= ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:2823:5: lv_actions_5_0= ruleBehaviorActions + // InternalBehaviorAnnexParser.g:2824:4: (lv_actions_5_0= ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:2825:5: lv_actions_5_0= ruleBehaviorActions { if ( state.backtracking==0 ) { @@ -7881,7 +7898,7 @@ public final EObject ruleWhileStatement() throws RecognitionException { // $ANTLR start "entryRuleDoUntilStatement" - // InternalBehaviorAnnexParser.g:2848:1: entryRuleDoUntilStatement returns [EObject current=null] : iv_ruleDoUntilStatement= ruleDoUntilStatement EOF ; + // InternalBehaviorAnnexParser.g:2850:1: entryRuleDoUntilStatement returns [EObject current=null] : iv_ruleDoUntilStatement= ruleDoUntilStatement EOF ; public final EObject entryRuleDoUntilStatement() throws RecognitionException { EObject current = null; @@ -7889,8 +7906,8 @@ public final EObject entryRuleDoUntilStatement() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2848:57: (iv_ruleDoUntilStatement= ruleDoUntilStatement EOF ) - // InternalBehaviorAnnexParser.g:2849:2: iv_ruleDoUntilStatement= ruleDoUntilStatement EOF + // InternalBehaviorAnnexParser.g:2850:57: (iv_ruleDoUntilStatement= ruleDoUntilStatement EOF ) + // InternalBehaviorAnnexParser.g:2851:2: iv_ruleDoUntilStatement= ruleDoUntilStatement EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getDoUntilStatementRule()); @@ -7921,7 +7938,7 @@ public final EObject entryRuleDoUntilStatement() throws RecognitionException { // $ANTLR start "ruleDoUntilStatement" - // InternalBehaviorAnnexParser.g:2855:1: ruleDoUntilStatement returns [EObject current=null] : (otherlv_0= Do ( (lv_actions_1_0= ruleBehaviorActions ) ) otherlv_2= Until otherlv_3= LeftParenthesis ( (lv_condition_4_0= ruleValueExpression ) ) otherlv_5= RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:2857:1: ruleDoUntilStatement returns [EObject current=null] : (otherlv_0= Do ( (lv_actions_1_0= ruleBehaviorActions ) ) otherlv_2= Until otherlv_3= LeftParenthesis ( (lv_condition_4_0= ruleValueExpression ) ) otherlv_5= RightParenthesis ) ; public final EObject ruleDoUntilStatement() throws RecognitionException { EObject current = null; @@ -7938,11 +7955,11 @@ public final EObject ruleDoUntilStatement() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:2861:2: ( (otherlv_0= Do ( (lv_actions_1_0= ruleBehaviorActions ) ) otherlv_2= Until otherlv_3= LeftParenthesis ( (lv_condition_4_0= ruleValueExpression ) ) otherlv_5= RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:2862:2: (otherlv_0= Do ( (lv_actions_1_0= ruleBehaviorActions ) ) otherlv_2= Until otherlv_3= LeftParenthesis ( (lv_condition_4_0= ruleValueExpression ) ) otherlv_5= RightParenthesis ) + // InternalBehaviorAnnexParser.g:2863:2: ( (otherlv_0= Do ( (lv_actions_1_0= ruleBehaviorActions ) ) otherlv_2= Until otherlv_3= LeftParenthesis ( (lv_condition_4_0= ruleValueExpression ) ) otherlv_5= RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:2864:2: (otherlv_0= Do ( (lv_actions_1_0= ruleBehaviorActions ) ) otherlv_2= Until otherlv_3= LeftParenthesis ( (lv_condition_4_0= ruleValueExpression ) ) otherlv_5= RightParenthesis ) { - // InternalBehaviorAnnexParser.g:2862:2: (otherlv_0= Do ( (lv_actions_1_0= ruleBehaviorActions ) ) otherlv_2= Until otherlv_3= LeftParenthesis ( (lv_condition_4_0= ruleValueExpression ) ) otherlv_5= RightParenthesis ) - // InternalBehaviorAnnexParser.g:2863:3: otherlv_0= Do ( (lv_actions_1_0= ruleBehaviorActions ) ) otherlv_2= Until otherlv_3= LeftParenthesis ( (lv_condition_4_0= ruleValueExpression ) ) otherlv_5= RightParenthesis + // InternalBehaviorAnnexParser.g:2864:2: (otherlv_0= Do ( (lv_actions_1_0= ruleBehaviorActions ) ) otherlv_2= Until otherlv_3= LeftParenthesis ( (lv_condition_4_0= ruleValueExpression ) ) otherlv_5= RightParenthesis ) + // InternalBehaviorAnnexParser.g:2865:3: otherlv_0= Do ( (lv_actions_1_0= ruleBehaviorActions ) ) otherlv_2= Until otherlv_3= LeftParenthesis ( (lv_condition_4_0= ruleValueExpression ) ) otherlv_5= RightParenthesis { otherlv_0=(Token)match(input,Do,FollowSets000.FOLLOW_40); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -7950,18 +7967,18 @@ public final EObject ruleDoUntilStatement() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getDoUntilStatementAccess().getDoKeyword_0()); } - // InternalBehaviorAnnexParser.g:2867:3: ( (lv_actions_1_0= ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:2868:4: (lv_actions_1_0= ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:2869:3: ( (lv_actions_1_0= ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:2870:4: (lv_actions_1_0= ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:2868:4: (lv_actions_1_0= ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:2869:5: lv_actions_1_0= ruleBehaviorActions + // InternalBehaviorAnnexParser.g:2870:4: (lv_actions_1_0= ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:2871:5: lv_actions_1_0= ruleBehaviorActions { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getDoUntilStatementAccess().getActionsBehaviorActionsParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_60); + pushFollow(FollowSets000.FOLLOW_61); lv_actions_1_0=ruleBehaviorActions(); state._fsp--; @@ -7997,11 +8014,11 @@ public final EObject ruleDoUntilStatement() throws RecognitionException { newLeafNode(otherlv_3, grammarAccess.getDoUntilStatementAccess().getLeftParenthesisKeyword_3()); } - // InternalBehaviorAnnexParser.g:2894:3: ( (lv_condition_4_0= ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:2895:4: (lv_condition_4_0= ruleValueExpression ) + // InternalBehaviorAnnexParser.g:2896:3: ( (lv_condition_4_0= ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:2897:4: (lv_condition_4_0= ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:2895:4: (lv_condition_4_0= ruleValueExpression ) - // InternalBehaviorAnnexParser.g:2896:5: lv_condition_4_0= ruleValueExpression + // InternalBehaviorAnnexParser.g:2897:4: (lv_condition_4_0= ruleValueExpression ) + // InternalBehaviorAnnexParser.g:2898:5: lv_condition_4_0= ruleValueExpression { if ( state.backtracking==0 ) { @@ -8063,7 +8080,7 @@ public final EObject ruleDoUntilStatement() throws RecognitionException { // $ANTLR start "entryRuleElementValues" - // InternalBehaviorAnnexParser.g:2921:1: entryRuleElementValues returns [EObject current=null] : iv_ruleElementValues= ruleElementValues EOF ; + // InternalBehaviorAnnexParser.g:2923:1: entryRuleElementValues returns [EObject current=null] : iv_ruleElementValues= ruleElementValues EOF ; public final EObject entryRuleElementValues() throws RecognitionException { EObject current = null; @@ -8071,8 +8088,8 @@ public final EObject entryRuleElementValues() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2921:54: (iv_ruleElementValues= ruleElementValues EOF ) - // InternalBehaviorAnnexParser.g:2922:2: iv_ruleElementValues= ruleElementValues EOF + // InternalBehaviorAnnexParser.g:2923:54: (iv_ruleElementValues= ruleElementValues EOF ) + // InternalBehaviorAnnexParser.g:2924:2: iv_ruleElementValues= ruleElementValues EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getElementValuesRule()); @@ -8103,7 +8120,7 @@ public final EObject entryRuleElementValues() throws RecognitionException { // $ANTLR start "ruleElementValues" - // InternalBehaviorAnnexParser.g:2928:1: ruleElementValues returns [EObject current=null] : ( ( (lv_lower_0_0= ruleIntegerValue ) ) (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? ) ; + // InternalBehaviorAnnexParser.g:2930:1: ruleElementValues returns [EObject current=null] : ( ( (lv_lower_0_0= ruleIntegerValue ) ) (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? ) ; public final EObject ruleElementValues() throws RecognitionException { EObject current = null; @@ -8117,24 +8134,24 @@ public final EObject ruleElementValues() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:2934:2: ( ( ( (lv_lower_0_0= ruleIntegerValue ) ) (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? ) ) - // InternalBehaviorAnnexParser.g:2935:2: ( ( (lv_lower_0_0= ruleIntegerValue ) ) (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? ) + // InternalBehaviorAnnexParser.g:2936:2: ( ( ( (lv_lower_0_0= ruleIntegerValue ) ) (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? ) ) + // InternalBehaviorAnnexParser.g:2937:2: ( ( (lv_lower_0_0= ruleIntegerValue ) ) (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? ) { - // InternalBehaviorAnnexParser.g:2935:2: ( ( (lv_lower_0_0= ruleIntegerValue ) ) (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? ) - // InternalBehaviorAnnexParser.g:2936:3: ( (lv_lower_0_0= ruleIntegerValue ) ) (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? + // InternalBehaviorAnnexParser.g:2937:2: ( ( (lv_lower_0_0= ruleIntegerValue ) ) (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? ) + // InternalBehaviorAnnexParser.g:2938:3: ( (lv_lower_0_0= ruleIntegerValue ) ) (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? { - // InternalBehaviorAnnexParser.g:2936:3: ( (lv_lower_0_0= ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:2937:4: (lv_lower_0_0= ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:2938:3: ( (lv_lower_0_0= ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:2939:4: (lv_lower_0_0= ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:2937:4: (lv_lower_0_0= ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:2938:5: lv_lower_0_0= ruleIntegerValue + // InternalBehaviorAnnexParser.g:2939:4: (lv_lower_0_0= ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:2940:5: lv_lower_0_0= ruleIntegerValue { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getElementValuesAccess().getLowerIntegerValueParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_61); + pushFollow(FollowSets000.FOLLOW_62); lv_lower_0_0=ruleIntegerValue(); state._fsp--; @@ -8158,16 +8175,16 @@ public final EObject ruleElementValues() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:2955:3: (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? - int alt55=2; - int LA55_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:2957:3: (otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) )? + int alt56=2; + int LA56_0 = input.LA(1); - if ( (LA55_0==FullStopFullStop) ) { - alt55=1; + if ( (LA56_0==FullStopFullStop) ) { + alt56=1; } - switch (alt55) { + switch (alt56) { case 1 : - // InternalBehaviorAnnexParser.g:2956:4: otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:2958:4: otherlv_1= FullStopFullStop ( (lv_upper_2_0= ruleIntegerValue ) ) { otherlv_1=(Token)match(input,FullStopFullStop,FollowSets000.FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -8175,11 +8192,11 @@ public final EObject ruleElementValues() throws RecognitionException { newLeafNode(otherlv_1, grammarAccess.getElementValuesAccess().getFullStopFullStopKeyword_1_0()); } - // InternalBehaviorAnnexParser.g:2960:4: ( (lv_upper_2_0= ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:2961:5: (lv_upper_2_0= ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:2962:4: ( (lv_upper_2_0= ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:2963:5: (lv_upper_2_0= ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:2961:5: (lv_upper_2_0= ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:2962:6: lv_upper_2_0= ruleIntegerValue + // InternalBehaviorAnnexParser.g:2963:5: (lv_upper_2_0= ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:2964:6: lv_upper_2_0= ruleIntegerValue { if ( state.backtracking==0 ) { @@ -8241,7 +8258,7 @@ public final EObject ruleElementValues() throws RecognitionException { // $ANTLR start "entryRuleBehaviorTime" - // InternalBehaviorAnnexParser.g:2984:1: entryRuleBehaviorTime returns [EObject current=null] : iv_ruleBehaviorTime= ruleBehaviorTime EOF ; + // InternalBehaviorAnnexParser.g:2986:1: entryRuleBehaviorTime returns [EObject current=null] : iv_ruleBehaviorTime= ruleBehaviorTime EOF ; public final EObject entryRuleBehaviorTime() throws RecognitionException { EObject current = null; @@ -8249,8 +8266,8 @@ public final EObject entryRuleBehaviorTime() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2984:53: (iv_ruleBehaviorTime= ruleBehaviorTime EOF ) - // InternalBehaviorAnnexParser.g:2985:2: iv_ruleBehaviorTime= ruleBehaviorTime EOF + // InternalBehaviorAnnexParser.g:2986:53: (iv_ruleBehaviorTime= ruleBehaviorTime EOF ) + // InternalBehaviorAnnexParser.g:2987:2: iv_ruleBehaviorTime= ruleBehaviorTime EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBehaviorTimeRule()); @@ -8281,7 +8298,7 @@ public final EObject entryRuleBehaviorTime() throws RecognitionException { // $ANTLR start "ruleBehaviorTime" - // InternalBehaviorAnnexParser.g:2991:1: ruleBehaviorTime returns [EObject current=null] : ( ( (lv_value_0_0= ruleIntegerValue ) ) ( (otherlv_1= RULE_ID ) ) ) ; + // InternalBehaviorAnnexParser.g:2993:1: ruleBehaviorTime returns [EObject current=null] : ( ( (lv_value_0_0= ruleIntegerValue ) ) ( (otherlv_1= RULE_ID ) ) ) ; public final EObject ruleBehaviorTime() throws RecognitionException { EObject current = null; @@ -8293,17 +8310,17 @@ public final EObject ruleBehaviorTime() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:2997:2: ( ( ( (lv_value_0_0= ruleIntegerValue ) ) ( (otherlv_1= RULE_ID ) ) ) ) - // InternalBehaviorAnnexParser.g:2998:2: ( ( (lv_value_0_0= ruleIntegerValue ) ) ( (otherlv_1= RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:2999:2: ( ( ( (lv_value_0_0= ruleIntegerValue ) ) ( (otherlv_1= RULE_ID ) ) ) ) + // InternalBehaviorAnnexParser.g:3000:2: ( ( (lv_value_0_0= ruleIntegerValue ) ) ( (otherlv_1= RULE_ID ) ) ) { - // InternalBehaviorAnnexParser.g:2998:2: ( ( (lv_value_0_0= ruleIntegerValue ) ) ( (otherlv_1= RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:2999:3: ( (lv_value_0_0= ruleIntegerValue ) ) ( (otherlv_1= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:3000:2: ( ( (lv_value_0_0= ruleIntegerValue ) ) ( (otherlv_1= RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:3001:3: ( (lv_value_0_0= ruleIntegerValue ) ) ( (otherlv_1= RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:2999:3: ( (lv_value_0_0= ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:3000:4: (lv_value_0_0= ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:3001:3: ( (lv_value_0_0= ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:3002:4: (lv_value_0_0= ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:3000:4: (lv_value_0_0= ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:3001:5: lv_value_0_0= ruleIntegerValue + // InternalBehaviorAnnexParser.g:3002:4: (lv_value_0_0= ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:3003:5: lv_value_0_0= ruleIntegerValue { if ( state.backtracking==0 ) { @@ -8334,11 +8351,11 @@ public final EObject ruleBehaviorTime() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:3018:3: ( (otherlv_1= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:3019:4: (otherlv_1= RULE_ID ) + // InternalBehaviorAnnexParser.g:3020:3: ( (otherlv_1= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:3021:4: (otherlv_1= RULE_ID ) { - // InternalBehaviorAnnexParser.g:3019:4: (otherlv_1= RULE_ID ) - // InternalBehaviorAnnexParser.g:3020:5: otherlv_1= RULE_ID + // InternalBehaviorAnnexParser.g:3021:4: (otherlv_1= RULE_ID ) + // InternalBehaviorAnnexParser.g:3022:5: otherlv_1= RULE_ID { if ( state.backtracking==0 ) { @@ -8384,7 +8401,7 @@ public final EObject ruleBehaviorTime() throws RecognitionException { // $ANTLR start "entryRuleIntegerValue" - // InternalBehaviorAnnexParser.g:3035:1: entryRuleIntegerValue returns [EObject current=null] : iv_ruleIntegerValue= ruleIntegerValue EOF ; + // InternalBehaviorAnnexParser.g:3037:1: entryRuleIntegerValue returns [EObject current=null] : iv_ruleIntegerValue= ruleIntegerValue EOF ; public final EObject entryRuleIntegerValue() throws RecognitionException { EObject current = null; @@ -8392,8 +8409,8 @@ public final EObject entryRuleIntegerValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3035:53: (iv_ruleIntegerValue= ruleIntegerValue EOF ) - // InternalBehaviorAnnexParser.g:3036:2: iv_ruleIntegerValue= ruleIntegerValue EOF + // InternalBehaviorAnnexParser.g:3037:53: (iv_ruleIntegerValue= ruleIntegerValue EOF ) + // InternalBehaviorAnnexParser.g:3038:2: iv_ruleIntegerValue= ruleIntegerValue EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getIntegerValueRule()); @@ -8424,7 +8441,7 @@ public final EObject entryRuleIntegerValue() throws RecognitionException { // $ANTLR start "ruleIntegerValue" - // InternalBehaviorAnnexParser.g:3042:1: ruleIntegerValue returns [EObject current=null] : (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_HashPropertyReference_1= ruleHashPropertyReference | this_ReferenceExpression_2= ruleReferenceExpression ) ; + // InternalBehaviorAnnexParser.g:3044:1: ruleIntegerValue returns [EObject current=null] : (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_HashPropertyReference_1= ruleHashPropertyReference | this_ReferenceExpression_2= ruleReferenceExpression ) ; public final EObject ruleIntegerValue() throws RecognitionException { EObject current = null; @@ -8439,38 +8456,38 @@ public final EObject ruleIntegerValue() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3048:2: ( (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_HashPropertyReference_1= ruleHashPropertyReference | this_ReferenceExpression_2= ruleReferenceExpression ) ) - // InternalBehaviorAnnexParser.g:3049:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_HashPropertyReference_1= ruleHashPropertyReference | this_ReferenceExpression_2= ruleReferenceExpression ) + // InternalBehaviorAnnexParser.g:3050:2: ( (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_HashPropertyReference_1= ruleHashPropertyReference | this_ReferenceExpression_2= ruleReferenceExpression ) ) + // InternalBehaviorAnnexParser.g:3051:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_HashPropertyReference_1= ruleHashPropertyReference | this_ReferenceExpression_2= ruleReferenceExpression ) { - // InternalBehaviorAnnexParser.g:3049:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_HashPropertyReference_1= ruleHashPropertyReference | this_ReferenceExpression_2= ruleReferenceExpression ) - int alt56=3; + // InternalBehaviorAnnexParser.g:3051:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_HashPropertyReference_1= ruleHashPropertyReference | this_ReferenceExpression_2= ruleReferenceExpression ) + int alt57=3; switch ( input.LA(1) ) { case RULE_INTEGER_LIT: { - alt56=1; + alt57=1; } break; case NumberSign: { - alt56=2; + alt57=2; } break; case RULE_ID: { - alt56=3; + alt57=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 56, 0, input); + new NoViableAltException("", 57, 0, input); throw nvae; } - switch (alt56) { + switch (alt57) { case 1 : - // InternalBehaviorAnnexParser.g:3050:3: this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral + // InternalBehaviorAnnexParser.g:3052:3: this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral { if ( state.backtracking==0 ) { @@ -8492,7 +8509,7 @@ public final EObject ruleIntegerValue() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:3059:3: this_HashPropertyReference_1= ruleHashPropertyReference + // InternalBehaviorAnnexParser.g:3061:3: this_HashPropertyReference_1= ruleHashPropertyReference { if ( state.backtracking==0 ) { @@ -8514,7 +8531,7 @@ public final EObject ruleIntegerValue() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:3068:3: this_ReferenceExpression_2= ruleReferenceExpression + // InternalBehaviorAnnexParser.g:3070:3: this_ReferenceExpression_2= ruleReferenceExpression { if ( state.backtracking==0 ) { @@ -8560,7 +8577,7 @@ public final EObject ruleIntegerValue() throws RecognitionException { // $ANTLR start "entryRuleValueExpression" - // InternalBehaviorAnnexParser.g:3080:1: entryRuleValueExpression returns [EObject current=null] : iv_ruleValueExpression= ruleValueExpression EOF ; + // InternalBehaviorAnnexParser.g:3082:1: entryRuleValueExpression returns [EObject current=null] : iv_ruleValueExpression= ruleValueExpression EOF ; public final EObject entryRuleValueExpression() throws RecognitionException { EObject current = null; @@ -8568,8 +8585,8 @@ public final EObject entryRuleValueExpression() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3080:56: (iv_ruleValueExpression= ruleValueExpression EOF ) - // InternalBehaviorAnnexParser.g:3081:2: iv_ruleValueExpression= ruleValueExpression EOF + // InternalBehaviorAnnexParser.g:3082:56: (iv_ruleValueExpression= ruleValueExpression EOF ) + // InternalBehaviorAnnexParser.g:3083:2: iv_ruleValueExpression= ruleValueExpression EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getValueExpressionRule()); @@ -8600,7 +8617,7 @@ public final EObject entryRuleValueExpression() throws RecognitionException { // $ANTLR start "ruleValueExpression" - // InternalBehaviorAnnexParser.g:3087:1: ruleValueExpression returns [EObject current=null] : (this_Relation_0= ruleRelation ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* ) ; + // InternalBehaviorAnnexParser.g:3089:1: ruleValueExpression returns [EObject current=null] : (this_Relation_0= ruleRelation ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* ) ; public final EObject ruleValueExpression() throws RecognitionException { EObject current = null; @@ -8615,18 +8632,18 @@ public final EObject ruleValueExpression() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3093:2: ( (this_Relation_0= ruleRelation ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* ) ) - // InternalBehaviorAnnexParser.g:3094:2: (this_Relation_0= ruleRelation ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* ) + // InternalBehaviorAnnexParser.g:3095:2: ( (this_Relation_0= ruleRelation ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* ) ) + // InternalBehaviorAnnexParser.g:3096:2: (this_Relation_0= ruleRelation ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* ) { - // InternalBehaviorAnnexParser.g:3094:2: (this_Relation_0= ruleRelation ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* ) - // InternalBehaviorAnnexParser.g:3095:3: this_Relation_0= ruleRelation ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* + // InternalBehaviorAnnexParser.g:3096:2: (this_Relation_0= ruleRelation ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* ) + // InternalBehaviorAnnexParser.g:3097:3: this_Relation_0= ruleRelation ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getValueExpressionAccess().getRelationParserRuleCall_0()); } - pushFollow(FollowSets000.FOLLOW_62); + pushFollow(FollowSets000.FOLLOW_63); this_Relation_0=ruleRelation(); state._fsp--; @@ -8637,23 +8654,23 @@ public final EObject ruleValueExpression() throws RecognitionException { afterParserOrEnumRuleCall(); } - // InternalBehaviorAnnexParser.g:3103:3: ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* - loop57: + // InternalBehaviorAnnexParser.g:3105:3: ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* + loop58: do { - int alt57=2; - int LA57_0 = input.LA(1); + int alt58=2; + int LA58_0 = input.LA(1); - if ( (LA57_0==And||LA57_0==Xor||LA57_0==Or) ) { - alt57=1; + if ( (LA58_0==And||LA58_0==Xor||LA58_0==Or) ) { + alt58=1; } - switch (alt57) { + switch (alt58) { case 1 : - // InternalBehaviorAnnexParser.g:3104:4: () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) + // InternalBehaviorAnnexParser.g:3106:4: () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) { - // InternalBehaviorAnnexParser.g:3104:4: () - // InternalBehaviorAnnexParser.g:3105:5: + // InternalBehaviorAnnexParser.g:3106:4: () + // InternalBehaviorAnnexParser.g:3107:5: { if ( state.backtracking==0 ) { @@ -8665,11 +8682,11 @@ public final EObject ruleValueExpression() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:3111:4: ( (lv_operator_2_0= ruleLogicalOperator ) ) - // InternalBehaviorAnnexParser.g:3112:5: (lv_operator_2_0= ruleLogicalOperator ) + // InternalBehaviorAnnexParser.g:3113:4: ( (lv_operator_2_0= ruleLogicalOperator ) ) + // InternalBehaviorAnnexParser.g:3114:5: (lv_operator_2_0= ruleLogicalOperator ) { - // InternalBehaviorAnnexParser.g:3112:5: (lv_operator_2_0= ruleLogicalOperator ) - // InternalBehaviorAnnexParser.g:3113:6: lv_operator_2_0= ruleLogicalOperator + // InternalBehaviorAnnexParser.g:3114:5: (lv_operator_2_0= ruleLogicalOperator ) + // InternalBehaviorAnnexParser.g:3115:6: lv_operator_2_0= ruleLogicalOperator { if ( state.backtracking==0 ) { @@ -8700,18 +8717,18 @@ public final EObject ruleValueExpression() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:3130:4: ( (lv_right_3_0= ruleRelation ) ) - // InternalBehaviorAnnexParser.g:3131:5: (lv_right_3_0= ruleRelation ) + // InternalBehaviorAnnexParser.g:3132:4: ( (lv_right_3_0= ruleRelation ) ) + // InternalBehaviorAnnexParser.g:3133:5: (lv_right_3_0= ruleRelation ) { - // InternalBehaviorAnnexParser.g:3131:5: (lv_right_3_0= ruleRelation ) - // InternalBehaviorAnnexParser.g:3132:6: lv_right_3_0= ruleRelation + // InternalBehaviorAnnexParser.g:3133:5: (lv_right_3_0= ruleRelation ) + // InternalBehaviorAnnexParser.g:3134:6: lv_right_3_0= ruleRelation { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getValueExpressionAccess().getRightRelationParserRuleCall_1_2_0()); } - pushFollow(FollowSets000.FOLLOW_62); + pushFollow(FollowSets000.FOLLOW_63); lv_right_3_0=ruleRelation(); state._fsp--; @@ -8740,7 +8757,7 @@ public final EObject ruleValueExpression() throws RecognitionException { break; default : - break loop57; + break loop58; } } while (true); @@ -8769,7 +8786,7 @@ public final EObject ruleValueExpression() throws RecognitionException { // $ANTLR start "entryRuleLogicalOperator" - // InternalBehaviorAnnexParser.g:3154:1: entryRuleLogicalOperator returns [String current=null] : iv_ruleLogicalOperator= ruleLogicalOperator EOF ; + // InternalBehaviorAnnexParser.g:3156:1: entryRuleLogicalOperator returns [String current=null] : iv_ruleLogicalOperator= ruleLogicalOperator EOF ; public final String entryRuleLogicalOperator() throws RecognitionException { String current = null; @@ -8777,8 +8794,8 @@ public final String entryRuleLogicalOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3154:55: (iv_ruleLogicalOperator= ruleLogicalOperator EOF ) - // InternalBehaviorAnnexParser.g:3155:2: iv_ruleLogicalOperator= ruleLogicalOperator EOF + // InternalBehaviorAnnexParser.g:3156:55: (iv_ruleLogicalOperator= ruleLogicalOperator EOF ) + // InternalBehaviorAnnexParser.g:3157:2: iv_ruleLogicalOperator= ruleLogicalOperator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getLogicalOperatorRule()); @@ -8809,7 +8826,7 @@ public final String entryRuleLogicalOperator() throws RecognitionException { // $ANTLR start "ruleLogicalOperator" - // InternalBehaviorAnnexParser.g:3161:1: ruleLogicalOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_LogicalAndOperator_0= ruleLogicalAndOperator | this_LogicalOrOperator_1= ruleLogicalOrOperator ) ; + // InternalBehaviorAnnexParser.g:3163:1: ruleLogicalOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_LogicalAndOperator_0= ruleLogicalAndOperator | this_LogicalOrOperator_1= ruleLogicalOrOperator ) ; public final AntlrDatatypeRuleToken ruleLogicalOperator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -8822,29 +8839,29 @@ public final AntlrDatatypeRuleToken ruleLogicalOperator() throws RecognitionExce enterRule(); try { - // InternalBehaviorAnnexParser.g:3167:2: ( (this_LogicalAndOperator_0= ruleLogicalAndOperator | this_LogicalOrOperator_1= ruleLogicalOrOperator ) ) - // InternalBehaviorAnnexParser.g:3168:2: (this_LogicalAndOperator_0= ruleLogicalAndOperator | this_LogicalOrOperator_1= ruleLogicalOrOperator ) + // InternalBehaviorAnnexParser.g:3169:2: ( (this_LogicalAndOperator_0= ruleLogicalAndOperator | this_LogicalOrOperator_1= ruleLogicalOrOperator ) ) + // InternalBehaviorAnnexParser.g:3170:2: (this_LogicalAndOperator_0= ruleLogicalAndOperator | this_LogicalOrOperator_1= ruleLogicalOrOperator ) { - // InternalBehaviorAnnexParser.g:3168:2: (this_LogicalAndOperator_0= ruleLogicalAndOperator | this_LogicalOrOperator_1= ruleLogicalOrOperator ) - int alt58=2; - int LA58_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3170:2: (this_LogicalAndOperator_0= ruleLogicalAndOperator | this_LogicalOrOperator_1= ruleLogicalOrOperator ) + int alt59=2; + int LA59_0 = input.LA(1); - if ( (LA58_0==And) ) { - alt58=1; + if ( (LA59_0==And) ) { + alt59=1; } - else if ( (LA58_0==Xor||LA58_0==Or) ) { - alt58=2; + else if ( (LA59_0==Xor||LA59_0==Or) ) { + alt59=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 58, 0, input); + new NoViableAltException("", 59, 0, input); throw nvae; } - switch (alt58) { + switch (alt59) { case 1 : - // InternalBehaviorAnnexParser.g:3169:3: this_LogicalAndOperator_0= ruleLogicalAndOperator + // InternalBehaviorAnnexParser.g:3171:3: this_LogicalAndOperator_0= ruleLogicalAndOperator { if ( state.backtracking==0 ) { @@ -8870,7 +8887,7 @@ else if ( (LA58_0==Xor||LA58_0==Or) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3180:3: this_LogicalOrOperator_1= ruleLogicalOrOperator + // InternalBehaviorAnnexParser.g:3182:3: this_LogicalOrOperator_1= ruleLogicalOrOperator { if ( state.backtracking==0 ) { @@ -8920,7 +8937,7 @@ else if ( (LA58_0==Xor||LA58_0==Or) ) { // $ANTLR start "entryRuleLogicalOrOperator" - // InternalBehaviorAnnexParser.g:3194:1: entryRuleLogicalOrOperator returns [String current=null] : iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF ; + // InternalBehaviorAnnexParser.g:3196:1: entryRuleLogicalOrOperator returns [String current=null] : iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF ; public final String entryRuleLogicalOrOperator() throws RecognitionException { String current = null; @@ -8928,8 +8945,8 @@ public final String entryRuleLogicalOrOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3194:57: (iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF ) - // InternalBehaviorAnnexParser.g:3195:2: iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF + // InternalBehaviorAnnexParser.g:3196:57: (iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF ) + // InternalBehaviorAnnexParser.g:3197:2: iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getLogicalOrOperatorRule()); @@ -8960,7 +8977,7 @@ public final String entryRuleLogicalOrOperator() throws RecognitionException { // $ANTLR start "ruleLogicalOrOperator" - // InternalBehaviorAnnexParser.g:3201:1: ruleLogicalOrOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= Or (kw= Else )? ) | kw= Xor ) ; + // InternalBehaviorAnnexParser.g:3203:1: ruleLogicalOrOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= Or (kw= Else )? ) | kw= Xor ) ; public final AntlrDatatypeRuleToken ruleLogicalOrOperator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -8970,50 +8987,50 @@ public final AntlrDatatypeRuleToken ruleLogicalOrOperator() throws RecognitionEx enterRule(); try { - // InternalBehaviorAnnexParser.g:3207:2: ( ( (kw= Or (kw= Else )? ) | kw= Xor ) ) - // InternalBehaviorAnnexParser.g:3208:2: ( (kw= Or (kw= Else )? ) | kw= Xor ) + // InternalBehaviorAnnexParser.g:3209:2: ( ( (kw= Or (kw= Else )? ) | kw= Xor ) ) + // InternalBehaviorAnnexParser.g:3210:2: ( (kw= Or (kw= Else )? ) | kw= Xor ) { - // InternalBehaviorAnnexParser.g:3208:2: ( (kw= Or (kw= Else )? ) | kw= Xor ) - int alt60=2; - int LA60_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3210:2: ( (kw= Or (kw= Else )? ) | kw= Xor ) + int alt61=2; + int LA61_0 = input.LA(1); - if ( (LA60_0==Or) ) { - alt60=1; + if ( (LA61_0==Or) ) { + alt61=1; } - else if ( (LA60_0==Xor) ) { - alt60=2; + else if ( (LA61_0==Xor) ) { + alt61=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 60, 0, input); + new NoViableAltException("", 61, 0, input); throw nvae; } - switch (alt60) { + switch (alt61) { case 1 : - // InternalBehaviorAnnexParser.g:3209:3: (kw= Or (kw= Else )? ) + // InternalBehaviorAnnexParser.g:3211:3: (kw= Or (kw= Else )? ) { - // InternalBehaviorAnnexParser.g:3209:3: (kw= Or (kw= Else )? ) - // InternalBehaviorAnnexParser.g:3210:4: kw= Or (kw= Else )? + // InternalBehaviorAnnexParser.g:3211:3: (kw= Or (kw= Else )? ) + // InternalBehaviorAnnexParser.g:3212:4: kw= Or (kw= Else )? { - kw=(Token)match(input,Or,FollowSets000.FOLLOW_63); if (state.failed) return current; + kw=(Token)match(input,Or,FollowSets000.FOLLOW_64); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(kw); newLeafNode(kw, grammarAccess.getLogicalOrOperatorAccess().getOrKeyword_0_0()); } - // InternalBehaviorAnnexParser.g:3215:4: (kw= Else )? - int alt59=2; - int LA59_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3217:4: (kw= Else )? + int alt60=2; + int LA60_0 = input.LA(1); - if ( (LA59_0==Else) ) { - alt59=1; + if ( (LA60_0==Else) ) { + alt60=1; } - switch (alt59) { + switch (alt60) { case 1 : - // InternalBehaviorAnnexParser.g:3216:5: kw= Else + // InternalBehaviorAnnexParser.g:3218:5: kw= Else { kw=(Token)match(input,Else,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -9035,7 +9052,7 @@ else if ( (LA60_0==Xor) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3224:3: kw= Xor + // InternalBehaviorAnnexParser.g:3226:3: kw= Xor { kw=(Token)match(input,Xor,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -9072,7 +9089,7 @@ else if ( (LA60_0==Xor) ) { // $ANTLR start "entryRuleLogicalAndOperator" - // InternalBehaviorAnnexParser.g:3233:1: entryRuleLogicalAndOperator returns [String current=null] : iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF ; + // InternalBehaviorAnnexParser.g:3235:1: entryRuleLogicalAndOperator returns [String current=null] : iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF ; public final String entryRuleLogicalAndOperator() throws RecognitionException { String current = null; @@ -9080,8 +9097,8 @@ public final String entryRuleLogicalAndOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3233:58: (iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF ) - // InternalBehaviorAnnexParser.g:3234:2: iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF + // InternalBehaviorAnnexParser.g:3235:58: (iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF ) + // InternalBehaviorAnnexParser.g:3236:2: iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getLogicalAndOperatorRule()); @@ -9112,7 +9129,7 @@ public final String entryRuleLogicalAndOperator() throws RecognitionException { // $ANTLR start "ruleLogicalAndOperator" - // InternalBehaviorAnnexParser.g:3240:1: ruleLogicalAndOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= And (kw= Then )? ) ; + // InternalBehaviorAnnexParser.g:3242:1: ruleLogicalAndOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= And (kw= Then )? ) ; public final AntlrDatatypeRuleToken ruleLogicalAndOperator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -9122,29 +9139,29 @@ public final AntlrDatatypeRuleToken ruleLogicalAndOperator() throws RecognitionE enterRule(); try { - // InternalBehaviorAnnexParser.g:3246:2: ( (kw= And (kw= Then )? ) ) - // InternalBehaviorAnnexParser.g:3247:2: (kw= And (kw= Then )? ) + // InternalBehaviorAnnexParser.g:3248:2: ( (kw= And (kw= Then )? ) ) + // InternalBehaviorAnnexParser.g:3249:2: (kw= And (kw= Then )? ) { - // InternalBehaviorAnnexParser.g:3247:2: (kw= And (kw= Then )? ) - // InternalBehaviorAnnexParser.g:3248:3: kw= And (kw= Then )? + // InternalBehaviorAnnexParser.g:3249:2: (kw= And (kw= Then )? ) + // InternalBehaviorAnnexParser.g:3250:3: kw= And (kw= Then )? { - kw=(Token)match(input,And,FollowSets000.FOLLOW_64); if (state.failed) return current; + kw=(Token)match(input,And,FollowSets000.FOLLOW_65); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(kw); newLeafNode(kw, grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); } - // InternalBehaviorAnnexParser.g:3253:3: (kw= Then )? - int alt61=2; - int LA61_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3255:3: (kw= Then )? + int alt62=2; + int LA62_0 = input.LA(1); - if ( (LA61_0==Then) ) { - alt61=1; + if ( (LA62_0==Then) ) { + alt62=1; } - switch (alt61) { + switch (alt62) { case 1 : - // InternalBehaviorAnnexParser.g:3254:4: kw= Then + // InternalBehaviorAnnexParser.g:3256:4: kw= Then { kw=(Token)match(input,Then,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -9184,7 +9201,7 @@ public final AntlrDatatypeRuleToken ruleLogicalAndOperator() throws RecognitionE // $ANTLR start "entryRuleRelation" - // InternalBehaviorAnnexParser.g:3264:1: entryRuleRelation returns [EObject current=null] : iv_ruleRelation= ruleRelation EOF ; + // InternalBehaviorAnnexParser.g:3266:1: entryRuleRelation returns [EObject current=null] : iv_ruleRelation= ruleRelation EOF ; public final EObject entryRuleRelation() throws RecognitionException { EObject current = null; @@ -9192,8 +9209,8 @@ public final EObject entryRuleRelation() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3264:49: (iv_ruleRelation= ruleRelation EOF ) - // InternalBehaviorAnnexParser.g:3265:2: iv_ruleRelation= ruleRelation EOF + // InternalBehaviorAnnexParser.g:3266:49: (iv_ruleRelation= ruleRelation EOF ) + // InternalBehaviorAnnexParser.g:3267:2: iv_ruleRelation= ruleRelation EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getRelationRule()); @@ -9224,7 +9241,7 @@ public final EObject entryRuleRelation() throws RecognitionException { // $ANTLR start "ruleRelation" - // InternalBehaviorAnnexParser.g:3271:1: ruleRelation returns [EObject current=null] : (this_SimpleExpression_0= ruleSimpleExpression ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? ) ; + // InternalBehaviorAnnexParser.g:3273:1: ruleRelation returns [EObject current=null] : (this_SimpleExpression_0= ruleSimpleExpression ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? ) ; public final EObject ruleRelation() throws RecognitionException { EObject current = null; @@ -9239,18 +9256,18 @@ public final EObject ruleRelation() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3277:2: ( (this_SimpleExpression_0= ruleSimpleExpression ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? ) ) - // InternalBehaviorAnnexParser.g:3278:2: (this_SimpleExpression_0= ruleSimpleExpression ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? ) + // InternalBehaviorAnnexParser.g:3279:2: ( (this_SimpleExpression_0= ruleSimpleExpression ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? ) ) + // InternalBehaviorAnnexParser.g:3280:2: (this_SimpleExpression_0= ruleSimpleExpression ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? ) { - // InternalBehaviorAnnexParser.g:3278:2: (this_SimpleExpression_0= ruleSimpleExpression ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? ) - // InternalBehaviorAnnexParser.g:3279:3: this_SimpleExpression_0= ruleSimpleExpression ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? + // InternalBehaviorAnnexParser.g:3280:2: (this_SimpleExpression_0= ruleSimpleExpression ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? ) + // InternalBehaviorAnnexParser.g:3281:3: this_SimpleExpression_0= ruleSimpleExpression ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getRelationAccess().getSimpleExpressionParserRuleCall_0()); } - pushFollow(FollowSets000.FOLLOW_65); + pushFollow(FollowSets000.FOLLOW_66); this_SimpleExpression_0=ruleSimpleExpression(); state._fsp--; @@ -9261,19 +9278,19 @@ public final EObject ruleRelation() throws RecognitionException { afterParserOrEnumRuleCall(); } - // InternalBehaviorAnnexParser.g:3287:3: ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? - int alt62=2; - int LA62_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3289:3: ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? + int alt63=2; + int LA63_0 = input.LA(1); - if ( (LA62_0==ExclamationMarkEqualsSign||LA62_0==LessThanSignEqualsSign||LA62_0==GreaterThanSignEqualsSign||(LA62_0>=LessThanSign && LA62_0<=GreaterThanSign)) ) { - alt62=1; + if ( (LA63_0==ExclamationMarkEqualsSign||LA63_0==LessThanSignEqualsSign||LA63_0==GreaterThanSignEqualsSign||(LA63_0>=LessThanSign && LA63_0<=GreaterThanSign)) ) { + alt63=1; } - switch (alt62) { + switch (alt63) { case 1 : - // InternalBehaviorAnnexParser.g:3288:4: () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) + // InternalBehaviorAnnexParser.g:3290:4: () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) { - // InternalBehaviorAnnexParser.g:3288:4: () - // InternalBehaviorAnnexParser.g:3289:5: + // InternalBehaviorAnnexParser.g:3290:4: () + // InternalBehaviorAnnexParser.g:3291:5: { if ( state.backtracking==0 ) { @@ -9285,11 +9302,11 @@ public final EObject ruleRelation() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:3295:4: ( (lv_operator_2_0= ruleRelationalOperator ) ) - // InternalBehaviorAnnexParser.g:3296:5: (lv_operator_2_0= ruleRelationalOperator ) + // InternalBehaviorAnnexParser.g:3297:4: ( (lv_operator_2_0= ruleRelationalOperator ) ) + // InternalBehaviorAnnexParser.g:3298:5: (lv_operator_2_0= ruleRelationalOperator ) { - // InternalBehaviorAnnexParser.g:3296:5: (lv_operator_2_0= ruleRelationalOperator ) - // InternalBehaviorAnnexParser.g:3297:6: lv_operator_2_0= ruleRelationalOperator + // InternalBehaviorAnnexParser.g:3298:5: (lv_operator_2_0= ruleRelationalOperator ) + // InternalBehaviorAnnexParser.g:3299:6: lv_operator_2_0= ruleRelationalOperator { if ( state.backtracking==0 ) { @@ -9320,11 +9337,11 @@ public final EObject ruleRelation() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:3314:4: ( (lv_right_3_0= ruleSimpleExpression ) ) - // InternalBehaviorAnnexParser.g:3315:5: (lv_right_3_0= ruleSimpleExpression ) + // InternalBehaviorAnnexParser.g:3316:4: ( (lv_right_3_0= ruleSimpleExpression ) ) + // InternalBehaviorAnnexParser.g:3317:5: (lv_right_3_0= ruleSimpleExpression ) { - // InternalBehaviorAnnexParser.g:3315:5: (lv_right_3_0= ruleSimpleExpression ) - // InternalBehaviorAnnexParser.g:3316:6: lv_right_3_0= ruleSimpleExpression + // InternalBehaviorAnnexParser.g:3317:5: (lv_right_3_0= ruleSimpleExpression ) + // InternalBehaviorAnnexParser.g:3318:6: lv_right_3_0= ruleSimpleExpression { if ( state.backtracking==0 ) { @@ -9386,7 +9403,7 @@ public final EObject ruleRelation() throws RecognitionException { // $ANTLR start "entryRuleRelationalOperator" - // InternalBehaviorAnnexParser.g:3338:1: entryRuleRelationalOperator returns [String current=null] : iv_ruleRelationalOperator= ruleRelationalOperator EOF ; + // InternalBehaviorAnnexParser.g:3340:1: entryRuleRelationalOperator returns [String current=null] : iv_ruleRelationalOperator= ruleRelationalOperator EOF ; public final String entryRuleRelationalOperator() throws RecognitionException { String current = null; @@ -9394,8 +9411,8 @@ public final String entryRuleRelationalOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3338:58: (iv_ruleRelationalOperator= ruleRelationalOperator EOF ) - // InternalBehaviorAnnexParser.g:3339:2: iv_ruleRelationalOperator= ruleRelationalOperator EOF + // InternalBehaviorAnnexParser.g:3340:58: (iv_ruleRelationalOperator= ruleRelationalOperator EOF ) + // InternalBehaviorAnnexParser.g:3341:2: iv_ruleRelationalOperator= ruleRelationalOperator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getRelationalOperatorRule()); @@ -9426,7 +9443,7 @@ public final String entryRuleRelationalOperator() throws RecognitionException { // $ANTLR start "ruleRelationalOperator" - // InternalBehaviorAnnexParser.g:3345:1: ruleRelationalOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= EqualsSign | kw= ExclamationMarkEqualsSign | kw= LessThanSign | kw= LessThanSignEqualsSign | kw= GreaterThanSign | kw= GreaterThanSignEqualsSign ) ; + // InternalBehaviorAnnexParser.g:3347:1: ruleRelationalOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= EqualsSign | kw= ExclamationMarkEqualsSign | kw= LessThanSign | kw= LessThanSignEqualsSign | kw= GreaterThanSign | kw= GreaterThanSignEqualsSign ) ; public final AntlrDatatypeRuleToken ruleRelationalOperator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -9436,53 +9453,53 @@ public final AntlrDatatypeRuleToken ruleRelationalOperator() throws RecognitionE enterRule(); try { - // InternalBehaviorAnnexParser.g:3351:2: ( (kw= EqualsSign | kw= ExclamationMarkEqualsSign | kw= LessThanSign | kw= LessThanSignEqualsSign | kw= GreaterThanSign | kw= GreaterThanSignEqualsSign ) ) - // InternalBehaviorAnnexParser.g:3352:2: (kw= EqualsSign | kw= ExclamationMarkEqualsSign | kw= LessThanSign | kw= LessThanSignEqualsSign | kw= GreaterThanSign | kw= GreaterThanSignEqualsSign ) + // InternalBehaviorAnnexParser.g:3353:2: ( (kw= EqualsSign | kw= ExclamationMarkEqualsSign | kw= LessThanSign | kw= LessThanSignEqualsSign | kw= GreaterThanSign | kw= GreaterThanSignEqualsSign ) ) + // InternalBehaviorAnnexParser.g:3354:2: (kw= EqualsSign | kw= ExclamationMarkEqualsSign | kw= LessThanSign | kw= LessThanSignEqualsSign | kw= GreaterThanSign | kw= GreaterThanSignEqualsSign ) { - // InternalBehaviorAnnexParser.g:3352:2: (kw= EqualsSign | kw= ExclamationMarkEqualsSign | kw= LessThanSign | kw= LessThanSignEqualsSign | kw= GreaterThanSign | kw= GreaterThanSignEqualsSign ) - int alt63=6; + // InternalBehaviorAnnexParser.g:3354:2: (kw= EqualsSign | kw= ExclamationMarkEqualsSign | kw= LessThanSign | kw= LessThanSignEqualsSign | kw= GreaterThanSign | kw= GreaterThanSignEqualsSign ) + int alt64=6; switch ( input.LA(1) ) { case EqualsSign: { - alt63=1; + alt64=1; } break; case ExclamationMarkEqualsSign: { - alt63=2; + alt64=2; } break; case LessThanSign: { - alt63=3; + alt64=3; } break; case LessThanSignEqualsSign: { - alt63=4; + alt64=4; } break; case GreaterThanSign: { - alt63=5; + alt64=5; } break; case GreaterThanSignEqualsSign: { - alt63=6; + alt64=6; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 63, 0, input); + new NoViableAltException("", 64, 0, input); throw nvae; } - switch (alt63) { + switch (alt64) { case 1 : - // InternalBehaviorAnnexParser.g:3353:3: kw= EqualsSign + // InternalBehaviorAnnexParser.g:3355:3: kw= EqualsSign { kw=(Token)match(input,EqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -9495,7 +9512,7 @@ public final AntlrDatatypeRuleToken ruleRelationalOperator() throws RecognitionE } break; case 2 : - // InternalBehaviorAnnexParser.g:3359:3: kw= ExclamationMarkEqualsSign + // InternalBehaviorAnnexParser.g:3361:3: kw= ExclamationMarkEqualsSign { kw=(Token)match(input,ExclamationMarkEqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -9508,7 +9525,7 @@ public final AntlrDatatypeRuleToken ruleRelationalOperator() throws RecognitionE } break; case 3 : - // InternalBehaviorAnnexParser.g:3365:3: kw= LessThanSign + // InternalBehaviorAnnexParser.g:3367:3: kw= LessThanSign { kw=(Token)match(input,LessThanSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -9521,7 +9538,7 @@ public final AntlrDatatypeRuleToken ruleRelationalOperator() throws RecognitionE } break; case 4 : - // InternalBehaviorAnnexParser.g:3371:3: kw= LessThanSignEqualsSign + // InternalBehaviorAnnexParser.g:3373:3: kw= LessThanSignEqualsSign { kw=(Token)match(input,LessThanSignEqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -9534,7 +9551,7 @@ public final AntlrDatatypeRuleToken ruleRelationalOperator() throws RecognitionE } break; case 5 : - // InternalBehaviorAnnexParser.g:3377:3: kw= GreaterThanSign + // InternalBehaviorAnnexParser.g:3379:3: kw= GreaterThanSign { kw=(Token)match(input,GreaterThanSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -9547,7 +9564,7 @@ public final AntlrDatatypeRuleToken ruleRelationalOperator() throws RecognitionE } break; case 6 : - // InternalBehaviorAnnexParser.g:3383:3: kw= GreaterThanSignEqualsSign + // InternalBehaviorAnnexParser.g:3385:3: kw= GreaterThanSignEqualsSign { kw=(Token)match(input,GreaterThanSignEqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -9584,7 +9601,7 @@ public final AntlrDatatypeRuleToken ruleRelationalOperator() throws RecognitionE // $ANTLR start "entryRuleSimpleExpression" - // InternalBehaviorAnnexParser.g:3392:1: entryRuleSimpleExpression returns [EObject current=null] : iv_ruleSimpleExpression= ruleSimpleExpression EOF ; + // InternalBehaviorAnnexParser.g:3394:1: entryRuleSimpleExpression returns [EObject current=null] : iv_ruleSimpleExpression= ruleSimpleExpression EOF ; public final EObject entryRuleSimpleExpression() throws RecognitionException { EObject current = null; @@ -9592,8 +9609,8 @@ public final EObject entryRuleSimpleExpression() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3392:57: (iv_ruleSimpleExpression= ruleSimpleExpression EOF ) - // InternalBehaviorAnnexParser.g:3393:2: iv_ruleSimpleExpression= ruleSimpleExpression EOF + // InternalBehaviorAnnexParser.g:3394:57: (iv_ruleSimpleExpression= ruleSimpleExpression EOF ) + // InternalBehaviorAnnexParser.g:3395:2: iv_ruleSimpleExpression= ruleSimpleExpression EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSimpleExpressionRule()); @@ -9624,7 +9641,7 @@ public final EObject entryRuleSimpleExpression() throws RecognitionException { // $ANTLR start "ruleSimpleExpression" - // InternalBehaviorAnnexParser.g:3399:1: ruleSimpleExpression returns [EObject current=null] : ( ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* ) ; + // InternalBehaviorAnnexParser.g:3401:1: ruleSimpleExpression returns [EObject current=null] : ( ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* ) ; public final EObject ruleSimpleExpression() throws RecognitionException { EObject current = null; @@ -9643,38 +9660,38 @@ public final EObject ruleSimpleExpression() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3405:2: ( ( ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* ) ) - // InternalBehaviorAnnexParser.g:3406:2: ( ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* ) + // InternalBehaviorAnnexParser.g:3407:2: ( ( ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* ) ) + // InternalBehaviorAnnexParser.g:3408:2: ( ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* ) { - // InternalBehaviorAnnexParser.g:3406:2: ( ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* ) - // InternalBehaviorAnnexParser.g:3407:3: ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* + // InternalBehaviorAnnexParser.g:3408:2: ( ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* ) + // InternalBehaviorAnnexParser.g:3409:3: ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* { - // InternalBehaviorAnnexParser.g:3407:3: ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) - int alt64=2; - int LA64_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3409:3: ( ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) | this_Term_3= ruleTerm ) + int alt65=2; + int LA65_0 = input.LA(1); - if ( (LA64_0==PlusSign||LA64_0==HyphenMinus) ) { - alt64=1; + if ( (LA65_0==PlusSign||LA65_0==HyphenMinus) ) { + alt65=1; } - else if ( (LA64_0==False||LA64_0==True||LA64_0==Abs||LA64_0==Not||LA64_0==NumberSign||LA64_0==LeftParenthesis||LA64_0==RULE_REAL_LIT||LA64_0==RULE_INTEGER_LIT||(LA64_0>=RULE_STRING && LA64_0<=RULE_ID)) ) { - alt64=2; + else if ( (LA65_0==False||LA65_0==True||LA65_0==Abs||LA65_0==Not||LA65_0==NumberSign||LA65_0==LeftParenthesis||LA65_0==RULE_REAL_LIT||LA65_0==RULE_INTEGER_LIT||(LA65_0>=RULE_STRING && LA65_0<=RULE_ID)) ) { + alt65=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 64, 0, input); + new NoViableAltException("", 65, 0, input); throw nvae; } - switch (alt64) { + switch (alt65) { case 1 : - // InternalBehaviorAnnexParser.g:3408:4: ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) + // InternalBehaviorAnnexParser.g:3410:4: ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) { - // InternalBehaviorAnnexParser.g:3408:4: ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) - // InternalBehaviorAnnexParser.g:3409:5: () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) + // InternalBehaviorAnnexParser.g:3410:4: ( () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) ) + // InternalBehaviorAnnexParser.g:3411:5: () ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) ( (lv_operand_2_0= ruleTerm ) ) { - // InternalBehaviorAnnexParser.g:3409:5: () - // InternalBehaviorAnnexParser.g:3410:6: + // InternalBehaviorAnnexParser.g:3411:5: () + // InternalBehaviorAnnexParser.g:3412:6: { if ( state.backtracking==0 ) { @@ -9686,11 +9703,11 @@ else if ( (LA64_0==False||LA64_0==True||LA64_0==Abs||LA64_0==Not||LA64_0==Number } - // InternalBehaviorAnnexParser.g:3416:5: ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) - // InternalBehaviorAnnexParser.g:3417:6: (lv_operator_1_0= ruleUnaryAddingOperator ) + // InternalBehaviorAnnexParser.g:3418:5: ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) + // InternalBehaviorAnnexParser.g:3419:6: (lv_operator_1_0= ruleUnaryAddingOperator ) { - // InternalBehaviorAnnexParser.g:3417:6: (lv_operator_1_0= ruleUnaryAddingOperator ) - // InternalBehaviorAnnexParser.g:3418:7: lv_operator_1_0= ruleUnaryAddingOperator + // InternalBehaviorAnnexParser.g:3419:6: (lv_operator_1_0= ruleUnaryAddingOperator ) + // InternalBehaviorAnnexParser.g:3420:7: lv_operator_1_0= ruleUnaryAddingOperator { if ( state.backtracking==0 ) { @@ -9721,18 +9738,18 @@ else if ( (LA64_0==False||LA64_0==True||LA64_0==Abs||LA64_0==Not||LA64_0==Number } - // InternalBehaviorAnnexParser.g:3435:5: ( (lv_operand_2_0= ruleTerm ) ) - // InternalBehaviorAnnexParser.g:3436:6: (lv_operand_2_0= ruleTerm ) + // InternalBehaviorAnnexParser.g:3437:5: ( (lv_operand_2_0= ruleTerm ) ) + // InternalBehaviorAnnexParser.g:3438:6: (lv_operand_2_0= ruleTerm ) { - // InternalBehaviorAnnexParser.g:3436:6: (lv_operand_2_0= ruleTerm ) - // InternalBehaviorAnnexParser.g:3437:7: lv_operand_2_0= ruleTerm + // InternalBehaviorAnnexParser.g:3438:6: (lv_operand_2_0= ruleTerm ) + // InternalBehaviorAnnexParser.g:3439:7: lv_operand_2_0= ruleTerm { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSimpleExpressionAccess().getOperandTermParserRuleCall_0_0_2_0()); } - pushFollow(FollowSets000.FOLLOW_66); + pushFollow(FollowSets000.FOLLOW_67); lv_operand_2_0=ruleTerm(); state._fsp--; @@ -9763,14 +9780,14 @@ else if ( (LA64_0==False||LA64_0==True||LA64_0==Abs||LA64_0==Not||LA64_0==Number } break; case 2 : - // InternalBehaviorAnnexParser.g:3456:4: this_Term_3= ruleTerm + // InternalBehaviorAnnexParser.g:3458:4: this_Term_3= ruleTerm { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSimpleExpressionAccess().getTermParserRuleCall_0_1()); } - pushFollow(FollowSets000.FOLLOW_66); + pushFollow(FollowSets000.FOLLOW_67); this_Term_3=ruleTerm(); state._fsp--; @@ -9787,23 +9804,23 @@ else if ( (LA64_0==False||LA64_0==True||LA64_0==Abs||LA64_0==Not||LA64_0==Number } - // InternalBehaviorAnnexParser.g:3465:3: ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* - loop65: + // InternalBehaviorAnnexParser.g:3467:3: ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* + loop66: do { - int alt65=2; - int LA65_0 = input.LA(1); + int alt66=2; + int LA66_0 = input.LA(1); - if ( (LA65_0==PlusSign||LA65_0==HyphenMinus) ) { - alt65=1; + if ( (LA66_0==PlusSign||LA66_0==HyphenMinus) ) { + alt66=1; } - switch (alt65) { + switch (alt66) { case 1 : - // InternalBehaviorAnnexParser.g:3466:4: () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) + // InternalBehaviorAnnexParser.g:3468:4: () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) { - // InternalBehaviorAnnexParser.g:3466:4: () - // InternalBehaviorAnnexParser.g:3467:5: + // InternalBehaviorAnnexParser.g:3468:4: () + // InternalBehaviorAnnexParser.g:3469:5: { if ( state.backtracking==0 ) { @@ -9815,11 +9832,11 @@ else if ( (LA64_0==False||LA64_0==True||LA64_0==Abs||LA64_0==Not||LA64_0==Number } - // InternalBehaviorAnnexParser.g:3473:4: ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) - // InternalBehaviorAnnexParser.g:3474:5: (lv_operator_5_0= ruleBinaryAddingOperator ) + // InternalBehaviorAnnexParser.g:3475:4: ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) + // InternalBehaviorAnnexParser.g:3476:5: (lv_operator_5_0= ruleBinaryAddingOperator ) { - // InternalBehaviorAnnexParser.g:3474:5: (lv_operator_5_0= ruleBinaryAddingOperator ) - // InternalBehaviorAnnexParser.g:3475:6: lv_operator_5_0= ruleBinaryAddingOperator + // InternalBehaviorAnnexParser.g:3476:5: (lv_operator_5_0= ruleBinaryAddingOperator ) + // InternalBehaviorAnnexParser.g:3477:6: lv_operator_5_0= ruleBinaryAddingOperator { if ( state.backtracking==0 ) { @@ -9850,18 +9867,18 @@ else if ( (LA64_0==False||LA64_0==True||LA64_0==Abs||LA64_0==Not||LA64_0==Number } - // InternalBehaviorAnnexParser.g:3492:4: ( (lv_right_6_0= ruleTerm ) ) - // InternalBehaviorAnnexParser.g:3493:5: (lv_right_6_0= ruleTerm ) + // InternalBehaviorAnnexParser.g:3494:4: ( (lv_right_6_0= ruleTerm ) ) + // InternalBehaviorAnnexParser.g:3495:5: (lv_right_6_0= ruleTerm ) { - // InternalBehaviorAnnexParser.g:3493:5: (lv_right_6_0= ruleTerm ) - // InternalBehaviorAnnexParser.g:3494:6: lv_right_6_0= ruleTerm + // InternalBehaviorAnnexParser.g:3495:5: (lv_right_6_0= ruleTerm ) + // InternalBehaviorAnnexParser.g:3496:6: lv_right_6_0= ruleTerm { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSimpleExpressionAccess().getRightTermParserRuleCall_1_2_0()); } - pushFollow(FollowSets000.FOLLOW_66); + pushFollow(FollowSets000.FOLLOW_67); lv_right_6_0=ruleTerm(); state._fsp--; @@ -9890,7 +9907,7 @@ else if ( (LA64_0==False||LA64_0==True||LA64_0==Abs||LA64_0==Not||LA64_0==Number break; default : - break loop65; + break loop66; } } while (true); @@ -9919,7 +9936,7 @@ else if ( (LA64_0==False||LA64_0==True||LA64_0==Abs||LA64_0==Not||LA64_0==Number // $ANTLR start "entryRuleUnaryAddingOperator" - // InternalBehaviorAnnexParser.g:3516:1: entryRuleUnaryAddingOperator returns [String current=null] : iv_ruleUnaryAddingOperator= ruleUnaryAddingOperator EOF ; + // InternalBehaviorAnnexParser.g:3518:1: entryRuleUnaryAddingOperator returns [String current=null] : iv_ruleUnaryAddingOperator= ruleUnaryAddingOperator EOF ; public final String entryRuleUnaryAddingOperator() throws RecognitionException { String current = null; @@ -9927,8 +9944,8 @@ public final String entryRuleUnaryAddingOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3516:59: (iv_ruleUnaryAddingOperator= ruleUnaryAddingOperator EOF ) - // InternalBehaviorAnnexParser.g:3517:2: iv_ruleUnaryAddingOperator= ruleUnaryAddingOperator EOF + // InternalBehaviorAnnexParser.g:3518:59: (iv_ruleUnaryAddingOperator= ruleUnaryAddingOperator EOF ) + // InternalBehaviorAnnexParser.g:3519:2: iv_ruleUnaryAddingOperator= ruleUnaryAddingOperator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnaryAddingOperatorRule()); @@ -9959,7 +9976,7 @@ public final String entryRuleUnaryAddingOperator() throws RecognitionException { // $ANTLR start "ruleUnaryAddingOperator" - // InternalBehaviorAnnexParser.g:3523:1: ruleUnaryAddingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= HyphenMinus | kw= PlusSign ) ; + // InternalBehaviorAnnexParser.g:3525:1: ruleUnaryAddingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= HyphenMinus | kw= PlusSign ) ; public final AntlrDatatypeRuleToken ruleUnaryAddingOperator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -9969,29 +9986,29 @@ public final AntlrDatatypeRuleToken ruleUnaryAddingOperator() throws Recognition enterRule(); try { - // InternalBehaviorAnnexParser.g:3529:2: ( (kw= HyphenMinus | kw= PlusSign ) ) - // InternalBehaviorAnnexParser.g:3530:2: (kw= HyphenMinus | kw= PlusSign ) + // InternalBehaviorAnnexParser.g:3531:2: ( (kw= HyphenMinus | kw= PlusSign ) ) + // InternalBehaviorAnnexParser.g:3532:2: (kw= HyphenMinus | kw= PlusSign ) { - // InternalBehaviorAnnexParser.g:3530:2: (kw= HyphenMinus | kw= PlusSign ) - int alt66=2; - int LA66_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3532:2: (kw= HyphenMinus | kw= PlusSign ) + int alt67=2; + int LA67_0 = input.LA(1); - if ( (LA66_0==HyphenMinus) ) { - alt66=1; + if ( (LA67_0==HyphenMinus) ) { + alt67=1; } - else if ( (LA66_0==PlusSign) ) { - alt66=2; + else if ( (LA67_0==PlusSign) ) { + alt67=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 66, 0, input); + new NoViableAltException("", 67, 0, input); throw nvae; } - switch (alt66) { + switch (alt67) { case 1 : - // InternalBehaviorAnnexParser.g:3531:3: kw= HyphenMinus + // InternalBehaviorAnnexParser.g:3533:3: kw= HyphenMinus { kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -10004,7 +10021,7 @@ else if ( (LA66_0==PlusSign) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3537:3: kw= PlusSign + // InternalBehaviorAnnexParser.g:3539:3: kw= PlusSign { kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -10041,7 +10058,7 @@ else if ( (LA66_0==PlusSign) ) { // $ANTLR start "entryRuleBinaryAddingOperator" - // InternalBehaviorAnnexParser.g:3546:1: entryRuleBinaryAddingOperator returns [String current=null] : iv_ruleBinaryAddingOperator= ruleBinaryAddingOperator EOF ; + // InternalBehaviorAnnexParser.g:3548:1: entryRuleBinaryAddingOperator returns [String current=null] : iv_ruleBinaryAddingOperator= ruleBinaryAddingOperator EOF ; public final String entryRuleBinaryAddingOperator() throws RecognitionException { String current = null; @@ -10049,8 +10066,8 @@ public final String entryRuleBinaryAddingOperator() throws RecognitionException try { - // InternalBehaviorAnnexParser.g:3546:60: (iv_ruleBinaryAddingOperator= ruleBinaryAddingOperator EOF ) - // InternalBehaviorAnnexParser.g:3547:2: iv_ruleBinaryAddingOperator= ruleBinaryAddingOperator EOF + // InternalBehaviorAnnexParser.g:3548:60: (iv_ruleBinaryAddingOperator= ruleBinaryAddingOperator EOF ) + // InternalBehaviorAnnexParser.g:3549:2: iv_ruleBinaryAddingOperator= ruleBinaryAddingOperator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBinaryAddingOperatorRule()); @@ -10081,7 +10098,7 @@ public final String entryRuleBinaryAddingOperator() throws RecognitionException // $ANTLR start "ruleBinaryAddingOperator" - // InternalBehaviorAnnexParser.g:3553:1: ruleBinaryAddingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= PlusSign | kw= HyphenMinus ) ; + // InternalBehaviorAnnexParser.g:3555:1: ruleBinaryAddingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= PlusSign | kw= HyphenMinus ) ; public final AntlrDatatypeRuleToken ruleBinaryAddingOperator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -10091,29 +10108,29 @@ public final AntlrDatatypeRuleToken ruleBinaryAddingOperator() throws Recognitio enterRule(); try { - // InternalBehaviorAnnexParser.g:3559:2: ( (kw= PlusSign | kw= HyphenMinus ) ) - // InternalBehaviorAnnexParser.g:3560:2: (kw= PlusSign | kw= HyphenMinus ) + // InternalBehaviorAnnexParser.g:3561:2: ( (kw= PlusSign | kw= HyphenMinus ) ) + // InternalBehaviorAnnexParser.g:3562:2: (kw= PlusSign | kw= HyphenMinus ) { - // InternalBehaviorAnnexParser.g:3560:2: (kw= PlusSign | kw= HyphenMinus ) - int alt67=2; - int LA67_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3562:2: (kw= PlusSign | kw= HyphenMinus ) + int alt68=2; + int LA68_0 = input.LA(1); - if ( (LA67_0==PlusSign) ) { - alt67=1; + if ( (LA68_0==PlusSign) ) { + alt68=1; } - else if ( (LA67_0==HyphenMinus) ) { - alt67=2; + else if ( (LA68_0==HyphenMinus) ) { + alt68=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 67, 0, input); + new NoViableAltException("", 68, 0, input); throw nvae; } - switch (alt67) { + switch (alt68) { case 1 : - // InternalBehaviorAnnexParser.g:3561:3: kw= PlusSign + // InternalBehaviorAnnexParser.g:3563:3: kw= PlusSign { kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -10126,7 +10143,7 @@ else if ( (LA67_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3567:3: kw= HyphenMinus + // InternalBehaviorAnnexParser.g:3569:3: kw= HyphenMinus { kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -10163,7 +10180,7 @@ else if ( (LA67_0==HyphenMinus) ) { // $ANTLR start "entryRuleTerm" - // InternalBehaviorAnnexParser.g:3576:1: entryRuleTerm returns [EObject current=null] : iv_ruleTerm= ruleTerm EOF ; + // InternalBehaviorAnnexParser.g:3578:1: entryRuleTerm returns [EObject current=null] : iv_ruleTerm= ruleTerm EOF ; public final EObject entryRuleTerm() throws RecognitionException { EObject current = null; @@ -10171,8 +10188,8 @@ public final EObject entryRuleTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3576:45: (iv_ruleTerm= ruleTerm EOF ) - // InternalBehaviorAnnexParser.g:3577:2: iv_ruleTerm= ruleTerm EOF + // InternalBehaviorAnnexParser.g:3578:45: (iv_ruleTerm= ruleTerm EOF ) + // InternalBehaviorAnnexParser.g:3579:2: iv_ruleTerm= ruleTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getTermRule()); @@ -10203,7 +10220,7 @@ public final EObject entryRuleTerm() throws RecognitionException { // $ANTLR start "ruleTerm" - // InternalBehaviorAnnexParser.g:3583:1: ruleTerm returns [EObject current=null] : (this_Factor_0= ruleFactor ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* ) ; + // InternalBehaviorAnnexParser.g:3585:1: ruleTerm returns [EObject current=null] : (this_Factor_0= ruleFactor ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* ) ; public final EObject ruleTerm() throws RecognitionException { EObject current = null; @@ -10218,18 +10235,18 @@ public final EObject ruleTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3589:2: ( (this_Factor_0= ruleFactor ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* ) ) - // InternalBehaviorAnnexParser.g:3590:2: (this_Factor_0= ruleFactor ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* ) + // InternalBehaviorAnnexParser.g:3591:2: ( (this_Factor_0= ruleFactor ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* ) ) + // InternalBehaviorAnnexParser.g:3592:2: (this_Factor_0= ruleFactor ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* ) { - // InternalBehaviorAnnexParser.g:3590:2: (this_Factor_0= ruleFactor ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* ) - // InternalBehaviorAnnexParser.g:3591:3: this_Factor_0= ruleFactor ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* + // InternalBehaviorAnnexParser.g:3592:2: (this_Factor_0= ruleFactor ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* ) + // InternalBehaviorAnnexParser.g:3593:3: this_Factor_0= ruleFactor ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getTermAccess().getFactorParserRuleCall_0()); } - pushFollow(FollowSets000.FOLLOW_67); + pushFollow(FollowSets000.FOLLOW_68); this_Factor_0=ruleFactor(); state._fsp--; @@ -10240,23 +10257,23 @@ public final EObject ruleTerm() throws RecognitionException { afterParserOrEnumRuleCall(); } - // InternalBehaviorAnnexParser.g:3599:3: ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* - loop68: + // InternalBehaviorAnnexParser.g:3601:3: ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* + loop69: do { - int alt68=2; - int LA68_0 = input.LA(1); + int alt69=2; + int LA69_0 = input.LA(1); - if ( (LA68_0==Mod||LA68_0==Rem||LA68_0==Asterisk||LA68_0==Solidus) ) { - alt68=1; + if ( (LA69_0==Mod||LA69_0==Rem||LA69_0==Asterisk||LA69_0==Solidus) ) { + alt69=1; } - switch (alt68) { + switch (alt69) { case 1 : - // InternalBehaviorAnnexParser.g:3600:4: () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) + // InternalBehaviorAnnexParser.g:3602:4: () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) { - // InternalBehaviorAnnexParser.g:3600:4: () - // InternalBehaviorAnnexParser.g:3601:5: + // InternalBehaviorAnnexParser.g:3602:4: () + // InternalBehaviorAnnexParser.g:3603:5: { if ( state.backtracking==0 ) { @@ -10268,11 +10285,11 @@ public final EObject ruleTerm() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:3607:4: ( (lv_operator_2_0= ruleMultiplyingOperator ) ) - // InternalBehaviorAnnexParser.g:3608:5: (lv_operator_2_0= ruleMultiplyingOperator ) + // InternalBehaviorAnnexParser.g:3609:4: ( (lv_operator_2_0= ruleMultiplyingOperator ) ) + // InternalBehaviorAnnexParser.g:3610:5: (lv_operator_2_0= ruleMultiplyingOperator ) { - // InternalBehaviorAnnexParser.g:3608:5: (lv_operator_2_0= ruleMultiplyingOperator ) - // InternalBehaviorAnnexParser.g:3609:6: lv_operator_2_0= ruleMultiplyingOperator + // InternalBehaviorAnnexParser.g:3610:5: (lv_operator_2_0= ruleMultiplyingOperator ) + // InternalBehaviorAnnexParser.g:3611:6: lv_operator_2_0= ruleMultiplyingOperator { if ( state.backtracking==0 ) { @@ -10303,18 +10320,18 @@ public final EObject ruleTerm() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:3626:4: ( (lv_right_3_0= ruleFactor ) ) - // InternalBehaviorAnnexParser.g:3627:5: (lv_right_3_0= ruleFactor ) + // InternalBehaviorAnnexParser.g:3628:4: ( (lv_right_3_0= ruleFactor ) ) + // InternalBehaviorAnnexParser.g:3629:5: (lv_right_3_0= ruleFactor ) { - // InternalBehaviorAnnexParser.g:3627:5: (lv_right_3_0= ruleFactor ) - // InternalBehaviorAnnexParser.g:3628:6: lv_right_3_0= ruleFactor + // InternalBehaviorAnnexParser.g:3629:5: (lv_right_3_0= ruleFactor ) + // InternalBehaviorAnnexParser.g:3630:6: lv_right_3_0= ruleFactor { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getTermAccess().getRightFactorParserRuleCall_1_2_0()); } - pushFollow(FollowSets000.FOLLOW_67); + pushFollow(FollowSets000.FOLLOW_68); lv_right_3_0=ruleFactor(); state._fsp--; @@ -10343,7 +10360,7 @@ public final EObject ruleTerm() throws RecognitionException { break; default : - break loop68; + break loop69; } } while (true); @@ -10372,7 +10389,7 @@ public final EObject ruleTerm() throws RecognitionException { // $ANTLR start "entryRuleMultiplyingOperator" - // InternalBehaviorAnnexParser.g:3650:1: entryRuleMultiplyingOperator returns [String current=null] : iv_ruleMultiplyingOperator= ruleMultiplyingOperator EOF ; + // InternalBehaviorAnnexParser.g:3652:1: entryRuleMultiplyingOperator returns [String current=null] : iv_ruleMultiplyingOperator= ruleMultiplyingOperator EOF ; public final String entryRuleMultiplyingOperator() throws RecognitionException { String current = null; @@ -10380,8 +10397,8 @@ public final String entryRuleMultiplyingOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3650:59: (iv_ruleMultiplyingOperator= ruleMultiplyingOperator EOF ) - // InternalBehaviorAnnexParser.g:3651:2: iv_ruleMultiplyingOperator= ruleMultiplyingOperator EOF + // InternalBehaviorAnnexParser.g:3652:59: (iv_ruleMultiplyingOperator= ruleMultiplyingOperator EOF ) + // InternalBehaviorAnnexParser.g:3653:2: iv_ruleMultiplyingOperator= ruleMultiplyingOperator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getMultiplyingOperatorRule()); @@ -10412,7 +10429,7 @@ public final String entryRuleMultiplyingOperator() throws RecognitionException { // $ANTLR start "ruleMultiplyingOperator" - // InternalBehaviorAnnexParser.g:3657:1: ruleMultiplyingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= Asterisk | kw= Solidus | kw= Mod | kw= Rem ) ; + // InternalBehaviorAnnexParser.g:3659:1: ruleMultiplyingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= Asterisk | kw= Solidus | kw= Mod | kw= Rem ) ; public final AntlrDatatypeRuleToken ruleMultiplyingOperator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -10422,43 +10439,43 @@ public final AntlrDatatypeRuleToken ruleMultiplyingOperator() throws Recognition enterRule(); try { - // InternalBehaviorAnnexParser.g:3663:2: ( (kw= Asterisk | kw= Solidus | kw= Mod | kw= Rem ) ) - // InternalBehaviorAnnexParser.g:3664:2: (kw= Asterisk | kw= Solidus | kw= Mod | kw= Rem ) + // InternalBehaviorAnnexParser.g:3665:2: ( (kw= Asterisk | kw= Solidus | kw= Mod | kw= Rem ) ) + // InternalBehaviorAnnexParser.g:3666:2: (kw= Asterisk | kw= Solidus | kw= Mod | kw= Rem ) { - // InternalBehaviorAnnexParser.g:3664:2: (kw= Asterisk | kw= Solidus | kw= Mod | kw= Rem ) - int alt69=4; + // InternalBehaviorAnnexParser.g:3666:2: (kw= Asterisk | kw= Solidus | kw= Mod | kw= Rem ) + int alt70=4; switch ( input.LA(1) ) { case Asterisk: { - alt69=1; + alt70=1; } break; case Solidus: { - alt69=2; + alt70=2; } break; case Mod: { - alt69=3; + alt70=3; } break; case Rem: { - alt69=4; + alt70=4; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 69, 0, input); + new NoViableAltException("", 70, 0, input); throw nvae; } - switch (alt69) { + switch (alt70) { case 1 : - // InternalBehaviorAnnexParser.g:3665:3: kw= Asterisk + // InternalBehaviorAnnexParser.g:3667:3: kw= Asterisk { kw=(Token)match(input,Asterisk,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -10471,7 +10488,7 @@ public final AntlrDatatypeRuleToken ruleMultiplyingOperator() throws Recognition } break; case 2 : - // InternalBehaviorAnnexParser.g:3671:3: kw= Solidus + // InternalBehaviorAnnexParser.g:3673:3: kw= Solidus { kw=(Token)match(input,Solidus,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -10484,7 +10501,7 @@ public final AntlrDatatypeRuleToken ruleMultiplyingOperator() throws Recognition } break; case 3 : - // InternalBehaviorAnnexParser.g:3677:3: kw= Mod + // InternalBehaviorAnnexParser.g:3679:3: kw= Mod { kw=(Token)match(input,Mod,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -10497,7 +10514,7 @@ public final AntlrDatatypeRuleToken ruleMultiplyingOperator() throws Recognition } break; case 4 : - // InternalBehaviorAnnexParser.g:3683:3: kw= Rem + // InternalBehaviorAnnexParser.g:3685:3: kw= Rem { kw=(Token)match(input,Rem,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -10534,7 +10551,7 @@ public final AntlrDatatypeRuleToken ruleMultiplyingOperator() throws Recognition // $ANTLR start "entryRuleFactor" - // InternalBehaviorAnnexParser.g:3692:1: entryRuleFactor returns [EObject current=null] : iv_ruleFactor= ruleFactor EOF ; + // InternalBehaviorAnnexParser.g:3694:1: entryRuleFactor returns [EObject current=null] : iv_ruleFactor= ruleFactor EOF ; public final EObject entryRuleFactor() throws RecognitionException { EObject current = null; @@ -10542,8 +10559,8 @@ public final EObject entryRuleFactor() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3692:47: (iv_ruleFactor= ruleFactor EOF ) - // InternalBehaviorAnnexParser.g:3693:2: iv_ruleFactor= ruleFactor EOF + // InternalBehaviorAnnexParser.g:3694:47: (iv_ruleFactor= ruleFactor EOF ) + // InternalBehaviorAnnexParser.g:3695:2: iv_ruleFactor= ruleFactor EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getFactorRule()); @@ -10574,7 +10591,7 @@ public final EObject entryRuleFactor() throws RecognitionException { // $ANTLR start "ruleFactor" - // InternalBehaviorAnnexParser.g:3699:1: ruleFactor returns [EObject current=null] : ( (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) | ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) ) ; + // InternalBehaviorAnnexParser.g:3701:1: ruleFactor returns [EObject current=null] : ( (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) | ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) ) ; public final EObject ruleFactor() throws RecognitionException { EObject current = null; @@ -10593,39 +10610,39 @@ public final EObject ruleFactor() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3705:2: ( ( (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) | ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) ) ) - // InternalBehaviorAnnexParser.g:3706:2: ( (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) | ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) ) + // InternalBehaviorAnnexParser.g:3707:2: ( ( (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) | ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) ) ) + // InternalBehaviorAnnexParser.g:3708:2: ( (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) | ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) ) { - // InternalBehaviorAnnexParser.g:3706:2: ( (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) | ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) ) - int alt71=2; - int LA71_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3708:2: ( (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) | ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) ) + int alt72=2; + int LA72_0 = input.LA(1); - if ( (LA71_0==False||LA71_0==True||LA71_0==NumberSign||LA71_0==LeftParenthesis||LA71_0==RULE_REAL_LIT||LA71_0==RULE_INTEGER_LIT||(LA71_0>=RULE_STRING && LA71_0<=RULE_ID)) ) { - alt71=1; + if ( (LA72_0==False||LA72_0==True||LA72_0==NumberSign||LA72_0==LeftParenthesis||LA72_0==RULE_REAL_LIT||LA72_0==RULE_INTEGER_LIT||(LA72_0>=RULE_STRING && LA72_0<=RULE_ID)) ) { + alt72=1; } - else if ( (LA71_0==Abs||LA71_0==Not) ) { - alt71=2; + else if ( (LA72_0==Abs||LA72_0==Not) ) { + alt72=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 71, 0, input); + new NoViableAltException("", 72, 0, input); throw nvae; } - switch (alt71) { + switch (alt72) { case 1 : - // InternalBehaviorAnnexParser.g:3707:3: (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) + // InternalBehaviorAnnexParser.g:3709:3: (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) { - // InternalBehaviorAnnexParser.g:3707:3: (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) - // InternalBehaviorAnnexParser.g:3708:4: this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? + // InternalBehaviorAnnexParser.g:3709:3: (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) + // InternalBehaviorAnnexParser.g:3710:4: this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getFactorAccess().getValueParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_68); + pushFollow(FollowSets000.FOLLOW_69); this_Value_0=ruleValue(); state._fsp--; @@ -10636,19 +10653,19 @@ else if ( (LA71_0==Abs||LA71_0==Not) ) { afterParserOrEnumRuleCall(); } - // InternalBehaviorAnnexParser.g:3716:4: ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? - int alt70=2; - int LA70_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3718:4: ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? + int alt71=2; + int LA71_0 = input.LA(1); - if ( (LA70_0==AsteriskAsterisk) ) { - alt70=1; + if ( (LA71_0==AsteriskAsterisk) ) { + alt71=1; } - switch (alt70) { + switch (alt71) { case 1 : - // InternalBehaviorAnnexParser.g:3717:5: () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) + // InternalBehaviorAnnexParser.g:3719:5: () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) { - // InternalBehaviorAnnexParser.g:3717:5: () - // InternalBehaviorAnnexParser.g:3718:6: + // InternalBehaviorAnnexParser.g:3719:5: () + // InternalBehaviorAnnexParser.g:3720:6: { if ( state.backtracking==0 ) { @@ -10660,18 +10677,18 @@ else if ( (LA71_0==Abs||LA71_0==Not) ) { } - // InternalBehaviorAnnexParser.g:3724:5: ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) - // InternalBehaviorAnnexParser.g:3725:6: (lv_operator_2_0= ruleBinaryNumericOperator ) + // InternalBehaviorAnnexParser.g:3726:5: ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) + // InternalBehaviorAnnexParser.g:3727:6: (lv_operator_2_0= ruleBinaryNumericOperator ) { - // InternalBehaviorAnnexParser.g:3725:6: (lv_operator_2_0= ruleBinaryNumericOperator ) - // InternalBehaviorAnnexParser.g:3726:7: lv_operator_2_0= ruleBinaryNumericOperator + // InternalBehaviorAnnexParser.g:3727:6: (lv_operator_2_0= ruleBinaryNumericOperator ) + // InternalBehaviorAnnexParser.g:3728:7: lv_operator_2_0= ruleBinaryNumericOperator { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getFactorAccess().getOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0()); } - pushFollow(FollowSets000.FOLLOW_69); + pushFollow(FollowSets000.FOLLOW_70); lv_operator_2_0=ruleBinaryNumericOperator(); state._fsp--; @@ -10695,11 +10712,11 @@ else if ( (LA71_0==Abs||LA71_0==Not) ) { } - // InternalBehaviorAnnexParser.g:3743:5: ( (lv_right_3_0= ruleValue ) ) - // InternalBehaviorAnnexParser.g:3744:6: (lv_right_3_0= ruleValue ) + // InternalBehaviorAnnexParser.g:3745:5: ( (lv_right_3_0= ruleValue ) ) + // InternalBehaviorAnnexParser.g:3746:6: (lv_right_3_0= ruleValue ) { - // InternalBehaviorAnnexParser.g:3744:6: (lv_right_3_0= ruleValue ) - // InternalBehaviorAnnexParser.g:3745:7: lv_right_3_0= ruleValue + // InternalBehaviorAnnexParser.g:3746:6: (lv_right_3_0= ruleValue ) + // InternalBehaviorAnnexParser.g:3747:7: lv_right_3_0= ruleValue { if ( state.backtracking==0 ) { @@ -10743,13 +10760,13 @@ else if ( (LA71_0==Abs||LA71_0==Not) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3765:3: ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) + // InternalBehaviorAnnexParser.g:3767:3: ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) { - // InternalBehaviorAnnexParser.g:3765:3: ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) - // InternalBehaviorAnnexParser.g:3766:4: () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) + // InternalBehaviorAnnexParser.g:3767:3: ( () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) ) + // InternalBehaviorAnnexParser.g:3768:4: () ( (lv_operator_5_0= ruleUnaryValueOperator ) ) ( (lv_operand_6_0= ruleValue ) ) { - // InternalBehaviorAnnexParser.g:3766:4: () - // InternalBehaviorAnnexParser.g:3767:5: + // InternalBehaviorAnnexParser.g:3768:4: () + // InternalBehaviorAnnexParser.g:3769:5: { if ( state.backtracking==0 ) { @@ -10761,18 +10778,18 @@ else if ( (LA71_0==Abs||LA71_0==Not) ) { } - // InternalBehaviorAnnexParser.g:3773:4: ( (lv_operator_5_0= ruleUnaryValueOperator ) ) - // InternalBehaviorAnnexParser.g:3774:5: (lv_operator_5_0= ruleUnaryValueOperator ) + // InternalBehaviorAnnexParser.g:3775:4: ( (lv_operator_5_0= ruleUnaryValueOperator ) ) + // InternalBehaviorAnnexParser.g:3776:5: (lv_operator_5_0= ruleUnaryValueOperator ) { - // InternalBehaviorAnnexParser.g:3774:5: (lv_operator_5_0= ruleUnaryValueOperator ) - // InternalBehaviorAnnexParser.g:3775:6: lv_operator_5_0= ruleUnaryValueOperator + // InternalBehaviorAnnexParser.g:3776:5: (lv_operator_5_0= ruleUnaryValueOperator ) + // InternalBehaviorAnnexParser.g:3777:6: lv_operator_5_0= ruleUnaryValueOperator { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getFactorAccess().getOperatorUnaryValueOperatorParserRuleCall_1_1_0()); } - pushFollow(FollowSets000.FOLLOW_69); + pushFollow(FollowSets000.FOLLOW_70); lv_operator_5_0=ruleUnaryValueOperator(); state._fsp--; @@ -10796,11 +10813,11 @@ else if ( (LA71_0==Abs||LA71_0==Not) ) { } - // InternalBehaviorAnnexParser.g:3792:4: ( (lv_operand_6_0= ruleValue ) ) - // InternalBehaviorAnnexParser.g:3793:5: (lv_operand_6_0= ruleValue ) + // InternalBehaviorAnnexParser.g:3794:4: ( (lv_operand_6_0= ruleValue ) ) + // InternalBehaviorAnnexParser.g:3795:5: (lv_operand_6_0= ruleValue ) { - // InternalBehaviorAnnexParser.g:3793:5: (lv_operand_6_0= ruleValue ) - // InternalBehaviorAnnexParser.g:3794:6: lv_operand_6_0= ruleValue + // InternalBehaviorAnnexParser.g:3795:5: (lv_operand_6_0= ruleValue ) + // InternalBehaviorAnnexParser.g:3796:6: lv_operand_6_0= ruleValue { if ( state.backtracking==0 ) { @@ -10862,7 +10879,7 @@ else if ( (LA71_0==Abs||LA71_0==Not) ) { // $ANTLR start "entryRuleBinaryNumericOperator" - // InternalBehaviorAnnexParser.g:3816:1: entryRuleBinaryNumericOperator returns [String current=null] : iv_ruleBinaryNumericOperator= ruleBinaryNumericOperator EOF ; + // InternalBehaviorAnnexParser.g:3818:1: entryRuleBinaryNumericOperator returns [String current=null] : iv_ruleBinaryNumericOperator= ruleBinaryNumericOperator EOF ; public final String entryRuleBinaryNumericOperator() throws RecognitionException { String current = null; @@ -10870,8 +10887,8 @@ public final String entryRuleBinaryNumericOperator() throws RecognitionException try { - // InternalBehaviorAnnexParser.g:3816:61: (iv_ruleBinaryNumericOperator= ruleBinaryNumericOperator EOF ) - // InternalBehaviorAnnexParser.g:3817:2: iv_ruleBinaryNumericOperator= ruleBinaryNumericOperator EOF + // InternalBehaviorAnnexParser.g:3818:61: (iv_ruleBinaryNumericOperator= ruleBinaryNumericOperator EOF ) + // InternalBehaviorAnnexParser.g:3819:2: iv_ruleBinaryNumericOperator= ruleBinaryNumericOperator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBinaryNumericOperatorRule()); @@ -10902,7 +10919,7 @@ public final String entryRuleBinaryNumericOperator() throws RecognitionException // $ANTLR start "ruleBinaryNumericOperator" - // InternalBehaviorAnnexParser.g:3823:1: ruleBinaryNumericOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= AsteriskAsterisk ; + // InternalBehaviorAnnexParser.g:3825:1: ruleBinaryNumericOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= AsteriskAsterisk ; public final AntlrDatatypeRuleToken ruleBinaryNumericOperator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -10912,8 +10929,8 @@ public final AntlrDatatypeRuleToken ruleBinaryNumericOperator() throws Recogniti enterRule(); try { - // InternalBehaviorAnnexParser.g:3829:2: (kw= AsteriskAsterisk ) - // InternalBehaviorAnnexParser.g:3830:2: kw= AsteriskAsterisk + // InternalBehaviorAnnexParser.g:3831:2: (kw= AsteriskAsterisk ) + // InternalBehaviorAnnexParser.g:3832:2: kw= AsteriskAsterisk { kw=(Token)match(input,AsteriskAsterisk,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -10944,7 +10961,7 @@ public final AntlrDatatypeRuleToken ruleBinaryNumericOperator() throws Recogniti // $ANTLR start "entryRuleUnaryValueOperator" - // InternalBehaviorAnnexParser.g:3838:1: entryRuleUnaryValueOperator returns [String current=null] : iv_ruleUnaryValueOperator= ruleUnaryValueOperator EOF ; + // InternalBehaviorAnnexParser.g:3840:1: entryRuleUnaryValueOperator returns [String current=null] : iv_ruleUnaryValueOperator= ruleUnaryValueOperator EOF ; public final String entryRuleUnaryValueOperator() throws RecognitionException { String current = null; @@ -10952,8 +10969,8 @@ public final String entryRuleUnaryValueOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3838:58: (iv_ruleUnaryValueOperator= ruleUnaryValueOperator EOF ) - // InternalBehaviorAnnexParser.g:3839:2: iv_ruleUnaryValueOperator= ruleUnaryValueOperator EOF + // InternalBehaviorAnnexParser.g:3840:58: (iv_ruleUnaryValueOperator= ruleUnaryValueOperator EOF ) + // InternalBehaviorAnnexParser.g:3841:2: iv_ruleUnaryValueOperator= ruleUnaryValueOperator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnaryValueOperatorRule()); @@ -10984,7 +11001,7 @@ public final String entryRuleUnaryValueOperator() throws RecognitionException { // $ANTLR start "ruleUnaryValueOperator" - // InternalBehaviorAnnexParser.g:3845:1: ruleUnaryValueOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= Abs | kw= Not ) ; + // InternalBehaviorAnnexParser.g:3847:1: ruleUnaryValueOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= Abs | kw= Not ) ; public final AntlrDatatypeRuleToken ruleUnaryValueOperator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -10994,29 +11011,29 @@ public final AntlrDatatypeRuleToken ruleUnaryValueOperator() throws RecognitionE enterRule(); try { - // InternalBehaviorAnnexParser.g:3851:2: ( (kw= Abs | kw= Not ) ) - // InternalBehaviorAnnexParser.g:3852:2: (kw= Abs | kw= Not ) + // InternalBehaviorAnnexParser.g:3853:2: ( (kw= Abs | kw= Not ) ) + // InternalBehaviorAnnexParser.g:3854:2: (kw= Abs | kw= Not ) { - // InternalBehaviorAnnexParser.g:3852:2: (kw= Abs | kw= Not ) - int alt72=2; - int LA72_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3854:2: (kw= Abs | kw= Not ) + int alt73=2; + int LA73_0 = input.LA(1); - if ( (LA72_0==Abs) ) { - alt72=1; + if ( (LA73_0==Abs) ) { + alt73=1; } - else if ( (LA72_0==Not) ) { - alt72=2; + else if ( (LA73_0==Not) ) { + alt73=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 72, 0, input); + new NoViableAltException("", 73, 0, input); throw nvae; } - switch (alt72) { + switch (alt73) { case 1 : - // InternalBehaviorAnnexParser.g:3853:3: kw= Abs + // InternalBehaviorAnnexParser.g:3855:3: kw= Abs { kw=(Token)match(input,Abs,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -11029,7 +11046,7 @@ else if ( (LA72_0==Not) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3859:3: kw= Not + // InternalBehaviorAnnexParser.g:3861:3: kw= Not { kw=(Token)match(input,Not,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -11066,7 +11083,7 @@ else if ( (LA72_0==Not) ) { // $ANTLR start "entryRuleValue" - // InternalBehaviorAnnexParser.g:3868:1: entryRuleValue returns [EObject current=null] : iv_ruleValue= ruleValue EOF ; + // InternalBehaviorAnnexParser.g:3870:1: entryRuleValue returns [EObject current=null] : iv_ruleValue= ruleValue EOF ; public final EObject entryRuleValue() throws RecognitionException { EObject current = null; @@ -11074,8 +11091,8 @@ public final EObject entryRuleValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3868:46: (iv_ruleValue= ruleValue EOF ) - // InternalBehaviorAnnexParser.g:3869:2: iv_ruleValue= ruleValue EOF + // InternalBehaviorAnnexParser.g:3870:46: (iv_ruleValue= ruleValue EOF ) + // InternalBehaviorAnnexParser.g:3871:2: iv_ruleValue= ruleValue EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getValueRule()); @@ -11106,7 +11123,7 @@ public final EObject entryRuleValue() throws RecognitionException { // $ANTLR start "ruleValue" - // InternalBehaviorAnnexParser.g:3875:1: ruleValue returns [EObject current=null] : (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | this_ParenthesizedExpression_2= ruleParenthesizedExpression ) ; + // InternalBehaviorAnnexParser.g:3877:1: ruleValue returns [EObject current=null] : (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | this_ParenthesizedExpression_2= ruleParenthesizedExpression ) ; public final EObject ruleValue() throws RecognitionException { EObject current = null; @@ -11121,11 +11138,11 @@ public final EObject ruleValue() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3881:2: ( (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | this_ParenthesizedExpression_2= ruleParenthesizedExpression ) ) - // InternalBehaviorAnnexParser.g:3882:2: (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | this_ParenthesizedExpression_2= ruleParenthesizedExpression ) + // InternalBehaviorAnnexParser.g:3883:2: ( (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | this_ParenthesizedExpression_2= ruleParenthesizedExpression ) ) + // InternalBehaviorAnnexParser.g:3884:2: (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | this_ParenthesizedExpression_2= ruleParenthesizedExpression ) { - // InternalBehaviorAnnexParser.g:3882:2: (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | this_ParenthesizedExpression_2= ruleParenthesizedExpression ) - int alt73=3; + // InternalBehaviorAnnexParser.g:3884:2: (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | this_ParenthesizedExpression_2= ruleParenthesizedExpression ) + int alt74=3; switch ( input.LA(1) ) { case False: case True: @@ -11134,30 +11151,30 @@ public final EObject ruleValue() throws RecognitionException { case RULE_INTEGER_LIT: case RULE_STRING: { - alt73=1; + alt74=1; } break; case RULE_ID: { - alt73=2; + alt74=2; } break; case LeftParenthesis: { - alt73=3; + alt74=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 73, 0, input); + new NoViableAltException("", 74, 0, input); throw nvae; } - switch (alt73) { + switch (alt74) { case 1 : - // InternalBehaviorAnnexParser.g:3883:3: this_ValueConstant_0= ruleValueConstant + // InternalBehaviorAnnexParser.g:3885:3: this_ValueConstant_0= ruleValueConstant { if ( state.backtracking==0 ) { @@ -11179,7 +11196,7 @@ public final EObject ruleValue() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:3892:3: this_ReferenceExpression_1= ruleReferenceExpression + // InternalBehaviorAnnexParser.g:3894:3: this_ReferenceExpression_1= ruleReferenceExpression { if ( state.backtracking==0 ) { @@ -11201,7 +11218,7 @@ public final EObject ruleValue() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:3901:3: this_ParenthesizedExpression_2= ruleParenthesizedExpression + // InternalBehaviorAnnexParser.g:3903:3: this_ParenthesizedExpression_2= ruleParenthesizedExpression { if ( state.backtracking==0 ) { @@ -11247,7 +11264,7 @@ public final EObject ruleValue() throws RecognitionException { // $ANTLR start "entryRuleParenthesizedExpression" - // InternalBehaviorAnnexParser.g:3913:1: entryRuleParenthesizedExpression returns [EObject current=null] : iv_ruleParenthesizedExpression= ruleParenthesizedExpression EOF ; + // InternalBehaviorAnnexParser.g:3915:1: entryRuleParenthesizedExpression returns [EObject current=null] : iv_ruleParenthesizedExpression= ruleParenthesizedExpression EOF ; public final EObject entryRuleParenthesizedExpression() throws RecognitionException { EObject current = null; @@ -11255,8 +11272,8 @@ public final EObject entryRuleParenthesizedExpression() throws RecognitionExcept try { - // InternalBehaviorAnnexParser.g:3913:64: (iv_ruleParenthesizedExpression= ruleParenthesizedExpression EOF ) - // InternalBehaviorAnnexParser.g:3914:2: iv_ruleParenthesizedExpression= ruleParenthesizedExpression EOF + // InternalBehaviorAnnexParser.g:3915:64: (iv_ruleParenthesizedExpression= ruleParenthesizedExpression EOF ) + // InternalBehaviorAnnexParser.g:3916:2: iv_ruleParenthesizedExpression= ruleParenthesizedExpression EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getParenthesizedExpressionRule()); @@ -11287,7 +11304,7 @@ public final EObject entryRuleParenthesizedExpression() throws RecognitionExcept // $ANTLR start "ruleParenthesizedExpression" - // InternalBehaviorAnnexParser.g:3920:1: ruleParenthesizedExpression returns [EObject current=null] : (otherlv_0= LeftParenthesis ( (lv_expression_1_0= ruleValueExpression ) ) otherlv_2= RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:3922:1: ruleParenthesizedExpression returns [EObject current=null] : (otherlv_0= LeftParenthesis ( (lv_expression_1_0= ruleValueExpression ) ) otherlv_2= RightParenthesis ) ; public final EObject ruleParenthesizedExpression() throws RecognitionException { EObject current = null; @@ -11300,11 +11317,11 @@ public final EObject ruleParenthesizedExpression() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3926:2: ( (otherlv_0= LeftParenthesis ( (lv_expression_1_0= ruleValueExpression ) ) otherlv_2= RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:3927:2: (otherlv_0= LeftParenthesis ( (lv_expression_1_0= ruleValueExpression ) ) otherlv_2= RightParenthesis ) + // InternalBehaviorAnnexParser.g:3928:2: ( (otherlv_0= LeftParenthesis ( (lv_expression_1_0= ruleValueExpression ) ) otherlv_2= RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:3929:2: (otherlv_0= LeftParenthesis ( (lv_expression_1_0= ruleValueExpression ) ) otherlv_2= RightParenthesis ) { - // InternalBehaviorAnnexParser.g:3927:2: (otherlv_0= LeftParenthesis ( (lv_expression_1_0= ruleValueExpression ) ) otherlv_2= RightParenthesis ) - // InternalBehaviorAnnexParser.g:3928:3: otherlv_0= LeftParenthesis ( (lv_expression_1_0= ruleValueExpression ) ) otherlv_2= RightParenthesis + // InternalBehaviorAnnexParser.g:3929:2: (otherlv_0= LeftParenthesis ( (lv_expression_1_0= ruleValueExpression ) ) otherlv_2= RightParenthesis ) + // InternalBehaviorAnnexParser.g:3930:3: otherlv_0= LeftParenthesis ( (lv_expression_1_0= ruleValueExpression ) ) otherlv_2= RightParenthesis { otherlv_0=(Token)match(input,LeftParenthesis,FollowSets000.FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -11312,11 +11329,11 @@ public final EObject ruleParenthesizedExpression() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } - // InternalBehaviorAnnexParser.g:3932:3: ( (lv_expression_1_0= ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:3933:4: (lv_expression_1_0= ruleValueExpression ) + // InternalBehaviorAnnexParser.g:3934:3: ( (lv_expression_1_0= ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:3935:4: (lv_expression_1_0= ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:3933:4: (lv_expression_1_0= ruleValueExpression ) - // InternalBehaviorAnnexParser.g:3934:5: lv_expression_1_0= ruleValueExpression + // InternalBehaviorAnnexParser.g:3935:4: (lv_expression_1_0= ruleValueExpression ) + // InternalBehaviorAnnexParser.g:3936:5: lv_expression_1_0= ruleValueExpression { if ( state.backtracking==0 ) { @@ -11378,7 +11395,7 @@ public final EObject ruleParenthesizedExpression() throws RecognitionException { // $ANTLR start "entryRuleValueConstant" - // InternalBehaviorAnnexParser.g:3959:1: entryRuleValueConstant returns [EObject current=null] : iv_ruleValueConstant= ruleValueConstant EOF ; + // InternalBehaviorAnnexParser.g:3961:1: entryRuleValueConstant returns [EObject current=null] : iv_ruleValueConstant= ruleValueConstant EOF ; public final EObject entryRuleValueConstant() throws RecognitionException { EObject current = null; @@ -11386,8 +11403,8 @@ public final EObject entryRuleValueConstant() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3959:54: (iv_ruleValueConstant= ruleValueConstant EOF ) - // InternalBehaviorAnnexParser.g:3960:2: iv_ruleValueConstant= ruleValueConstant EOF + // InternalBehaviorAnnexParser.g:3961:54: (iv_ruleValueConstant= ruleValueConstant EOF ) + // InternalBehaviorAnnexParser.g:3962:2: iv_ruleValueConstant= ruleValueConstant EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getValueConstantRule()); @@ -11418,7 +11435,7 @@ public final EObject entryRuleValueConstant() throws RecognitionException { // $ANTLR start "ruleValueConstant" - // InternalBehaviorAnnexParser.g:3966:1: ruleValueConstant returns [EObject current=null] : (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) ; + // InternalBehaviorAnnexParser.g:3968:1: ruleValueConstant returns [EObject current=null] : (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) ; public final EObject ruleValueConstant() throws RecognitionException { EObject current = null; @@ -11437,49 +11454,49 @@ public final EObject ruleValueConstant() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3972:2: ( (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) ) - // InternalBehaviorAnnexParser.g:3973:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) + // InternalBehaviorAnnexParser.g:3974:2: ( (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) ) + // InternalBehaviorAnnexParser.g:3975:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) { - // InternalBehaviorAnnexParser.g:3973:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) - int alt74=5; + // InternalBehaviorAnnexParser.g:3975:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) + int alt75=5; switch ( input.LA(1) ) { case RULE_INTEGER_LIT: { - alt74=1; + alt75=1; } break; case RULE_REAL_LIT: { - alt74=2; + alt75=2; } break; case RULE_STRING: { - alt74=3; + alt75=3; } break; case False: case True: { - alt74=4; + alt75=4; } break; case NumberSign: { - alt74=5; + alt75=5; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 74, 0, input); + new NoViableAltException("", 75, 0, input); throw nvae; } - switch (alt74) { + switch (alt75) { case 1 : - // InternalBehaviorAnnexParser.g:3974:3: this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral + // InternalBehaviorAnnexParser.g:3976:3: this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral { if ( state.backtracking==0 ) { @@ -11501,7 +11518,7 @@ public final EObject ruleValueConstant() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:3983:3: this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral + // InternalBehaviorAnnexParser.g:3985:3: this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral { if ( state.backtracking==0 ) { @@ -11523,7 +11540,7 @@ public final EObject ruleValueConstant() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:3992:3: this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral + // InternalBehaviorAnnexParser.g:3994:3: this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral { if ( state.backtracking==0 ) { @@ -11545,7 +11562,7 @@ public final EObject ruleValueConstant() throws RecognitionException { } break; case 4 : - // InternalBehaviorAnnexParser.g:4001:3: this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral + // InternalBehaviorAnnexParser.g:4003:3: this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral { if ( state.backtracking==0 ) { @@ -11567,7 +11584,7 @@ public final EObject ruleValueConstant() throws RecognitionException { } break; case 5 : - // InternalBehaviorAnnexParser.g:4010:3: this_HashPropertyReference_4= ruleHashPropertyReference + // InternalBehaviorAnnexParser.g:4012:3: this_HashPropertyReference_4= ruleHashPropertyReference { if ( state.backtracking==0 ) { @@ -11613,7 +11630,7 @@ public final EObject ruleValueConstant() throws RecognitionException { // $ANTLR start "entryRuleBehaviorIntegerLiteral" - // InternalBehaviorAnnexParser.g:4022:1: entryRuleBehaviorIntegerLiteral returns [EObject current=null] : iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF ; + // InternalBehaviorAnnexParser.g:4024:1: entryRuleBehaviorIntegerLiteral returns [EObject current=null] : iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF ; public final EObject entryRuleBehaviorIntegerLiteral() throws RecognitionException { EObject current = null; @@ -11621,8 +11638,8 @@ public final EObject entryRuleBehaviorIntegerLiteral() throws RecognitionExcepti try { - // InternalBehaviorAnnexParser.g:4022:63: (iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF ) - // InternalBehaviorAnnexParser.g:4023:2: iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF + // InternalBehaviorAnnexParser.g:4024:63: (iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF ) + // InternalBehaviorAnnexParser.g:4025:2: iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBehaviorIntegerLiteralRule()); @@ -11653,7 +11670,7 @@ public final EObject entryRuleBehaviorIntegerLiteral() throws RecognitionExcepti // $ANTLR start "ruleBehaviorIntegerLiteral" - // InternalBehaviorAnnexParser.g:4029:1: ruleBehaviorIntegerLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_INTEGER_LIT ) ) ; + // InternalBehaviorAnnexParser.g:4031:1: ruleBehaviorIntegerLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_INTEGER_LIT ) ) ; public final EObject ruleBehaviorIntegerLiteral() throws RecognitionException { EObject current = null; @@ -11663,14 +11680,14 @@ public final EObject ruleBehaviorIntegerLiteral() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4035:2: ( ( (lv_value_0_0= RULE_INTEGER_LIT ) ) ) - // InternalBehaviorAnnexParser.g:4036:2: ( (lv_value_0_0= RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:4037:2: ( ( (lv_value_0_0= RULE_INTEGER_LIT ) ) ) + // InternalBehaviorAnnexParser.g:4038:2: ( (lv_value_0_0= RULE_INTEGER_LIT ) ) { - // InternalBehaviorAnnexParser.g:4036:2: ( (lv_value_0_0= RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:4037:3: (lv_value_0_0= RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:4038:2: ( (lv_value_0_0= RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:4039:3: (lv_value_0_0= RULE_INTEGER_LIT ) { - // InternalBehaviorAnnexParser.g:4037:3: (lv_value_0_0= RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:4038:4: lv_value_0_0= RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:4039:3: (lv_value_0_0= RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:4040:4: lv_value_0_0= RULE_INTEGER_LIT { lv_value_0_0=(Token)match(input,RULE_INTEGER_LIT,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -11718,7 +11735,7 @@ public final EObject ruleBehaviorIntegerLiteral() throws RecognitionException { // $ANTLR start "entryRuleBehaviorRealLiteral" - // InternalBehaviorAnnexParser.g:4057:1: entryRuleBehaviorRealLiteral returns [EObject current=null] : iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF ; + // InternalBehaviorAnnexParser.g:4059:1: entryRuleBehaviorRealLiteral returns [EObject current=null] : iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF ; public final EObject entryRuleBehaviorRealLiteral() throws RecognitionException { EObject current = null; @@ -11726,8 +11743,8 @@ public final EObject entryRuleBehaviorRealLiteral() throws RecognitionException try { - // InternalBehaviorAnnexParser.g:4057:60: (iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF ) - // InternalBehaviorAnnexParser.g:4058:2: iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF + // InternalBehaviorAnnexParser.g:4059:60: (iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF ) + // InternalBehaviorAnnexParser.g:4060:2: iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBehaviorRealLiteralRule()); @@ -11758,7 +11775,7 @@ public final EObject entryRuleBehaviorRealLiteral() throws RecognitionException // $ANTLR start "ruleBehaviorRealLiteral" - // InternalBehaviorAnnexParser.g:4064:1: ruleBehaviorRealLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_REAL_LIT ) ) ; + // InternalBehaviorAnnexParser.g:4066:1: ruleBehaviorRealLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_REAL_LIT ) ) ; public final EObject ruleBehaviorRealLiteral() throws RecognitionException { EObject current = null; @@ -11768,14 +11785,14 @@ public final EObject ruleBehaviorRealLiteral() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4070:2: ( ( (lv_value_0_0= RULE_REAL_LIT ) ) ) - // InternalBehaviorAnnexParser.g:4071:2: ( (lv_value_0_0= RULE_REAL_LIT ) ) + // InternalBehaviorAnnexParser.g:4072:2: ( ( (lv_value_0_0= RULE_REAL_LIT ) ) ) + // InternalBehaviorAnnexParser.g:4073:2: ( (lv_value_0_0= RULE_REAL_LIT ) ) { - // InternalBehaviorAnnexParser.g:4071:2: ( (lv_value_0_0= RULE_REAL_LIT ) ) - // InternalBehaviorAnnexParser.g:4072:3: (lv_value_0_0= RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:4073:2: ( (lv_value_0_0= RULE_REAL_LIT ) ) + // InternalBehaviorAnnexParser.g:4074:3: (lv_value_0_0= RULE_REAL_LIT ) { - // InternalBehaviorAnnexParser.g:4072:3: (lv_value_0_0= RULE_REAL_LIT ) - // InternalBehaviorAnnexParser.g:4073:4: lv_value_0_0= RULE_REAL_LIT + // InternalBehaviorAnnexParser.g:4074:3: (lv_value_0_0= RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:4075:4: lv_value_0_0= RULE_REAL_LIT { lv_value_0_0=(Token)match(input,RULE_REAL_LIT,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -11823,7 +11840,7 @@ public final EObject ruleBehaviorRealLiteral() throws RecognitionException { // $ANTLR start "entryRuleBehaviorStringLiteral" - // InternalBehaviorAnnexParser.g:4092:1: entryRuleBehaviorStringLiteral returns [EObject current=null] : iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF ; + // InternalBehaviorAnnexParser.g:4094:1: entryRuleBehaviorStringLiteral returns [EObject current=null] : iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF ; public final EObject entryRuleBehaviorStringLiteral() throws RecognitionException { EObject current = null; @@ -11831,8 +11848,8 @@ public final EObject entryRuleBehaviorStringLiteral() throws RecognitionExceptio try { - // InternalBehaviorAnnexParser.g:4092:62: (iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF ) - // InternalBehaviorAnnexParser.g:4093:2: iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF + // InternalBehaviorAnnexParser.g:4094:62: (iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF ) + // InternalBehaviorAnnexParser.g:4095:2: iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBehaviorStringLiteralRule()); @@ -11863,7 +11880,7 @@ public final EObject entryRuleBehaviorStringLiteral() throws RecognitionExceptio // $ANTLR start "ruleBehaviorStringLiteral" - // InternalBehaviorAnnexParser.g:4099:1: ruleBehaviorStringLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; + // InternalBehaviorAnnexParser.g:4101:1: ruleBehaviorStringLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; public final EObject ruleBehaviorStringLiteral() throws RecognitionException { EObject current = null; @@ -11873,14 +11890,14 @@ public final EObject ruleBehaviorStringLiteral() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4105:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) - // InternalBehaviorAnnexParser.g:4106:2: ( (lv_value_0_0= RULE_STRING ) ) + // InternalBehaviorAnnexParser.g:4107:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) + // InternalBehaviorAnnexParser.g:4108:2: ( (lv_value_0_0= RULE_STRING ) ) { - // InternalBehaviorAnnexParser.g:4106:2: ( (lv_value_0_0= RULE_STRING ) ) - // InternalBehaviorAnnexParser.g:4107:3: (lv_value_0_0= RULE_STRING ) + // InternalBehaviorAnnexParser.g:4108:2: ( (lv_value_0_0= RULE_STRING ) ) + // InternalBehaviorAnnexParser.g:4109:3: (lv_value_0_0= RULE_STRING ) { - // InternalBehaviorAnnexParser.g:4107:3: (lv_value_0_0= RULE_STRING ) - // InternalBehaviorAnnexParser.g:4108:4: lv_value_0_0= RULE_STRING + // InternalBehaviorAnnexParser.g:4109:3: (lv_value_0_0= RULE_STRING ) + // InternalBehaviorAnnexParser.g:4110:4: lv_value_0_0= RULE_STRING { lv_value_0_0=(Token)match(input,RULE_STRING,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -11928,7 +11945,7 @@ public final EObject ruleBehaviorStringLiteral() throws RecognitionException { // $ANTLR start "entryRuleBehaviorBooleanLiteral" - // InternalBehaviorAnnexParser.g:4127:1: entryRuleBehaviorBooleanLiteral returns [EObject current=null] : iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF ; + // InternalBehaviorAnnexParser.g:4129:1: entryRuleBehaviorBooleanLiteral returns [EObject current=null] : iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF ; public final EObject entryRuleBehaviorBooleanLiteral() throws RecognitionException { EObject current = null; @@ -11936,8 +11953,8 @@ public final EObject entryRuleBehaviorBooleanLiteral() throws RecognitionExcepti try { - // InternalBehaviorAnnexParser.g:4127:63: (iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF ) - // InternalBehaviorAnnexParser.g:4128:2: iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF + // InternalBehaviorAnnexParser.g:4129:63: (iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF ) + // InternalBehaviorAnnexParser.g:4130:2: iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBehaviorBooleanLiteralRule()); @@ -11968,7 +11985,7 @@ public final EObject entryRuleBehaviorBooleanLiteral() throws RecognitionExcepti // $ANTLR start "ruleBehaviorBooleanLiteral" - // InternalBehaviorAnnexParser.g:4134:1: ruleBehaviorBooleanLiteral returns [EObject current=null] : ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ; + // InternalBehaviorAnnexParser.g:4136:1: ruleBehaviorBooleanLiteral returns [EObject current=null] : ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ; public final EObject ruleBehaviorBooleanLiteral() throws RecognitionException { EObject current = null; @@ -11979,14 +11996,14 @@ public final EObject ruleBehaviorBooleanLiteral() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4140:2: ( ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ) - // InternalBehaviorAnnexParser.g:4141:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) + // InternalBehaviorAnnexParser.g:4142:2: ( ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ) + // InternalBehaviorAnnexParser.g:4143:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) { - // InternalBehaviorAnnexParser.g:4141:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) - // InternalBehaviorAnnexParser.g:4142:3: () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) + // InternalBehaviorAnnexParser.g:4143:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) + // InternalBehaviorAnnexParser.g:4144:3: () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) { - // InternalBehaviorAnnexParser.g:4142:3: () - // InternalBehaviorAnnexParser.g:4143:4: + // InternalBehaviorAnnexParser.g:4144:3: () + // InternalBehaviorAnnexParser.g:4145:4: { if ( state.backtracking==0 ) { @@ -11998,32 +12015,32 @@ public final EObject ruleBehaviorBooleanLiteral() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4149:3: ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) - int alt75=2; - int LA75_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:4151:3: ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) + int alt76=2; + int LA76_0 = input.LA(1); - if ( (LA75_0==True) ) { - alt75=1; + if ( (LA76_0==True) ) { + alt76=1; } - else if ( (LA75_0==False) ) { - alt75=2; + else if ( (LA76_0==False) ) { + alt76=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 75, 0, input); + new NoViableAltException("", 76, 0, input); throw nvae; } - switch (alt75) { + switch (alt76) { case 1 : - // InternalBehaviorAnnexParser.g:4150:4: ( (lv_value_1_0= True ) ) + // InternalBehaviorAnnexParser.g:4152:4: ( (lv_value_1_0= True ) ) { - // InternalBehaviorAnnexParser.g:4150:4: ( (lv_value_1_0= True ) ) - // InternalBehaviorAnnexParser.g:4151:5: (lv_value_1_0= True ) + // InternalBehaviorAnnexParser.g:4152:4: ( (lv_value_1_0= True ) ) + // InternalBehaviorAnnexParser.g:4153:5: (lv_value_1_0= True ) { - // InternalBehaviorAnnexParser.g:4151:5: (lv_value_1_0= True ) - // InternalBehaviorAnnexParser.g:4152:6: lv_value_1_0= True + // InternalBehaviorAnnexParser.g:4153:5: (lv_value_1_0= True ) + // InternalBehaviorAnnexParser.g:4154:6: lv_value_1_0= True { lv_value_1_0=(Token)match(input,True,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12049,7 +12066,7 @@ else if ( (LA75_0==False) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:4165:4: otherlv_2= False + // InternalBehaviorAnnexParser.g:4167:4: otherlv_2= False { otherlv_2=(Token)match(input,False,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12088,7 +12105,7 @@ else if ( (LA75_0==False) ) { // $ANTLR start "entryRuleReferenceExpression" - // InternalBehaviorAnnexParser.g:4174:1: entryRuleReferenceExpression returns [EObject current=null] : iv_ruleReferenceExpression= ruleReferenceExpression EOF ; + // InternalBehaviorAnnexParser.g:4176:1: entryRuleReferenceExpression returns [EObject current=null] : iv_ruleReferenceExpression= ruleReferenceExpression EOF ; public final EObject entryRuleReferenceExpression() throws RecognitionException { EObject current = null; @@ -12096,8 +12113,8 @@ public final EObject entryRuleReferenceExpression() throws RecognitionException try { - // InternalBehaviorAnnexParser.g:4174:60: (iv_ruleReferenceExpression= ruleReferenceExpression EOF ) - // InternalBehaviorAnnexParser.g:4175:2: iv_ruleReferenceExpression= ruleReferenceExpression EOF + // InternalBehaviorAnnexParser.g:4176:60: (iv_ruleReferenceExpression= ruleReferenceExpression EOF ) + // InternalBehaviorAnnexParser.g:4177:2: iv_ruleReferenceExpression= ruleReferenceExpression EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceExpressionRule()); @@ -12128,7 +12145,7 @@ public final EObject entryRuleReferenceExpression() throws RecognitionException // $ANTLR start "ruleReferenceExpression" - // InternalBehaviorAnnexParser.g:4181:1: ruleReferenceExpression returns [EObject current=null] : ( ( (lv_reference_0_0= ruleReference ) ) ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? ) ; + // InternalBehaviorAnnexParser.g:4183:1: ruleReferenceExpression returns [EObject current=null] : ( ( (lv_reference_0_0= ruleReference ) ) ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? ) ; public final EObject ruleReferenceExpression() throws RecognitionException { EObject current = null; @@ -12146,24 +12163,24 @@ public final EObject ruleReferenceExpression() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4187:2: ( ( ( (lv_reference_0_0= ruleReference ) ) ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? ) ) - // InternalBehaviorAnnexParser.g:4188:2: ( ( (lv_reference_0_0= ruleReference ) ) ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? ) + // InternalBehaviorAnnexParser.g:4189:2: ( ( ( (lv_reference_0_0= ruleReference ) ) ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? ) ) + // InternalBehaviorAnnexParser.g:4190:2: ( ( (lv_reference_0_0= ruleReference ) ) ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? ) { - // InternalBehaviorAnnexParser.g:4188:2: ( ( (lv_reference_0_0= ruleReference ) ) ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? ) - // InternalBehaviorAnnexParser.g:4189:3: ( (lv_reference_0_0= ruleReference ) ) ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? + // InternalBehaviorAnnexParser.g:4190:2: ( ( (lv_reference_0_0= ruleReference ) ) ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? ) + // InternalBehaviorAnnexParser.g:4191:3: ( (lv_reference_0_0= ruleReference ) ) ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? { - // InternalBehaviorAnnexParser.g:4189:3: ( (lv_reference_0_0= ruleReference ) ) - // InternalBehaviorAnnexParser.g:4190:4: (lv_reference_0_0= ruleReference ) + // InternalBehaviorAnnexParser.g:4191:3: ( (lv_reference_0_0= ruleReference ) ) + // InternalBehaviorAnnexParser.g:4192:4: (lv_reference_0_0= ruleReference ) { - // InternalBehaviorAnnexParser.g:4190:4: (lv_reference_0_0= ruleReference ) - // InternalBehaviorAnnexParser.g:4191:5: lv_reference_0_0= ruleReference + // InternalBehaviorAnnexParser.g:4192:4: (lv_reference_0_0= ruleReference ) + // InternalBehaviorAnnexParser.g:4193:5: lv_reference_0_0= ruleReference { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceExpressionAccess().getReferenceReferenceParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_70); + pushFollow(FollowSets000.FOLLOW_71); lv_reference_0_0=ruleReference(); state._fsp--; @@ -12187,35 +12204,35 @@ public final EObject ruleReferenceExpression() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4208:3: ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? - int alt77=4; + // InternalBehaviorAnnexParser.g:4210:3: ( ( (lv_property_1_0= rulePropertyReferenceTail ) ) | ( (lv_dequeue_2_0= QuestionMark ) ) | (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) )? + int alt78=4; switch ( input.LA(1) ) { case NumberSign: { - alt77=1; + alt78=1; } break; case QuestionMark: { - alt77=2; + alt78=2; } break; case Apostrophe: { - alt77=3; + alt78=3; } break; } - switch (alt77) { + switch (alt78) { case 1 : - // InternalBehaviorAnnexParser.g:4209:4: ( (lv_property_1_0= rulePropertyReferenceTail ) ) + // InternalBehaviorAnnexParser.g:4211:4: ( (lv_property_1_0= rulePropertyReferenceTail ) ) { - // InternalBehaviorAnnexParser.g:4209:4: ( (lv_property_1_0= rulePropertyReferenceTail ) ) - // InternalBehaviorAnnexParser.g:4210:5: (lv_property_1_0= rulePropertyReferenceTail ) + // InternalBehaviorAnnexParser.g:4211:4: ( (lv_property_1_0= rulePropertyReferenceTail ) ) + // InternalBehaviorAnnexParser.g:4212:5: (lv_property_1_0= rulePropertyReferenceTail ) { - // InternalBehaviorAnnexParser.g:4210:5: (lv_property_1_0= rulePropertyReferenceTail ) - // InternalBehaviorAnnexParser.g:4211:6: lv_property_1_0= rulePropertyReferenceTail + // InternalBehaviorAnnexParser.g:4212:5: (lv_property_1_0= rulePropertyReferenceTail ) + // InternalBehaviorAnnexParser.g:4213:6: lv_property_1_0= rulePropertyReferenceTail { if ( state.backtracking==0 ) { @@ -12250,13 +12267,13 @@ public final EObject ruleReferenceExpression() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:4229:4: ( (lv_dequeue_2_0= QuestionMark ) ) + // InternalBehaviorAnnexParser.g:4231:4: ( (lv_dequeue_2_0= QuestionMark ) ) { - // InternalBehaviorAnnexParser.g:4229:4: ( (lv_dequeue_2_0= QuestionMark ) ) - // InternalBehaviorAnnexParser.g:4230:5: (lv_dequeue_2_0= QuestionMark ) + // InternalBehaviorAnnexParser.g:4231:4: ( (lv_dequeue_2_0= QuestionMark ) ) + // InternalBehaviorAnnexParser.g:4232:5: (lv_dequeue_2_0= QuestionMark ) { - // InternalBehaviorAnnexParser.g:4230:5: (lv_dequeue_2_0= QuestionMark ) - // InternalBehaviorAnnexParser.g:4231:6: lv_dequeue_2_0= QuestionMark + // InternalBehaviorAnnexParser.g:4232:5: (lv_dequeue_2_0= QuestionMark ) + // InternalBehaviorAnnexParser.g:4233:6: lv_dequeue_2_0= QuestionMark { lv_dequeue_2_0=(Token)match(input,QuestionMark,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12282,52 +12299,52 @@ public final EObject ruleReferenceExpression() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:4244:4: (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) + // InternalBehaviorAnnexParser.g:4246:4: (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) { - // InternalBehaviorAnnexParser.g:4244:4: (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) - // InternalBehaviorAnnexParser.g:4245:5: otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) + // InternalBehaviorAnnexParser.g:4246:4: (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) + // InternalBehaviorAnnexParser.g:4247:5: otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) { - otherlv_3=(Token)match(input,Apostrophe,FollowSets000.FOLLOW_71); if (state.failed) return current; + otherlv_3=(Token)match(input,Apostrophe,FollowSets000.FOLLOW_72); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getReferenceExpressionAccess().getApostropheKeyword_1_2_0()); } - // InternalBehaviorAnnexParser.g:4249:5: ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) - int alt76=3; + // InternalBehaviorAnnexParser.g:4251:5: ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) + int alt77=3; switch ( input.LA(1) ) { case Count: { - alt76=1; + alt77=1; } break; case Fresh: { - alt76=2; + alt77=2; } break; case Updated: { - alt76=3; + alt77=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 76, 0, input); + new NoViableAltException("", 77, 0, input); throw nvae; } - switch (alt76) { + switch (alt77) { case 1 : - // InternalBehaviorAnnexParser.g:4250:6: ( (lv_count_4_0= Count ) ) + // InternalBehaviorAnnexParser.g:4252:6: ( (lv_count_4_0= Count ) ) { - // InternalBehaviorAnnexParser.g:4250:6: ( (lv_count_4_0= Count ) ) - // InternalBehaviorAnnexParser.g:4251:7: (lv_count_4_0= Count ) + // InternalBehaviorAnnexParser.g:4252:6: ( (lv_count_4_0= Count ) ) + // InternalBehaviorAnnexParser.g:4253:7: (lv_count_4_0= Count ) { - // InternalBehaviorAnnexParser.g:4251:7: (lv_count_4_0= Count ) - // InternalBehaviorAnnexParser.g:4252:8: lv_count_4_0= Count + // InternalBehaviorAnnexParser.g:4253:7: (lv_count_4_0= Count ) + // InternalBehaviorAnnexParser.g:4254:8: lv_count_4_0= Count { lv_count_4_0=(Token)match(input,Count,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12353,13 +12370,13 @@ public final EObject ruleReferenceExpression() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:4265:6: ( (lv_fresh_5_0= Fresh ) ) + // InternalBehaviorAnnexParser.g:4267:6: ( (lv_fresh_5_0= Fresh ) ) { - // InternalBehaviorAnnexParser.g:4265:6: ( (lv_fresh_5_0= Fresh ) ) - // InternalBehaviorAnnexParser.g:4266:7: (lv_fresh_5_0= Fresh ) + // InternalBehaviorAnnexParser.g:4267:6: ( (lv_fresh_5_0= Fresh ) ) + // InternalBehaviorAnnexParser.g:4268:7: (lv_fresh_5_0= Fresh ) { - // InternalBehaviorAnnexParser.g:4266:7: (lv_fresh_5_0= Fresh ) - // InternalBehaviorAnnexParser.g:4267:8: lv_fresh_5_0= Fresh + // InternalBehaviorAnnexParser.g:4268:7: (lv_fresh_5_0= Fresh ) + // InternalBehaviorAnnexParser.g:4269:8: lv_fresh_5_0= Fresh { lv_fresh_5_0=(Token)match(input,Fresh,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12385,13 +12402,13 @@ public final EObject ruleReferenceExpression() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:4280:6: ( (lv_updated_6_0= Updated ) ) + // InternalBehaviorAnnexParser.g:4282:6: ( (lv_updated_6_0= Updated ) ) { - // InternalBehaviorAnnexParser.g:4280:6: ( (lv_updated_6_0= Updated ) ) - // InternalBehaviorAnnexParser.g:4281:7: (lv_updated_6_0= Updated ) + // InternalBehaviorAnnexParser.g:4282:6: ( (lv_updated_6_0= Updated ) ) + // InternalBehaviorAnnexParser.g:4283:7: (lv_updated_6_0= Updated ) { - // InternalBehaviorAnnexParser.g:4281:7: (lv_updated_6_0= Updated ) - // InternalBehaviorAnnexParser.g:4282:8: lv_updated_6_0= Updated + // InternalBehaviorAnnexParser.g:4283:7: (lv_updated_6_0= Updated ) + // InternalBehaviorAnnexParser.g:4284:8: lv_updated_6_0= Updated { lv_updated_6_0=(Token)match(input,Updated,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12453,7 +12470,7 @@ public final EObject ruleReferenceExpression() throws RecognitionException { // $ANTLR start "entryRuleHashPropertyReference" - // InternalBehaviorAnnexParser.g:4301:1: entryRuleHashPropertyReference returns [EObject current=null] : iv_ruleHashPropertyReference= ruleHashPropertyReference EOF ; + // InternalBehaviorAnnexParser.g:4303:1: entryRuleHashPropertyReference returns [EObject current=null] : iv_ruleHashPropertyReference= ruleHashPropertyReference EOF ; public final EObject entryRuleHashPropertyReference() throws RecognitionException { EObject current = null; @@ -12461,8 +12478,8 @@ public final EObject entryRuleHashPropertyReference() throws RecognitionExceptio try { - // InternalBehaviorAnnexParser.g:4301:62: (iv_ruleHashPropertyReference= ruleHashPropertyReference EOF ) - // InternalBehaviorAnnexParser.g:4302:2: iv_ruleHashPropertyReference= ruleHashPropertyReference EOF + // InternalBehaviorAnnexParser.g:4303:62: (iv_ruleHashPropertyReference= ruleHashPropertyReference EOF ) + // InternalBehaviorAnnexParser.g:4304:2: iv_ruleHashPropertyReference= ruleHashPropertyReference EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getHashPropertyReferenceRule()); @@ -12493,7 +12510,7 @@ public final EObject entryRuleHashPropertyReference() throws RecognitionExceptio // $ANTLR start "ruleHashPropertyReference" - // InternalBehaviorAnnexParser.g:4308:1: ruleHashPropertyReference returns [EObject current=null] : (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) ; + // InternalBehaviorAnnexParser.g:4310:1: ruleHashPropertyReference returns [EObject current=null] : (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) ; public final EObject ruleHashPropertyReference() throws RecognitionException { EObject current = null; @@ -12509,11 +12526,11 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4314:2: ( (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) ) - // InternalBehaviorAnnexParser.g:4315:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) + // InternalBehaviorAnnexParser.g:4316:2: ( (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) ) + // InternalBehaviorAnnexParser.g:4317:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) { - // InternalBehaviorAnnexParser.g:4315:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) - // InternalBehaviorAnnexParser.g:4316:3: otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* + // InternalBehaviorAnnexParser.g:4317:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) + // InternalBehaviorAnnexParser.g:4318:3: otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* { otherlv_0=(Token)match(input,NumberSign,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12521,18 +12538,18 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getHashPropertyReferenceAccess().getNumberSignKeyword_0()); } - // InternalBehaviorAnnexParser.g:4320:3: ( (lv_property_1_0= ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:4321:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4322:3: ( (lv_property_1_0= ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:4323:4: (lv_property_1_0= ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:4321:4: (lv_property_1_0= ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:4322:5: lv_property_1_0= ruleQualifiedName + // InternalBehaviorAnnexParser.g:4323:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4324:5: lv_property_1_0= ruleQualifiedName { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getHashPropertyReferenceAccess().getPropertyQualifiedNameParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_72); + pushFollow(FollowSets000.FOLLOW_73); lv_property_1_0=ruleQualifiedName(); state._fsp--; @@ -12556,30 +12573,30 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4339:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* - loop78: + // InternalBehaviorAnnexParser.g:4341:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* + loop79: do { - int alt78=2; - int LA78_0 = input.LA(1); + int alt79=2; + int LA79_0 = input.LA(1); - if ( (LA78_0==LeftSquareBracket) ) { - alt78=1; + if ( (LA79_0==LeftSquareBracket) ) { + alt79=1; } - switch (alt78) { + switch (alt79) { case 1 : - // InternalBehaviorAnnexParser.g:4340:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4342:4: (lv_indexes_2_0= rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:4340:4: (lv_indexes_2_0= rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:4341:5: lv_indexes_2_0= rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:4342:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4343:5: lv_indexes_2_0= rulePropertyArrayIndex { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getHashPropertyReferenceAccess().getIndexesPropertyArrayIndexParserRuleCall_2_0()); } - pushFollow(FollowSets000.FOLLOW_72); + pushFollow(FollowSets000.FOLLOW_73); lv_indexes_2_0=rulePropertyArrayIndex(); state._fsp--; @@ -12605,34 +12622,34 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { break; default : - break loop78; + break loop79; } } while (true); - // InternalBehaviorAnnexParser.g:4358:3: ( (lv_fields_3_0= ruleNamedPropertyField ) )* - loop79: + // InternalBehaviorAnnexParser.g:4360:3: ( (lv_fields_3_0= ruleNamedPropertyField ) )* + loop80: do { - int alt79=2; - int LA79_0 = input.LA(1); + int alt80=2; + int LA80_0 = input.LA(1); - if ( (LA79_0==FullStop) ) { - alt79=1; + if ( (LA80_0==FullStop) ) { + alt80=1; } - switch (alt79) { + switch (alt80) { case 1 : - // InternalBehaviorAnnexParser.g:4359:4: (lv_fields_3_0= ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:4361:4: (lv_fields_3_0= ruleNamedPropertyField ) { - // InternalBehaviorAnnexParser.g:4359:4: (lv_fields_3_0= ruleNamedPropertyField ) - // InternalBehaviorAnnexParser.g:4360:5: lv_fields_3_0= ruleNamedPropertyField + // InternalBehaviorAnnexParser.g:4361:4: (lv_fields_3_0= ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:4362:5: lv_fields_3_0= ruleNamedPropertyField { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getHashPropertyReferenceAccess().getFieldsNamedPropertyFieldParserRuleCall_3_0()); } - pushFollow(FollowSets000.FOLLOW_73); + pushFollow(FollowSets000.FOLLOW_74); lv_fields_3_0=ruleNamedPropertyField(); state._fsp--; @@ -12658,7 +12675,7 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { break; default : - break loop79; + break loop80; } } while (true); @@ -12687,7 +12704,7 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { // $ANTLR start "entryRulePropertyReferenceTail" - // InternalBehaviorAnnexParser.g:4381:1: entryRulePropertyReferenceTail returns [EObject current=null] : iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF ; + // InternalBehaviorAnnexParser.g:4383:1: entryRulePropertyReferenceTail returns [EObject current=null] : iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF ; public final EObject entryRulePropertyReferenceTail() throws RecognitionException { EObject current = null; @@ -12695,8 +12712,8 @@ public final EObject entryRulePropertyReferenceTail() throws RecognitionExceptio try { - // InternalBehaviorAnnexParser.g:4381:62: (iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF ) - // InternalBehaviorAnnexParser.g:4382:2: iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF + // InternalBehaviorAnnexParser.g:4383:62: (iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF ) + // InternalBehaviorAnnexParser.g:4384:2: iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyReferenceTailRule()); @@ -12727,7 +12744,7 @@ public final EObject entryRulePropertyReferenceTail() throws RecognitionExceptio // $ANTLR start "rulePropertyReferenceTail" - // InternalBehaviorAnnexParser.g:4388:1: rulePropertyReferenceTail returns [EObject current=null] : (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) ; + // InternalBehaviorAnnexParser.g:4390:1: rulePropertyReferenceTail returns [EObject current=null] : (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) ; public final EObject rulePropertyReferenceTail() throws RecognitionException { EObject current = null; @@ -12743,11 +12760,11 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4394:2: ( (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) ) - // InternalBehaviorAnnexParser.g:4395:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) + // InternalBehaviorAnnexParser.g:4396:2: ( (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) ) + // InternalBehaviorAnnexParser.g:4397:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) { - // InternalBehaviorAnnexParser.g:4395:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) - // InternalBehaviorAnnexParser.g:4396:3: otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* + // InternalBehaviorAnnexParser.g:4397:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) + // InternalBehaviorAnnexParser.g:4398:3: otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* { otherlv_0=(Token)match(input,NumberSign,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12755,18 +12772,18 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getPropertyReferenceTailAccess().getNumberSignKeyword_0()); } - // InternalBehaviorAnnexParser.g:4400:3: ( (lv_property_1_0= ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:4401:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4402:3: ( (lv_property_1_0= ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:4403:4: (lv_property_1_0= ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:4401:4: (lv_property_1_0= ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:4402:5: lv_property_1_0= ruleQualifiedName + // InternalBehaviorAnnexParser.g:4403:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4404:5: lv_property_1_0= ruleQualifiedName { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyReferenceTailAccess().getPropertyQualifiedNameParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_72); + pushFollow(FollowSets000.FOLLOW_73); lv_property_1_0=ruleQualifiedName(); state._fsp--; @@ -12790,30 +12807,30 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4419:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* - loop80: + // InternalBehaviorAnnexParser.g:4421:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* + loop81: do { - int alt80=2; - int LA80_0 = input.LA(1); + int alt81=2; + int LA81_0 = input.LA(1); - if ( (LA80_0==LeftSquareBracket) ) { - alt80=1; + if ( (LA81_0==LeftSquareBracket) ) { + alt81=1; } - switch (alt80) { + switch (alt81) { case 1 : - // InternalBehaviorAnnexParser.g:4420:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4422:4: (lv_indexes_2_0= rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:4420:4: (lv_indexes_2_0= rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:4421:5: lv_indexes_2_0= rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:4422:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4423:5: lv_indexes_2_0= rulePropertyArrayIndex { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyReferenceTailAccess().getIndexesPropertyArrayIndexParserRuleCall_2_0()); } - pushFollow(FollowSets000.FOLLOW_72); + pushFollow(FollowSets000.FOLLOW_73); lv_indexes_2_0=rulePropertyArrayIndex(); state._fsp--; @@ -12839,34 +12856,34 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { break; default : - break loop80; + break loop81; } } while (true); - // InternalBehaviorAnnexParser.g:4438:3: ( (lv_fields_3_0= ruleNamedPropertyField ) )* - loop81: + // InternalBehaviorAnnexParser.g:4440:3: ( (lv_fields_3_0= ruleNamedPropertyField ) )* + loop82: do { - int alt81=2; - int LA81_0 = input.LA(1); + int alt82=2; + int LA82_0 = input.LA(1); - if ( (LA81_0==FullStop) ) { - alt81=1; + if ( (LA82_0==FullStop) ) { + alt82=1; } - switch (alt81) { + switch (alt82) { case 1 : - // InternalBehaviorAnnexParser.g:4439:4: (lv_fields_3_0= ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:4441:4: (lv_fields_3_0= ruleNamedPropertyField ) { - // InternalBehaviorAnnexParser.g:4439:4: (lv_fields_3_0= ruleNamedPropertyField ) - // InternalBehaviorAnnexParser.g:4440:5: lv_fields_3_0= ruleNamedPropertyField + // InternalBehaviorAnnexParser.g:4441:4: (lv_fields_3_0= ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:4442:5: lv_fields_3_0= ruleNamedPropertyField { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyReferenceTailAccess().getFieldsNamedPropertyFieldParserRuleCall_3_0()); } - pushFollow(FollowSets000.FOLLOW_73); + pushFollow(FollowSets000.FOLLOW_74); lv_fields_3_0=ruleNamedPropertyField(); state._fsp--; @@ -12892,7 +12909,7 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { break; default : - break loop81; + break loop82; } } while (true); @@ -12921,7 +12938,7 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { // $ANTLR start "entryRuleNamedPropertyField" - // InternalBehaviorAnnexParser.g:4461:1: entryRuleNamedPropertyField returns [EObject current=null] : iv_ruleNamedPropertyField= ruleNamedPropertyField EOF ; + // InternalBehaviorAnnexParser.g:4463:1: entryRuleNamedPropertyField returns [EObject current=null] : iv_ruleNamedPropertyField= ruleNamedPropertyField EOF ; public final EObject entryRuleNamedPropertyField() throws RecognitionException { EObject current = null; @@ -12929,8 +12946,8 @@ public final EObject entryRuleNamedPropertyField() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4461:59: (iv_ruleNamedPropertyField= ruleNamedPropertyField EOF ) - // InternalBehaviorAnnexParser.g:4462:2: iv_ruleNamedPropertyField= ruleNamedPropertyField EOF + // InternalBehaviorAnnexParser.g:4463:59: (iv_ruleNamedPropertyField= ruleNamedPropertyField EOF ) + // InternalBehaviorAnnexParser.g:4464:2: iv_ruleNamedPropertyField= ruleNamedPropertyField EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNamedPropertyFieldRule()); @@ -12961,7 +12978,7 @@ public final EObject entryRuleNamedPropertyField() throws RecognitionException { // $ANTLR start "ruleNamedPropertyField" - // InternalBehaviorAnnexParser.g:4468:1: ruleNamedPropertyField returns [EObject current=null] : (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) ; + // InternalBehaviorAnnexParser.g:4470:1: ruleNamedPropertyField returns [EObject current=null] : (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) ; public final EObject ruleNamedPropertyField() throws RecognitionException { EObject current = null; @@ -12974,11 +12991,11 @@ public final EObject ruleNamedPropertyField() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4474:2: ( (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) ) - // InternalBehaviorAnnexParser.g:4475:2: (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) + // InternalBehaviorAnnexParser.g:4476:2: ( (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) ) + // InternalBehaviorAnnexParser.g:4477:2: (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) { - // InternalBehaviorAnnexParser.g:4475:2: (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) - // InternalBehaviorAnnexParser.g:4476:3: otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* + // InternalBehaviorAnnexParser.g:4477:2: (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) + // InternalBehaviorAnnexParser.g:4478:3: otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* { otherlv_0=(Token)match(input,FullStop,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12986,11 +13003,11 @@ public final EObject ruleNamedPropertyField() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getNamedPropertyFieldAccess().getFullStopKeyword_0()); } - // InternalBehaviorAnnexParser.g:4480:3: ( (lv_name_1_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:4481:4: (lv_name_1_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:4482:3: ( (lv_name_1_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:4483:4: (lv_name_1_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:4481:4: (lv_name_1_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:4482:5: lv_name_1_0= RULE_ID + // InternalBehaviorAnnexParser.g:4483:4: (lv_name_1_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:4484:5: lv_name_1_0= RULE_ID { lv_name_1_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_13); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -13016,23 +13033,23 @@ public final EObject ruleNamedPropertyField() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4498:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* - loop82: + // InternalBehaviorAnnexParser.g:4500:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* + loop83: do { - int alt82=2; - int LA82_0 = input.LA(1); + int alt83=2; + int LA83_0 = input.LA(1); - if ( (LA82_0==LeftSquareBracket) ) { - alt82=1; + if ( (LA83_0==LeftSquareBracket) ) { + alt83=1; } - switch (alt82) { + switch (alt83) { case 1 : - // InternalBehaviorAnnexParser.g:4499:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4501:4: (lv_indexes_2_0= rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:4499:4: (lv_indexes_2_0= rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:4500:5: lv_indexes_2_0= rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:4501:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4502:5: lv_indexes_2_0= rulePropertyArrayIndex { if ( state.backtracking==0 ) { @@ -13065,7 +13082,7 @@ public final EObject ruleNamedPropertyField() throws RecognitionException { break; default : - break loop82; + break loop83; } } while (true); @@ -13094,7 +13111,7 @@ public final EObject ruleNamedPropertyField() throws RecognitionException { // $ANTLR start "entryRulePropertyArrayIndex" - // InternalBehaviorAnnexParser.g:4521:1: entryRulePropertyArrayIndex returns [EObject current=null] : iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF ; + // InternalBehaviorAnnexParser.g:4523:1: entryRulePropertyArrayIndex returns [EObject current=null] : iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF ; public final EObject entryRulePropertyArrayIndex() throws RecognitionException { EObject current = null; @@ -13102,8 +13119,8 @@ public final EObject entryRulePropertyArrayIndex() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4521:59: (iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF ) - // InternalBehaviorAnnexParser.g:4522:2: iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF + // InternalBehaviorAnnexParser.g:4523:59: (iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF ) + // InternalBehaviorAnnexParser.g:4524:2: iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyArrayIndexRule()); @@ -13134,7 +13151,7 @@ public final EObject entryRulePropertyArrayIndex() throws RecognitionException { // $ANTLR start "rulePropertyArrayIndex" - // InternalBehaviorAnnexParser.g:4528:1: rulePropertyArrayIndex returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:4530:1: rulePropertyArrayIndex returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) ; public final EObject rulePropertyArrayIndex() throws RecognitionException { EObject current = null; @@ -13147,23 +13164,23 @@ public final EObject rulePropertyArrayIndex() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4534:2: ( (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:4535:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) + // InternalBehaviorAnnexParser.g:4536:2: ( (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:4537:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:4535:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) - // InternalBehaviorAnnexParser.g:4536:3: otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket + // InternalBehaviorAnnexParser.g:4537:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) + // InternalBehaviorAnnexParser.g:4538:3: otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket { - otherlv_0=(Token)match(input,LeftSquareBracket,FollowSets000.FOLLOW_74); if (state.failed) return current; + otherlv_0=(Token)match(input,LeftSquareBracket,FollowSets000.FOLLOW_75); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getPropertyArrayIndexAccess().getLeftSquareBracketKeyword_0()); } - // InternalBehaviorAnnexParser.g:4540:3: ( (lv_value_1_0= rulePropertyIndexValue ) ) - // InternalBehaviorAnnexParser.g:4541:4: (lv_value_1_0= rulePropertyIndexValue ) + // InternalBehaviorAnnexParser.g:4542:3: ( (lv_value_1_0= rulePropertyIndexValue ) ) + // InternalBehaviorAnnexParser.g:4543:4: (lv_value_1_0= rulePropertyIndexValue ) { - // InternalBehaviorAnnexParser.g:4541:4: (lv_value_1_0= rulePropertyIndexValue ) - // InternalBehaviorAnnexParser.g:4542:5: lv_value_1_0= rulePropertyIndexValue + // InternalBehaviorAnnexParser.g:4543:4: (lv_value_1_0= rulePropertyIndexValue ) + // InternalBehaviorAnnexParser.g:4544:5: lv_value_1_0= rulePropertyIndexValue { if ( state.backtracking==0 ) { @@ -13225,7 +13242,7 @@ public final EObject rulePropertyArrayIndex() throws RecognitionException { // $ANTLR start "entryRulePropertyIndexValue" - // InternalBehaviorAnnexParser.g:4567:1: entryRulePropertyIndexValue returns [EObject current=null] : iv_rulePropertyIndexValue= rulePropertyIndexValue EOF ; + // InternalBehaviorAnnexParser.g:4569:1: entryRulePropertyIndexValue returns [EObject current=null] : iv_rulePropertyIndexValue= rulePropertyIndexValue EOF ; public final EObject entryRulePropertyIndexValue() throws RecognitionException { EObject current = null; @@ -13233,8 +13250,8 @@ public final EObject entryRulePropertyIndexValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4567:59: (iv_rulePropertyIndexValue= rulePropertyIndexValue EOF ) - // InternalBehaviorAnnexParser.g:4568:2: iv_rulePropertyIndexValue= rulePropertyIndexValue EOF + // InternalBehaviorAnnexParser.g:4569:59: (iv_rulePropertyIndexValue= rulePropertyIndexValue EOF ) + // InternalBehaviorAnnexParser.g:4570:2: iv_rulePropertyIndexValue= rulePropertyIndexValue EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyIndexValueRule()); @@ -13265,7 +13282,7 @@ public final EObject entryRulePropertyIndexValue() throws RecognitionException { // $ANTLR start "rulePropertyIndexValue" - // InternalBehaviorAnnexParser.g:4574:1: rulePropertyIndexValue returns [EObject current=null] : (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) ; + // InternalBehaviorAnnexParser.g:4576:1: rulePropertyIndexValue returns [EObject current=null] : (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) ; public final EObject rulePropertyIndexValue() throws RecognitionException { EObject current = null; @@ -13280,38 +13297,38 @@ public final EObject rulePropertyIndexValue() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4580:2: ( (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) ) - // InternalBehaviorAnnexParser.g:4581:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) + // InternalBehaviorAnnexParser.g:4582:2: ( (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) ) + // InternalBehaviorAnnexParser.g:4583:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) { - // InternalBehaviorAnnexParser.g:4581:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) - int alt83=3; + // InternalBehaviorAnnexParser.g:4583:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) + int alt84=3; switch ( input.LA(1) ) { case RULE_INTEGER_LIT: { - alt83=1; + alt84=1; } break; case NumberSign: { - alt83=2; + alt84=2; } break; case RULE_ID: { - alt83=3; + alt84=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 83, 0, input); + new NoViableAltException("", 84, 0, input); throw nvae; } - switch (alt83) { + switch (alt84) { case 1 : - // InternalBehaviorAnnexParser.g:4582:3: this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral + // InternalBehaviorAnnexParser.g:4584:3: this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral { if ( state.backtracking==0 ) { @@ -13333,7 +13350,7 @@ public final EObject rulePropertyIndexValue() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:4591:3: this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference + // InternalBehaviorAnnexParser.g:4593:3: this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference { if ( state.backtracking==0 ) { @@ -13355,7 +13372,7 @@ public final EObject rulePropertyIndexValue() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:4600:3: this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression + // InternalBehaviorAnnexParser.g:4602:3: this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression { if ( state.backtracking==0 ) { @@ -13401,7 +13418,7 @@ public final EObject rulePropertyIndexValue() throws RecognitionException { // $ANTLR start "entryRulePropertyIndexPropertyReference" - // InternalBehaviorAnnexParser.g:4612:1: entryRulePropertyIndexPropertyReference returns [EObject current=null] : iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF ; + // InternalBehaviorAnnexParser.g:4614:1: entryRulePropertyIndexPropertyReference returns [EObject current=null] : iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF ; public final EObject entryRulePropertyIndexPropertyReference() throws RecognitionException { EObject current = null; @@ -13409,8 +13426,8 @@ public final EObject entryRulePropertyIndexPropertyReference() throws Recognitio try { - // InternalBehaviorAnnexParser.g:4612:71: (iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF ) - // InternalBehaviorAnnexParser.g:4613:2: iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF + // InternalBehaviorAnnexParser.g:4614:71: (iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF ) + // InternalBehaviorAnnexParser.g:4615:2: iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyIndexPropertyReferenceRule()); @@ -13441,7 +13458,7 @@ public final EObject entryRulePropertyIndexPropertyReference() throws Recognitio // $ANTLR start "rulePropertyIndexPropertyReference" - // InternalBehaviorAnnexParser.g:4619:1: rulePropertyIndexPropertyReference returns [EObject current=null] : (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) ; + // InternalBehaviorAnnexParser.g:4621:1: rulePropertyIndexPropertyReference returns [EObject current=null] : (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) ; public final EObject rulePropertyIndexPropertyReference() throws RecognitionException { EObject current = null; @@ -13453,11 +13470,11 @@ public final EObject rulePropertyIndexPropertyReference() throws RecognitionExce enterRule(); try { - // InternalBehaviorAnnexParser.g:4625:2: ( (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) ) - // InternalBehaviorAnnexParser.g:4626:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) + // InternalBehaviorAnnexParser.g:4627:2: ( (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) ) + // InternalBehaviorAnnexParser.g:4628:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) { - // InternalBehaviorAnnexParser.g:4626:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) - // InternalBehaviorAnnexParser.g:4627:3: otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:4628:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) + // InternalBehaviorAnnexParser.g:4629:3: otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) { otherlv_0=(Token)match(input,NumberSign,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -13465,11 +13482,11 @@ public final EObject rulePropertyIndexPropertyReference() throws RecognitionExce newLeafNode(otherlv_0, grammarAccess.getPropertyIndexPropertyReferenceAccess().getNumberSignKeyword_0()); } - // InternalBehaviorAnnexParser.g:4631:3: ( (lv_property_1_0= ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:4632:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4633:3: ( (lv_property_1_0= ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:4634:4: (lv_property_1_0= ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:4632:4: (lv_property_1_0= ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:4633:5: lv_property_1_0= ruleQualifiedName + // InternalBehaviorAnnexParser.g:4634:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4635:5: lv_property_1_0= ruleQualifiedName { if ( state.backtracking==0 ) { @@ -13525,7 +13542,7 @@ public final EObject rulePropertyIndexPropertyReference() throws RecognitionExce // $ANTLR start "entryRuleUnindexedReferenceExpression" - // InternalBehaviorAnnexParser.g:4654:1: entryRuleUnindexedReferenceExpression returns [EObject current=null] : iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF ; + // InternalBehaviorAnnexParser.g:4656:1: entryRuleUnindexedReferenceExpression returns [EObject current=null] : iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF ; public final EObject entryRuleUnindexedReferenceExpression() throws RecognitionException { EObject current = null; @@ -13533,8 +13550,8 @@ public final EObject entryRuleUnindexedReferenceExpression() throws RecognitionE try { - // InternalBehaviorAnnexParser.g:4654:69: (iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF ) - // InternalBehaviorAnnexParser.g:4655:2: iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF + // InternalBehaviorAnnexParser.g:4656:69: (iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF ) + // InternalBehaviorAnnexParser.g:4657:2: iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceExpressionRule()); @@ -13565,7 +13582,7 @@ public final EObject entryRuleUnindexedReferenceExpression() throws RecognitionE // $ANTLR start "ruleUnindexedReferenceExpression" - // InternalBehaviorAnnexParser.g:4661:1: ruleUnindexedReferenceExpression returns [EObject current=null] : ( ( (lv_reference_0_0= ruleUnindexedReference ) ) ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? ) ; + // InternalBehaviorAnnexParser.g:4663:1: ruleUnindexedReferenceExpression returns [EObject current=null] : ( ( (lv_reference_0_0= ruleUnindexedReference ) ) ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? ) ; public final EObject ruleUnindexedReferenceExpression() throws RecognitionException { EObject current = null; @@ -13581,24 +13598,24 @@ public final EObject ruleUnindexedReferenceExpression() throws RecognitionExcept enterRule(); try { - // InternalBehaviorAnnexParser.g:4667:2: ( ( ( (lv_reference_0_0= ruleUnindexedReference ) ) ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? ) ) - // InternalBehaviorAnnexParser.g:4668:2: ( ( (lv_reference_0_0= ruleUnindexedReference ) ) ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? ) + // InternalBehaviorAnnexParser.g:4669:2: ( ( ( (lv_reference_0_0= ruleUnindexedReference ) ) ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? ) ) + // InternalBehaviorAnnexParser.g:4670:2: ( ( (lv_reference_0_0= ruleUnindexedReference ) ) ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? ) { - // InternalBehaviorAnnexParser.g:4668:2: ( ( (lv_reference_0_0= ruleUnindexedReference ) ) ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? ) - // InternalBehaviorAnnexParser.g:4669:3: ( (lv_reference_0_0= ruleUnindexedReference ) ) ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? + // InternalBehaviorAnnexParser.g:4670:2: ( ( (lv_reference_0_0= ruleUnindexedReference ) ) ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? ) + // InternalBehaviorAnnexParser.g:4671:3: ( (lv_reference_0_0= ruleUnindexedReference ) ) ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? { - // InternalBehaviorAnnexParser.g:4669:3: ( (lv_reference_0_0= ruleUnindexedReference ) ) - // InternalBehaviorAnnexParser.g:4670:4: (lv_reference_0_0= ruleUnindexedReference ) + // InternalBehaviorAnnexParser.g:4671:3: ( (lv_reference_0_0= ruleUnindexedReference ) ) + // InternalBehaviorAnnexParser.g:4672:4: (lv_reference_0_0= ruleUnindexedReference ) { - // InternalBehaviorAnnexParser.g:4670:4: (lv_reference_0_0= ruleUnindexedReference ) - // InternalBehaviorAnnexParser.g:4671:5: lv_reference_0_0= ruleUnindexedReference + // InternalBehaviorAnnexParser.g:4672:4: (lv_reference_0_0= ruleUnindexedReference ) + // InternalBehaviorAnnexParser.g:4673:5: lv_reference_0_0= ruleUnindexedReference { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceExpressionAccess().getReferenceUnindexedReferenceParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_75); + pushFollow(FollowSets000.FOLLOW_76); lv_reference_0_0=ruleUnindexedReference(); state._fsp--; @@ -13622,25 +13639,25 @@ public final EObject ruleUnindexedReferenceExpression() throws RecognitionExcept } - // InternalBehaviorAnnexParser.g:4688:3: ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? - int alt85=3; - int LA85_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:4690:3: ( ( (lv_dequeue_1_0= QuestionMark ) ) | (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) )? + int alt86=3; + int LA86_0 = input.LA(1); - if ( (LA85_0==QuestionMark) ) { - alt85=1; + if ( (LA86_0==QuestionMark) ) { + alt86=1; } - else if ( (LA85_0==Apostrophe) ) { - alt85=2; + else if ( (LA86_0==Apostrophe) ) { + alt86=2; } - switch (alt85) { + switch (alt86) { case 1 : - // InternalBehaviorAnnexParser.g:4689:4: ( (lv_dequeue_1_0= QuestionMark ) ) + // InternalBehaviorAnnexParser.g:4691:4: ( (lv_dequeue_1_0= QuestionMark ) ) { - // InternalBehaviorAnnexParser.g:4689:4: ( (lv_dequeue_1_0= QuestionMark ) ) - // InternalBehaviorAnnexParser.g:4690:5: (lv_dequeue_1_0= QuestionMark ) + // InternalBehaviorAnnexParser.g:4691:4: ( (lv_dequeue_1_0= QuestionMark ) ) + // InternalBehaviorAnnexParser.g:4692:5: (lv_dequeue_1_0= QuestionMark ) { - // InternalBehaviorAnnexParser.g:4690:5: (lv_dequeue_1_0= QuestionMark ) - // InternalBehaviorAnnexParser.g:4691:6: lv_dequeue_1_0= QuestionMark + // InternalBehaviorAnnexParser.g:4692:5: (lv_dequeue_1_0= QuestionMark ) + // InternalBehaviorAnnexParser.g:4693:6: lv_dequeue_1_0= QuestionMark { lv_dequeue_1_0=(Token)match(input,QuestionMark,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -13666,52 +13683,52 @@ else if ( (LA85_0==Apostrophe) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:4704:4: (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) + // InternalBehaviorAnnexParser.g:4706:4: (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) { - // InternalBehaviorAnnexParser.g:4704:4: (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) - // InternalBehaviorAnnexParser.g:4705:5: otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) + // InternalBehaviorAnnexParser.g:4706:4: (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) + // InternalBehaviorAnnexParser.g:4707:5: otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) { - otherlv_2=(Token)match(input,Apostrophe,FollowSets000.FOLLOW_71); if (state.failed) return current; + otherlv_2=(Token)match(input,Apostrophe,FollowSets000.FOLLOW_72); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getUnindexedReferenceExpressionAccess().getApostropheKeyword_1_1_0()); } - // InternalBehaviorAnnexParser.g:4709:5: ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) - int alt84=3; + // InternalBehaviorAnnexParser.g:4711:5: ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) + int alt85=3; switch ( input.LA(1) ) { case Count: { - alt84=1; + alt85=1; } break; case Fresh: { - alt84=2; + alt85=2; } break; case Updated: { - alt84=3; + alt85=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 84, 0, input); + new NoViableAltException("", 85, 0, input); throw nvae; } - switch (alt84) { + switch (alt85) { case 1 : - // InternalBehaviorAnnexParser.g:4710:6: ( (lv_count_3_0= Count ) ) + // InternalBehaviorAnnexParser.g:4712:6: ( (lv_count_3_0= Count ) ) { - // InternalBehaviorAnnexParser.g:4710:6: ( (lv_count_3_0= Count ) ) - // InternalBehaviorAnnexParser.g:4711:7: (lv_count_3_0= Count ) + // InternalBehaviorAnnexParser.g:4712:6: ( (lv_count_3_0= Count ) ) + // InternalBehaviorAnnexParser.g:4713:7: (lv_count_3_0= Count ) { - // InternalBehaviorAnnexParser.g:4711:7: (lv_count_3_0= Count ) - // InternalBehaviorAnnexParser.g:4712:8: lv_count_3_0= Count + // InternalBehaviorAnnexParser.g:4713:7: (lv_count_3_0= Count ) + // InternalBehaviorAnnexParser.g:4714:8: lv_count_3_0= Count { lv_count_3_0=(Token)match(input,Count,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -13737,13 +13754,13 @@ else if ( (LA85_0==Apostrophe) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:4725:6: ( (lv_fresh_4_0= Fresh ) ) + // InternalBehaviorAnnexParser.g:4727:6: ( (lv_fresh_4_0= Fresh ) ) { - // InternalBehaviorAnnexParser.g:4725:6: ( (lv_fresh_4_0= Fresh ) ) - // InternalBehaviorAnnexParser.g:4726:7: (lv_fresh_4_0= Fresh ) + // InternalBehaviorAnnexParser.g:4727:6: ( (lv_fresh_4_0= Fresh ) ) + // InternalBehaviorAnnexParser.g:4728:7: (lv_fresh_4_0= Fresh ) { - // InternalBehaviorAnnexParser.g:4726:7: (lv_fresh_4_0= Fresh ) - // InternalBehaviorAnnexParser.g:4727:8: lv_fresh_4_0= Fresh + // InternalBehaviorAnnexParser.g:4728:7: (lv_fresh_4_0= Fresh ) + // InternalBehaviorAnnexParser.g:4729:8: lv_fresh_4_0= Fresh { lv_fresh_4_0=(Token)match(input,Fresh,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -13769,13 +13786,13 @@ else if ( (LA85_0==Apostrophe) ) { } break; case 3 : - // InternalBehaviorAnnexParser.g:4740:6: ( (lv_updated_5_0= Updated ) ) + // InternalBehaviorAnnexParser.g:4742:6: ( (lv_updated_5_0= Updated ) ) { - // InternalBehaviorAnnexParser.g:4740:6: ( (lv_updated_5_0= Updated ) ) - // InternalBehaviorAnnexParser.g:4741:7: (lv_updated_5_0= Updated ) + // InternalBehaviorAnnexParser.g:4742:6: ( (lv_updated_5_0= Updated ) ) + // InternalBehaviorAnnexParser.g:4743:7: (lv_updated_5_0= Updated ) { - // InternalBehaviorAnnexParser.g:4741:7: (lv_updated_5_0= Updated ) - // InternalBehaviorAnnexParser.g:4742:8: lv_updated_5_0= Updated + // InternalBehaviorAnnexParser.g:4743:7: (lv_updated_5_0= Updated ) + // InternalBehaviorAnnexParser.g:4744:8: lv_updated_5_0= Updated { lv_updated_5_0=(Token)match(input,Updated,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -13837,7 +13854,7 @@ else if ( (LA85_0==Apostrophe) ) { // $ANTLR start "entryRuleUnindexedReference" - // InternalBehaviorAnnexParser.g:4761:1: entryRuleUnindexedReference returns [EObject current=null] : iv_ruleUnindexedReference= ruleUnindexedReference EOF ; + // InternalBehaviorAnnexParser.g:4763:1: entryRuleUnindexedReference returns [EObject current=null] : iv_ruleUnindexedReference= ruleUnindexedReference EOF ; public final EObject entryRuleUnindexedReference() throws RecognitionException { EObject current = null; @@ -13845,8 +13862,8 @@ public final EObject entryRuleUnindexedReference() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4761:59: (iv_ruleUnindexedReference= ruleUnindexedReference EOF ) - // InternalBehaviorAnnexParser.g:4762:2: iv_ruleUnindexedReference= ruleUnindexedReference EOF + // InternalBehaviorAnnexParser.g:4763:59: (iv_ruleUnindexedReference= ruleUnindexedReference EOF ) + // InternalBehaviorAnnexParser.g:4764:2: iv_ruleUnindexedReference= ruleUnindexedReference EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceRule()); @@ -13877,7 +13894,7 @@ public final EObject entryRuleUnindexedReference() throws RecognitionException { // $ANTLR start "ruleUnindexedReference" - // InternalBehaviorAnnexParser.g:4768:1: ruleUnindexedReference returns [EObject current=null] : ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) ; + // InternalBehaviorAnnexParser.g:4770:1: ruleUnindexedReference returns [EObject current=null] : ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) ; public final EObject ruleUnindexedReference() throws RecognitionException { EObject current = null; @@ -13890,24 +13907,24 @@ public final EObject ruleUnindexedReference() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4774:2: ( ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) ) - // InternalBehaviorAnnexParser.g:4775:2: ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) + // InternalBehaviorAnnexParser.g:4776:2: ( ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) ) + // InternalBehaviorAnnexParser.g:4777:2: ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) { - // InternalBehaviorAnnexParser.g:4775:2: ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) - // InternalBehaviorAnnexParser.g:4776:3: ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* + // InternalBehaviorAnnexParser.g:4777:2: ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) + // InternalBehaviorAnnexParser.g:4778:3: ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* { - // InternalBehaviorAnnexParser.g:4776:3: ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:4777:4: (lv_segments_0_0= ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:4778:3: ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:4779:4: (lv_segments_0_0= ruleUnindexedReferenceSegment ) { - // InternalBehaviorAnnexParser.g:4777:4: (lv_segments_0_0= ruleUnindexedReferenceSegment ) - // InternalBehaviorAnnexParser.g:4778:5: lv_segments_0_0= ruleUnindexedReferenceSegment + // InternalBehaviorAnnexParser.g:4779:4: (lv_segments_0_0= ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:4780:5: lv_segments_0_0= ruleUnindexedReferenceSegment { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceAccess().getSegmentsUnindexedReferenceSegmentParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_76); + pushFollow(FollowSets000.FOLLOW_77); lv_segments_0_0=ruleUnindexedReferenceSegment(); state._fsp--; @@ -13931,30 +13948,30 @@ public final EObject ruleUnindexedReference() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4795:3: ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* - loop86: + // InternalBehaviorAnnexParser.g:4797:3: ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* + loop87: do { - int alt86=2; - int LA86_0 = input.LA(1); + int alt87=2; + int LA87_0 = input.LA(1); - if ( (LA86_0==ColonColon||LA86_0==FullStop) ) { - alt86=1; + if ( (LA87_0==ColonColon||LA87_0==FullStop) ) { + alt87=1; } - switch (alt86) { + switch (alt87) { case 1 : - // InternalBehaviorAnnexParser.g:4796:4: (lv_tails_1_0= ruleUnindexedReferenceTail ) + // InternalBehaviorAnnexParser.g:4798:4: (lv_tails_1_0= ruleUnindexedReferenceTail ) { - // InternalBehaviorAnnexParser.g:4796:4: (lv_tails_1_0= ruleUnindexedReferenceTail ) - // InternalBehaviorAnnexParser.g:4797:5: lv_tails_1_0= ruleUnindexedReferenceTail + // InternalBehaviorAnnexParser.g:4798:4: (lv_tails_1_0= ruleUnindexedReferenceTail ) + // InternalBehaviorAnnexParser.g:4799:5: lv_tails_1_0= ruleUnindexedReferenceTail { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceAccess().getTailsUnindexedReferenceTailParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_76); + pushFollow(FollowSets000.FOLLOW_77); lv_tails_1_0=ruleUnindexedReferenceTail(); state._fsp--; @@ -13980,7 +13997,7 @@ public final EObject ruleUnindexedReference() throws RecognitionException { break; default : - break loop86; + break loop87; } } while (true); @@ -14009,7 +14026,7 @@ public final EObject ruleUnindexedReference() throws RecognitionException { // $ANTLR start "entryRuleUnindexedReferenceTail" - // InternalBehaviorAnnexParser.g:4818:1: entryRuleUnindexedReferenceTail returns [EObject current=null] : iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF ; + // InternalBehaviorAnnexParser.g:4820:1: entryRuleUnindexedReferenceTail returns [EObject current=null] : iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF ; public final EObject entryRuleUnindexedReferenceTail() throws RecognitionException { EObject current = null; @@ -14017,8 +14034,8 @@ public final EObject entryRuleUnindexedReferenceTail() throws RecognitionExcepti try { - // InternalBehaviorAnnexParser.g:4818:63: (iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF ) - // InternalBehaviorAnnexParser.g:4819:2: iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF + // InternalBehaviorAnnexParser.g:4820:63: (iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF ) + // InternalBehaviorAnnexParser.g:4821:2: iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceTailRule()); @@ -14049,7 +14066,7 @@ public final EObject entryRuleUnindexedReferenceTail() throws RecognitionExcepti // $ANTLR start "ruleUnindexedReferenceTail" - // InternalBehaviorAnnexParser.g:4825:1: ruleUnindexedReferenceTail returns [EObject current=null] : ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) ; + // InternalBehaviorAnnexParser.g:4827:1: ruleUnindexedReferenceTail returns [EObject current=null] : ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) ; public final EObject ruleUnindexedReferenceTail() throws RecognitionException { EObject current = null; @@ -14062,24 +14079,24 @@ public final EObject ruleUnindexedReferenceTail() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4831:2: ( ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) ) - // InternalBehaviorAnnexParser.g:4832:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) + // InternalBehaviorAnnexParser.g:4833:2: ( ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) ) + // InternalBehaviorAnnexParser.g:4834:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) { - // InternalBehaviorAnnexParser.g:4832:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) - // InternalBehaviorAnnexParser.g:4833:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:4834:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) + // InternalBehaviorAnnexParser.g:4835:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) { - // InternalBehaviorAnnexParser.g:4833:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) - // InternalBehaviorAnnexParser.g:4834:4: (lv_separator_0_0= ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:4835:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) + // InternalBehaviorAnnexParser.g:4836:4: (lv_separator_0_0= ruleReferenceSeparator ) { - // InternalBehaviorAnnexParser.g:4834:4: (lv_separator_0_0= ruleReferenceSeparator ) - // InternalBehaviorAnnexParser.g:4835:5: lv_separator_0_0= ruleReferenceSeparator + // InternalBehaviorAnnexParser.g:4836:4: (lv_separator_0_0= ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:4837:5: lv_separator_0_0= ruleReferenceSeparator { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceTailAccess().getSeparatorReferenceSeparatorParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_74); + pushFollow(FollowSets000.FOLLOW_75); lv_separator_0_0=ruleReferenceSeparator(); state._fsp--; @@ -14103,11 +14120,11 @@ public final EObject ruleUnindexedReferenceTail() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4852:3: ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:4853:4: (lv_segment_1_0= ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:4854:3: ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:4855:4: (lv_segment_1_0= ruleUnindexedReferenceSegment ) { - // InternalBehaviorAnnexParser.g:4853:4: (lv_segment_1_0= ruleUnindexedReferenceSegment ) - // InternalBehaviorAnnexParser.g:4854:5: lv_segment_1_0= ruleUnindexedReferenceSegment + // InternalBehaviorAnnexParser.g:4855:4: (lv_segment_1_0= ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:4856:5: lv_segment_1_0= ruleUnindexedReferenceSegment { if ( state.backtracking==0 ) { @@ -14163,7 +14180,7 @@ public final EObject ruleUnindexedReferenceTail() throws RecognitionException { // $ANTLR start "entryRuleUnindexedReferenceSegment" - // InternalBehaviorAnnexParser.g:4875:1: entryRuleUnindexedReferenceSegment returns [EObject current=null] : iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF ; + // InternalBehaviorAnnexParser.g:4877:1: entryRuleUnindexedReferenceSegment returns [EObject current=null] : iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF ; public final EObject entryRuleUnindexedReferenceSegment() throws RecognitionException { EObject current = null; @@ -14171,8 +14188,8 @@ public final EObject entryRuleUnindexedReferenceSegment() throws RecognitionExce try { - // InternalBehaviorAnnexParser.g:4875:66: (iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF ) - // InternalBehaviorAnnexParser.g:4876:2: iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF + // InternalBehaviorAnnexParser.g:4877:66: (iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF ) + // InternalBehaviorAnnexParser.g:4878:2: iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceSegmentRule()); @@ -14203,7 +14220,7 @@ public final EObject entryRuleUnindexedReferenceSegment() throws RecognitionExce // $ANTLR start "ruleUnindexedReferenceSegment" - // InternalBehaviorAnnexParser.g:4882:1: ruleUnindexedReferenceSegment returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:4884:1: ruleUnindexedReferenceSegment returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; public final EObject ruleUnindexedReferenceSegment() throws RecognitionException { EObject current = null; @@ -14213,14 +14230,14 @@ public final EObject ruleUnindexedReferenceSegment() throws RecognitionException enterRule(); try { - // InternalBehaviorAnnexParser.g:4888:2: ( ( (lv_name_0_0= RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:4889:2: ( (lv_name_0_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:4890:2: ( ( (lv_name_0_0= RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:4891:2: ( (lv_name_0_0= RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:4889:2: ( (lv_name_0_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:4890:3: (lv_name_0_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:4891:2: ( (lv_name_0_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:4892:3: (lv_name_0_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:4890:3: (lv_name_0_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:4891:4: lv_name_0_0= RULE_ID + // InternalBehaviorAnnexParser.g:4892:3: (lv_name_0_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:4893:4: lv_name_0_0= RULE_ID { lv_name_0_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -14268,7 +14285,7 @@ public final EObject ruleUnindexedReferenceSegment() throws RecognitionException // $ANTLR start "entryRuleQualifiedName" - // InternalBehaviorAnnexParser.g:4910:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; + // InternalBehaviorAnnexParser.g:4912:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; public final String entryRuleQualifiedName() throws RecognitionException { String current = null; @@ -14276,8 +14293,8 @@ public final String entryRuleQualifiedName() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4910:53: (iv_ruleQualifiedName= ruleQualifiedName EOF ) - // InternalBehaviorAnnexParser.g:4911:2: iv_ruleQualifiedName= ruleQualifiedName EOF + // InternalBehaviorAnnexParser.g:4912:53: (iv_ruleQualifiedName= ruleQualifiedName EOF ) + // InternalBehaviorAnnexParser.g:4913:2: iv_ruleQualifiedName= ruleQualifiedName EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getQualifiedNameRule()); @@ -14308,7 +14325,7 @@ public final String entryRuleQualifiedName() throws RecognitionException { // $ANTLR start "ruleQualifiedName" - // InternalBehaviorAnnexParser.g:4917:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) ; + // InternalBehaviorAnnexParser.g:4919:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) ; public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -14320,13 +14337,13 @@ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionExcept enterRule(); try { - // InternalBehaviorAnnexParser.g:4923:2: ( (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) ) - // InternalBehaviorAnnexParser.g:4924:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) + // InternalBehaviorAnnexParser.g:4925:2: ( (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) ) + // InternalBehaviorAnnexParser.g:4926:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) { - // InternalBehaviorAnnexParser.g:4924:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) - // InternalBehaviorAnnexParser.g:4925:3: this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* + // InternalBehaviorAnnexParser.g:4926:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) + // InternalBehaviorAnnexParser.g:4927:3: this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* { - this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_77); if (state.failed) return current; + this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_78); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(this_ID_0); @@ -14337,20 +14354,20 @@ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionExcept newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); } - // InternalBehaviorAnnexParser.g:4932:3: (kw= ColonColon this_ID_2= RULE_ID )* - loop87: + // InternalBehaviorAnnexParser.g:4934:3: (kw= ColonColon this_ID_2= RULE_ID )* + loop88: do { - int alt87=2; - int LA87_0 = input.LA(1); + int alt88=2; + int LA88_0 = input.LA(1); - if ( (LA87_0==ColonColon) ) { - alt87=1; + if ( (LA88_0==ColonColon) ) { + alt88=1; } - switch (alt87) { + switch (alt88) { case 1 : - // InternalBehaviorAnnexParser.g:4933:4: kw= ColonColon this_ID_2= RULE_ID + // InternalBehaviorAnnexParser.g:4935:4: kw= ColonColon this_ID_2= RULE_ID { kw=(Token)match(input,ColonColon,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -14359,7 +14376,7 @@ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionExcept newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); } - this_ID_2=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_77); if (state.failed) return current; + this_ID_2=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_78); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(this_ID_2); @@ -14375,7 +14392,7 @@ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionExcept break; default : - break loop87; + break loop88; } } while (true); @@ -14404,7 +14421,7 @@ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionExcept // $ANTLR start "entryRuleReference" - // InternalBehaviorAnnexParser.g:4950:1: entryRuleReference returns [EObject current=null] : iv_ruleReference= ruleReference EOF ; + // InternalBehaviorAnnexParser.g:4952:1: entryRuleReference returns [EObject current=null] : iv_ruleReference= ruleReference EOF ; public final EObject entryRuleReference() throws RecognitionException { EObject current = null; @@ -14412,8 +14429,8 @@ public final EObject entryRuleReference() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4950:50: (iv_ruleReference= ruleReference EOF ) - // InternalBehaviorAnnexParser.g:4951:2: iv_ruleReference= ruleReference EOF + // InternalBehaviorAnnexParser.g:4952:50: (iv_ruleReference= ruleReference EOF ) + // InternalBehaviorAnnexParser.g:4953:2: iv_ruleReference= ruleReference EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceRule()); @@ -14444,7 +14461,7 @@ public final EObject entryRuleReference() throws RecognitionException { // $ANTLR start "ruleReference" - // InternalBehaviorAnnexParser.g:4957:1: ruleReference returns [EObject current=null] : ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) ; + // InternalBehaviorAnnexParser.g:4959:1: ruleReference returns [EObject current=null] : ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) ; public final EObject ruleReference() throws RecognitionException { EObject current = null; @@ -14457,24 +14474,24 @@ public final EObject ruleReference() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4963:2: ( ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) ) - // InternalBehaviorAnnexParser.g:4964:2: ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) + // InternalBehaviorAnnexParser.g:4965:2: ( ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) ) + // InternalBehaviorAnnexParser.g:4966:2: ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) { - // InternalBehaviorAnnexParser.g:4964:2: ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) - // InternalBehaviorAnnexParser.g:4965:3: ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* + // InternalBehaviorAnnexParser.g:4966:2: ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) + // InternalBehaviorAnnexParser.g:4967:3: ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* { - // InternalBehaviorAnnexParser.g:4965:3: ( (lv_segments_0_0= ruleReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:4966:4: (lv_segments_0_0= ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:4967:3: ( (lv_segments_0_0= ruleReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:4968:4: (lv_segments_0_0= ruleReferenceSegment ) { - // InternalBehaviorAnnexParser.g:4966:4: (lv_segments_0_0= ruleReferenceSegment ) - // InternalBehaviorAnnexParser.g:4967:5: lv_segments_0_0= ruleReferenceSegment + // InternalBehaviorAnnexParser.g:4968:4: (lv_segments_0_0= ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:4969:5: lv_segments_0_0= ruleReferenceSegment { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceAccess().getSegmentsReferenceSegmentParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_76); + pushFollow(FollowSets000.FOLLOW_77); lv_segments_0_0=ruleReferenceSegment(); state._fsp--; @@ -14498,30 +14515,30 @@ public final EObject ruleReference() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4984:3: ( (lv_tails_1_0= ruleReferenceTail ) )* - loop88: + // InternalBehaviorAnnexParser.g:4986:3: ( (lv_tails_1_0= ruleReferenceTail ) )* + loop89: do { - int alt88=2; - int LA88_0 = input.LA(1); + int alt89=2; + int LA89_0 = input.LA(1); - if ( (LA88_0==ColonColon||LA88_0==FullStop) ) { - alt88=1; + if ( (LA89_0==ColonColon||LA89_0==FullStop) ) { + alt89=1; } - switch (alt88) { + switch (alt89) { case 1 : - // InternalBehaviorAnnexParser.g:4985:4: (lv_tails_1_0= ruleReferenceTail ) + // InternalBehaviorAnnexParser.g:4987:4: (lv_tails_1_0= ruleReferenceTail ) { - // InternalBehaviorAnnexParser.g:4985:4: (lv_tails_1_0= ruleReferenceTail ) - // InternalBehaviorAnnexParser.g:4986:5: lv_tails_1_0= ruleReferenceTail + // InternalBehaviorAnnexParser.g:4987:4: (lv_tails_1_0= ruleReferenceTail ) + // InternalBehaviorAnnexParser.g:4988:5: lv_tails_1_0= ruleReferenceTail { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceAccess().getTailsReferenceTailParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_76); + pushFollow(FollowSets000.FOLLOW_77); lv_tails_1_0=ruleReferenceTail(); state._fsp--; @@ -14547,7 +14564,7 @@ public final EObject ruleReference() throws RecognitionException { break; default : - break loop88; + break loop89; } } while (true); @@ -14576,7 +14593,7 @@ public final EObject ruleReference() throws RecognitionException { // $ANTLR start "entryRuleReferenceTail" - // InternalBehaviorAnnexParser.g:5007:1: entryRuleReferenceTail returns [EObject current=null] : iv_ruleReferenceTail= ruleReferenceTail EOF ; + // InternalBehaviorAnnexParser.g:5009:1: entryRuleReferenceTail returns [EObject current=null] : iv_ruleReferenceTail= ruleReferenceTail EOF ; public final EObject entryRuleReferenceTail() throws RecognitionException { EObject current = null; @@ -14584,8 +14601,8 @@ public final EObject entryRuleReferenceTail() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5007:54: (iv_ruleReferenceTail= ruleReferenceTail EOF ) - // InternalBehaviorAnnexParser.g:5008:2: iv_ruleReferenceTail= ruleReferenceTail EOF + // InternalBehaviorAnnexParser.g:5009:54: (iv_ruleReferenceTail= ruleReferenceTail EOF ) + // InternalBehaviorAnnexParser.g:5010:2: iv_ruleReferenceTail= ruleReferenceTail EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceTailRule()); @@ -14616,7 +14633,7 @@ public final EObject entryRuleReferenceTail() throws RecognitionException { // $ANTLR start "ruleReferenceTail" - // InternalBehaviorAnnexParser.g:5014:1: ruleReferenceTail returns [EObject current=null] : ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) ; + // InternalBehaviorAnnexParser.g:5016:1: ruleReferenceTail returns [EObject current=null] : ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) ; public final EObject ruleReferenceTail() throws RecognitionException { EObject current = null; @@ -14629,17 +14646,17 @@ public final EObject ruleReferenceTail() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5020:2: ( ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) ) - // InternalBehaviorAnnexParser.g:5021:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) + // InternalBehaviorAnnexParser.g:5022:2: ( ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) ) + // InternalBehaviorAnnexParser.g:5023:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) { - // InternalBehaviorAnnexParser.g:5021:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) - // InternalBehaviorAnnexParser.g:5022:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:5023:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) + // InternalBehaviorAnnexParser.g:5024:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) { - // InternalBehaviorAnnexParser.g:5022:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) - // InternalBehaviorAnnexParser.g:5023:4: (lv_separator_0_0= ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:5024:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) + // InternalBehaviorAnnexParser.g:5025:4: (lv_separator_0_0= ruleReferenceSeparator ) { - // InternalBehaviorAnnexParser.g:5023:4: (lv_separator_0_0= ruleReferenceSeparator ) - // InternalBehaviorAnnexParser.g:5024:5: lv_separator_0_0= ruleReferenceSeparator + // InternalBehaviorAnnexParser.g:5025:4: (lv_separator_0_0= ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:5026:5: lv_separator_0_0= ruleReferenceSeparator { if ( state.backtracking==0 ) { @@ -14670,11 +14687,11 @@ public final EObject ruleReferenceTail() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:5041:3: ( (lv_segment_1_0= ruleReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:5042:4: (lv_segment_1_0= ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:5043:3: ( (lv_segment_1_0= ruleReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:5044:4: (lv_segment_1_0= ruleReferenceSegment ) { - // InternalBehaviorAnnexParser.g:5042:4: (lv_segment_1_0= ruleReferenceSegment ) - // InternalBehaviorAnnexParser.g:5043:5: lv_segment_1_0= ruleReferenceSegment + // InternalBehaviorAnnexParser.g:5044:4: (lv_segment_1_0= ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:5045:5: lv_segment_1_0= ruleReferenceSegment { if ( state.backtracking==0 ) { @@ -14730,7 +14747,7 @@ public final EObject ruleReferenceTail() throws RecognitionException { // $ANTLR start "entryRuleReferenceSeparator" - // InternalBehaviorAnnexParser.g:5064:1: entryRuleReferenceSeparator returns [String current=null] : iv_ruleReferenceSeparator= ruleReferenceSeparator EOF ; + // InternalBehaviorAnnexParser.g:5066:1: entryRuleReferenceSeparator returns [String current=null] : iv_ruleReferenceSeparator= ruleReferenceSeparator EOF ; public final String entryRuleReferenceSeparator() throws RecognitionException { String current = null; @@ -14738,8 +14755,8 @@ public final String entryRuleReferenceSeparator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5064:58: (iv_ruleReferenceSeparator= ruleReferenceSeparator EOF ) - // InternalBehaviorAnnexParser.g:5065:2: iv_ruleReferenceSeparator= ruleReferenceSeparator EOF + // InternalBehaviorAnnexParser.g:5066:58: (iv_ruleReferenceSeparator= ruleReferenceSeparator EOF ) + // InternalBehaviorAnnexParser.g:5067:2: iv_ruleReferenceSeparator= ruleReferenceSeparator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceSeparatorRule()); @@ -14770,7 +14787,7 @@ public final String entryRuleReferenceSeparator() throws RecognitionException { // $ANTLR start "ruleReferenceSeparator" - // InternalBehaviorAnnexParser.g:5071:1: ruleReferenceSeparator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= ColonColon | kw= FullStop ) ; + // InternalBehaviorAnnexParser.g:5073:1: ruleReferenceSeparator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= ColonColon | kw= FullStop ) ; public final AntlrDatatypeRuleToken ruleReferenceSeparator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -14780,29 +14797,29 @@ public final AntlrDatatypeRuleToken ruleReferenceSeparator() throws RecognitionE enterRule(); try { - // InternalBehaviorAnnexParser.g:5077:2: ( (kw= ColonColon | kw= FullStop ) ) - // InternalBehaviorAnnexParser.g:5078:2: (kw= ColonColon | kw= FullStop ) + // InternalBehaviorAnnexParser.g:5079:2: ( (kw= ColonColon | kw= FullStop ) ) + // InternalBehaviorAnnexParser.g:5080:2: (kw= ColonColon | kw= FullStop ) { - // InternalBehaviorAnnexParser.g:5078:2: (kw= ColonColon | kw= FullStop ) - int alt89=2; - int LA89_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5080:2: (kw= ColonColon | kw= FullStop ) + int alt90=2; + int LA90_0 = input.LA(1); - if ( (LA89_0==ColonColon) ) { - alt89=1; + if ( (LA90_0==ColonColon) ) { + alt90=1; } - else if ( (LA89_0==FullStop) ) { - alt89=2; + else if ( (LA90_0==FullStop) ) { + alt90=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 89, 0, input); + new NoViableAltException("", 90, 0, input); throw nvae; } - switch (alt89) { + switch (alt90) { case 1 : - // InternalBehaviorAnnexParser.g:5079:3: kw= ColonColon + // InternalBehaviorAnnexParser.g:5081:3: kw= ColonColon { kw=(Token)match(input,ColonColon,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -14815,7 +14832,7 @@ else if ( (LA89_0==FullStop) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:5085:3: kw= FullStop + // InternalBehaviorAnnexParser.g:5087:3: kw= FullStop { kw=(Token)match(input,FullStop,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -14852,7 +14869,7 @@ else if ( (LA89_0==FullStop) ) { // $ANTLR start "entryRuleReferenceSegment" - // InternalBehaviorAnnexParser.g:5094:1: entryRuleReferenceSegment returns [EObject current=null] : iv_ruleReferenceSegment= ruleReferenceSegment EOF ; + // InternalBehaviorAnnexParser.g:5096:1: entryRuleReferenceSegment returns [EObject current=null] : iv_ruleReferenceSegment= ruleReferenceSegment EOF ; public final EObject entryRuleReferenceSegment() throws RecognitionException { EObject current = null; @@ -14860,8 +14877,8 @@ public final EObject entryRuleReferenceSegment() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5094:57: (iv_ruleReferenceSegment= ruleReferenceSegment EOF ) - // InternalBehaviorAnnexParser.g:5095:2: iv_ruleReferenceSegment= ruleReferenceSegment EOF + // InternalBehaviorAnnexParser.g:5096:57: (iv_ruleReferenceSegment= ruleReferenceSegment EOF ) + // InternalBehaviorAnnexParser.g:5097:2: iv_ruleReferenceSegment= ruleReferenceSegment EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceSegmentRule()); @@ -14892,7 +14909,7 @@ public final EObject entryRuleReferenceSegment() throws RecognitionException { // $ANTLR start "ruleReferenceSegment" - // InternalBehaviorAnnexParser.g:5101:1: ruleReferenceSegment returns [EObject current=null] : ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) ; + // InternalBehaviorAnnexParser.g:5103:1: ruleReferenceSegment returns [EObject current=null] : ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) ; public final EObject ruleReferenceSegment() throws RecognitionException { EObject current = null; @@ -14904,17 +14921,17 @@ public final EObject ruleReferenceSegment() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5107:2: ( ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) ) - // InternalBehaviorAnnexParser.g:5108:2: ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) + // InternalBehaviorAnnexParser.g:5109:2: ( ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) ) + // InternalBehaviorAnnexParser.g:5110:2: ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) { - // InternalBehaviorAnnexParser.g:5108:2: ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) - // InternalBehaviorAnnexParser.g:5109:3: ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* + // InternalBehaviorAnnexParser.g:5110:2: ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) + // InternalBehaviorAnnexParser.g:5111:3: ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* { - // InternalBehaviorAnnexParser.g:5109:3: ( (lv_name_0_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:5110:4: (lv_name_0_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:5111:3: ( (lv_name_0_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:5112:4: (lv_name_0_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:5110:4: (lv_name_0_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:5111:5: lv_name_0_0= RULE_ID + // InternalBehaviorAnnexParser.g:5112:4: (lv_name_0_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:5113:5: lv_name_0_0= RULE_ID { lv_name_0_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_13); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -14940,23 +14957,23 @@ public final EObject ruleReferenceSegment() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:5127:3: ( (lv_indexes_1_0= ruleArrayIndex ) )* - loop90: + // InternalBehaviorAnnexParser.g:5129:3: ( (lv_indexes_1_0= ruleArrayIndex ) )* + loop91: do { - int alt90=2; - int LA90_0 = input.LA(1); + int alt91=2; + int LA91_0 = input.LA(1); - if ( (LA90_0==LeftSquareBracket) ) { - alt90=1; + if ( (LA91_0==LeftSquareBracket) ) { + alt91=1; } - switch (alt90) { + switch (alt91) { case 1 : - // InternalBehaviorAnnexParser.g:5128:4: (lv_indexes_1_0= ruleArrayIndex ) + // InternalBehaviorAnnexParser.g:5130:4: (lv_indexes_1_0= ruleArrayIndex ) { - // InternalBehaviorAnnexParser.g:5128:4: (lv_indexes_1_0= ruleArrayIndex ) - // InternalBehaviorAnnexParser.g:5129:5: lv_indexes_1_0= ruleArrayIndex + // InternalBehaviorAnnexParser.g:5130:4: (lv_indexes_1_0= ruleArrayIndex ) + // InternalBehaviorAnnexParser.g:5131:5: lv_indexes_1_0= ruleArrayIndex { if ( state.backtracking==0 ) { @@ -14989,7 +15006,7 @@ public final EObject ruleReferenceSegment() throws RecognitionException { break; default : - break loop90; + break loop91; } } while (true); @@ -15018,7 +15035,7 @@ public final EObject ruleReferenceSegment() throws RecognitionException { // $ANTLR start "entryRuleArrayIndex" - // InternalBehaviorAnnexParser.g:5150:1: entryRuleArrayIndex returns [EObject current=null] : iv_ruleArrayIndex= ruleArrayIndex EOF ; + // InternalBehaviorAnnexParser.g:5152:1: entryRuleArrayIndex returns [EObject current=null] : iv_ruleArrayIndex= ruleArrayIndex EOF ; public final EObject entryRuleArrayIndex() throws RecognitionException { EObject current = null; @@ -15026,8 +15043,8 @@ public final EObject entryRuleArrayIndex() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5150:51: (iv_ruleArrayIndex= ruleArrayIndex EOF ) - // InternalBehaviorAnnexParser.g:5151:2: iv_ruleArrayIndex= ruleArrayIndex EOF + // InternalBehaviorAnnexParser.g:5152:51: (iv_ruleArrayIndex= ruleArrayIndex EOF ) + // InternalBehaviorAnnexParser.g:5153:2: iv_ruleArrayIndex= ruleArrayIndex EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getArrayIndexRule()); @@ -15058,7 +15075,7 @@ public final EObject entryRuleArrayIndex() throws RecognitionException { // $ANTLR start "ruleArrayIndex" - // InternalBehaviorAnnexParser.g:5157:1: ruleArrayIndex returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:5159:1: ruleArrayIndex returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) ; public final EObject ruleArrayIndex() throws RecognitionException { EObject current = null; @@ -15071,11 +15088,11 @@ public final EObject ruleArrayIndex() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5163:2: ( (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:5164:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) + // InternalBehaviorAnnexParser.g:5165:2: ( (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:5166:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:5164:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) - // InternalBehaviorAnnexParser.g:5165:3: otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket + // InternalBehaviorAnnexParser.g:5166:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) + // InternalBehaviorAnnexParser.g:5167:3: otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket { otherlv_0=(Token)match(input,LeftSquareBracket,FollowSets000.FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -15083,11 +15100,11 @@ public final EObject ruleArrayIndex() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getArrayIndexAccess().getLeftSquareBracketKeyword_0()); } - // InternalBehaviorAnnexParser.g:5169:3: ( (lv_value_1_0= ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:5170:4: (lv_value_1_0= ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:5171:3: ( (lv_value_1_0= ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:5172:4: (lv_value_1_0= ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:5170:4: (lv_value_1_0= ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:5171:5: lv_value_1_0= ruleIntegerValue + // InternalBehaviorAnnexParser.g:5172:4: (lv_value_1_0= ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:5173:5: lv_value_1_0= ruleIntegerValue { if ( state.backtracking==0 ) { @@ -15149,7 +15166,7 @@ public final EObject ruleArrayIndex() throws RecognitionException { // $ANTLR start "entryRuleContainedPropertyAssociation" - // InternalBehaviorAnnexParser.g:5196:1: entryRuleContainedPropertyAssociation returns [EObject current=null] : iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF ; + // InternalBehaviorAnnexParser.g:5198:1: entryRuleContainedPropertyAssociation returns [EObject current=null] : iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF ; public final EObject entryRuleContainedPropertyAssociation() throws RecognitionException { EObject current = null; @@ -15157,8 +15174,8 @@ public final EObject entryRuleContainedPropertyAssociation() throws RecognitionE try { - // InternalBehaviorAnnexParser.g:5196:69: (iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF ) - // InternalBehaviorAnnexParser.g:5197:2: iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF + // InternalBehaviorAnnexParser.g:5198:69: (iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF ) + // InternalBehaviorAnnexParser.g:5199:2: iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainedPropertyAssociationRule()); @@ -15189,7 +15206,7 @@ public final EObject entryRuleContainedPropertyAssociation() throws RecognitionE // $ANTLR start "ruleContainedPropertyAssociation" - // InternalBehaviorAnnexParser.g:5203:1: ruleContainedPropertyAssociation returns [EObject current=null] : ( ( ( ruleQPREF ) ) (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) ( (lv_constant_3_0= Constant ) )? ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? otherlv_17= Semicolon ) ; + // InternalBehaviorAnnexParser.g:5205:1: ruleContainedPropertyAssociation returns [EObject current=null] : ( ( ( ruleQPREF ) ) (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) ( (lv_constant_3_0= Constant ) )? ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? otherlv_17= Semicolon ) ; public final EObject ruleContainedPropertyAssociation() throws RecognitionException { EObject current = null; @@ -15218,17 +15235,17 @@ public final EObject ruleContainedPropertyAssociation() throws RecognitionExcept enterRule(); try { - // InternalBehaviorAnnexParser.g:5209:2: ( ( ( ( ruleQPREF ) ) (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) ( (lv_constant_3_0= Constant ) )? ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? otherlv_17= Semicolon ) ) - // InternalBehaviorAnnexParser.g:5210:2: ( ( ( ruleQPREF ) ) (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) ( (lv_constant_3_0= Constant ) )? ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? otherlv_17= Semicolon ) + // InternalBehaviorAnnexParser.g:5211:2: ( ( ( ( ruleQPREF ) ) (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) ( (lv_constant_3_0= Constant ) )? ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? otherlv_17= Semicolon ) ) + // InternalBehaviorAnnexParser.g:5212:2: ( ( ( ruleQPREF ) ) (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) ( (lv_constant_3_0= Constant ) )? ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? otherlv_17= Semicolon ) { - // InternalBehaviorAnnexParser.g:5210:2: ( ( ( ruleQPREF ) ) (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) ( (lv_constant_3_0= Constant ) )? ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? otherlv_17= Semicolon ) - // InternalBehaviorAnnexParser.g:5211:3: ( ( ruleQPREF ) ) (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) ( (lv_constant_3_0= Constant ) )? ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? otherlv_17= Semicolon + // InternalBehaviorAnnexParser.g:5212:2: ( ( ( ruleQPREF ) ) (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) ( (lv_constant_3_0= Constant ) )? ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? otherlv_17= Semicolon ) + // InternalBehaviorAnnexParser.g:5213:3: ( ( ruleQPREF ) ) (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) ( (lv_constant_3_0= Constant ) )? ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? otherlv_17= Semicolon { - // InternalBehaviorAnnexParser.g:5211:3: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:5212:4: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5213:3: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:5214:4: ( ruleQPREF ) { - // InternalBehaviorAnnexParser.g:5212:4: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:5213:5: ruleQPREF + // InternalBehaviorAnnexParser.g:5214:4: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5215:5: ruleQPREF { if ( state.backtracking==0 ) { @@ -15242,7 +15259,7 @@ public final EObject ruleContainedPropertyAssociation() throws RecognitionExcept newCompositeNode(grammarAccess.getContainedPropertyAssociationAccess().getPropertyPropertyCrossReference_0_0()); } - pushFollow(FollowSets000.FOLLOW_78); + pushFollow(FollowSets000.FOLLOW_79); ruleQPREF(); state._fsp--; @@ -15258,28 +15275,28 @@ public final EObject ruleContainedPropertyAssociation() throws RecognitionExcept } - // InternalBehaviorAnnexParser.g:5227:3: (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) - int alt91=2; - int LA91_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5229:3: (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) + int alt92=2; + int LA92_0 = input.LA(1); - if ( (LA91_0==EqualsSignGreaterThanSign) ) { - alt91=1; + if ( (LA92_0==EqualsSignGreaterThanSign) ) { + alt92=1; } - else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { - alt91=2; + else if ( (LA92_0==PlusSignEqualsSignGreaterThanSign) ) { + alt92=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 91, 0, input); + new NoViableAltException("", 92, 0, input); throw nvae; } - switch (alt91) { + switch (alt92) { case 1 : - // InternalBehaviorAnnexParser.g:5228:4: otherlv_1= EqualsSignGreaterThanSign + // InternalBehaviorAnnexParser.g:5230:4: otherlv_1= EqualsSignGreaterThanSign { - otherlv_1=(Token)match(input,EqualsSignGreaterThanSign,FollowSets000.FOLLOW_79); if (state.failed) return current; + otherlv_1=(Token)match(input,EqualsSignGreaterThanSign,FollowSets000.FOLLOW_80); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getContainedPropertyAssociationAccess().getEqualsSignGreaterThanSignKeyword_1_0()); @@ -15289,15 +15306,15 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:5233:4: ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:5235:4: ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) { - // InternalBehaviorAnnexParser.g:5233:4: ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:5234:5: (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:5235:4: ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:5236:5: (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) { - // InternalBehaviorAnnexParser.g:5234:5: (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) - // InternalBehaviorAnnexParser.g:5235:6: lv_append_2_0= PlusSignEqualsSignGreaterThanSign + // InternalBehaviorAnnexParser.g:5236:5: (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:5237:6: lv_append_2_0= PlusSignEqualsSignGreaterThanSign { - lv_append_2_0=(Token)match(input,PlusSignEqualsSignGreaterThanSign,FollowSets000.FOLLOW_79); if (state.failed) return current; + lv_append_2_0=(Token)match(input,PlusSignEqualsSignGreaterThanSign,FollowSets000.FOLLOW_80); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_append_2_0, grammarAccess.getContainedPropertyAssociationAccess().getAppendPlusSignEqualsSignGreaterThanSignKeyword_1_1_0()); @@ -15323,21 +15340,21 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { } - // InternalBehaviorAnnexParser.g:5248:3: ( (lv_constant_3_0= Constant ) )? - int alt92=2; - int LA92_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5250:3: ( (lv_constant_3_0= Constant ) )? + int alt93=2; + int LA93_0 = input.LA(1); - if ( (LA92_0==Constant) ) { - alt92=1; + if ( (LA93_0==Constant) ) { + alt93=1; } - switch (alt92) { + switch (alt93) { case 1 : - // InternalBehaviorAnnexParser.g:5249:4: (lv_constant_3_0= Constant ) + // InternalBehaviorAnnexParser.g:5251:4: (lv_constant_3_0= Constant ) { - // InternalBehaviorAnnexParser.g:5249:4: (lv_constant_3_0= Constant ) - // InternalBehaviorAnnexParser.g:5250:5: lv_constant_3_0= Constant + // InternalBehaviorAnnexParser.g:5251:4: (lv_constant_3_0= Constant ) + // InternalBehaviorAnnexParser.g:5252:5: lv_constant_3_0= Constant { - lv_constant_3_0=(Token)match(input,Constant,FollowSets000.FOLLOW_79); if (state.failed) return current; + lv_constant_3_0=(Token)match(input,Constant,FollowSets000.FOLLOW_80); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_constant_3_0, grammarAccess.getContainedPropertyAssociationAccess().getConstantConstantKeyword_2_0()); @@ -15360,21 +15377,21 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { } - // InternalBehaviorAnnexParser.g:5262:3: ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) - // InternalBehaviorAnnexParser.g:5263:4: ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* + // InternalBehaviorAnnexParser.g:5264:3: ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) + // InternalBehaviorAnnexParser.g:5265:4: ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* { - // InternalBehaviorAnnexParser.g:5263:4: ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) - // InternalBehaviorAnnexParser.g:5264:5: (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:5265:4: ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) + // InternalBehaviorAnnexParser.g:5266:5: (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) { - // InternalBehaviorAnnexParser.g:5264:5: (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) - // InternalBehaviorAnnexParser.g:5265:6: lv_ownedValue_4_0= ruleOptionalModalPropertyValue + // InternalBehaviorAnnexParser.g:5266:5: (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:5267:6: lv_ownedValue_4_0= ruleOptionalModalPropertyValue { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueOptionalModalPropertyValueParserRuleCall_3_0_0()); } - pushFollow(FollowSets000.FOLLOW_80); + pushFollow(FollowSets000.FOLLOW_81); lv_ownedValue_4_0=ruleOptionalModalPropertyValue(); state._fsp--; @@ -15398,39 +15415,39 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { } - // InternalBehaviorAnnexParser.g:5282:4: (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* - loop93: + // InternalBehaviorAnnexParser.g:5284:4: (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* + loop94: do { - int alt93=2; - int LA93_0 = input.LA(1); + int alt94=2; + int LA94_0 = input.LA(1); - if ( (LA93_0==Comma) ) { - alt93=1; + if ( (LA94_0==Comma) ) { + alt94=1; } - switch (alt93) { + switch (alt94) { case 1 : - // InternalBehaviorAnnexParser.g:5283:5: otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) + // InternalBehaviorAnnexParser.g:5285:5: otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) { - otherlv_5=(Token)match(input,Comma,FollowSets000.FOLLOW_79); if (state.failed) return current; + otherlv_5=(Token)match(input,Comma,FollowSets000.FOLLOW_80); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getContainedPropertyAssociationAccess().getCommaKeyword_3_1_0()); } - // InternalBehaviorAnnexParser.g:5287:5: ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) - // InternalBehaviorAnnexParser.g:5288:6: (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:5289:5: ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) + // InternalBehaviorAnnexParser.g:5290:6: (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) { - // InternalBehaviorAnnexParser.g:5288:6: (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) - // InternalBehaviorAnnexParser.g:5289:7: lv_ownedValue_6_0= ruleOptionalModalPropertyValue + // InternalBehaviorAnnexParser.g:5290:6: (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:5291:7: lv_ownedValue_6_0= ruleOptionalModalPropertyValue { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueOptionalModalPropertyValueParserRuleCall_3_1_1_0()); } - pushFollow(FollowSets000.FOLLOW_80); + pushFollow(FollowSets000.FOLLOW_81); lv_ownedValue_6_0=ruleOptionalModalPropertyValue(); state._fsp--; @@ -15459,25 +15476,25 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { break; default : - break loop93; + break loop94; } } while (true); } - // InternalBehaviorAnnexParser.g:5308:3: (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? - int alt95=2; - int LA95_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5310:3: (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? + int alt96=2; + int LA96_0 = input.LA(1); - if ( (LA95_0==Applies) ) { - alt95=1; + if ( (LA96_0==Applies) ) { + alt96=1; } - switch (alt95) { + switch (alt96) { case 1 : - // InternalBehaviorAnnexParser.g:5309:4: otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* + // InternalBehaviorAnnexParser.g:5311:4: otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* { - otherlv_7=(Token)match(input,Applies,FollowSets000.FOLLOW_81); if (state.failed) return current; + otherlv_7=(Token)match(input,Applies,FollowSets000.FOLLOW_82); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_7, grammarAccess.getContainedPropertyAssociationAccess().getAppliesKeyword_4_0()); @@ -15489,18 +15506,18 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { newLeafNode(otherlv_8, grammarAccess.getContainedPropertyAssociationAccess().getToKeyword_4_1()); } - // InternalBehaviorAnnexParser.g:5317:4: ( (lv_appliesTo_9_0= ruleContainmentPath ) ) - // InternalBehaviorAnnexParser.g:5318:5: (lv_appliesTo_9_0= ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:5319:4: ( (lv_appliesTo_9_0= ruleContainmentPath ) ) + // InternalBehaviorAnnexParser.g:5320:5: (lv_appliesTo_9_0= ruleContainmentPath ) { - // InternalBehaviorAnnexParser.g:5318:5: (lv_appliesTo_9_0= ruleContainmentPath ) - // InternalBehaviorAnnexParser.g:5319:6: lv_appliesTo_9_0= ruleContainmentPath + // InternalBehaviorAnnexParser.g:5320:5: (lv_appliesTo_9_0= ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:5321:6: lv_appliesTo_9_0= ruleContainmentPath { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToContainmentPathParserRuleCall_4_2_0()); } - pushFollow(FollowSets000.FOLLOW_82); + pushFollow(FollowSets000.FOLLOW_83); lv_appliesTo_9_0=ruleContainmentPath(); state._fsp--; @@ -15524,20 +15541,20 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { } - // InternalBehaviorAnnexParser.g:5336:4: (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* - loop94: + // InternalBehaviorAnnexParser.g:5338:4: (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* + loop95: do { - int alt94=2; - int LA94_0 = input.LA(1); + int alt95=2; + int LA95_0 = input.LA(1); - if ( (LA94_0==Comma) ) { - alt94=1; + if ( (LA95_0==Comma) ) { + alt95=1; } - switch (alt94) { + switch (alt95) { case 1 : - // InternalBehaviorAnnexParser.g:5337:5: otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) + // InternalBehaviorAnnexParser.g:5339:5: otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) { otherlv_10=(Token)match(input,Comma,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -15545,18 +15562,18 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { newLeafNode(otherlv_10, grammarAccess.getContainedPropertyAssociationAccess().getCommaKeyword_4_3_0()); } - // InternalBehaviorAnnexParser.g:5341:5: ( (lv_appliesTo_11_0= ruleContainmentPath ) ) - // InternalBehaviorAnnexParser.g:5342:6: (lv_appliesTo_11_0= ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:5343:5: ( (lv_appliesTo_11_0= ruleContainmentPath ) ) + // InternalBehaviorAnnexParser.g:5344:6: (lv_appliesTo_11_0= ruleContainmentPath ) { - // InternalBehaviorAnnexParser.g:5342:6: (lv_appliesTo_11_0= ruleContainmentPath ) - // InternalBehaviorAnnexParser.g:5343:7: lv_appliesTo_11_0= ruleContainmentPath + // InternalBehaviorAnnexParser.g:5344:6: (lv_appliesTo_11_0= ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:5345:7: lv_appliesTo_11_0= ruleContainmentPath { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToContainmentPathParserRuleCall_4_3_1_0()); } - pushFollow(FollowSets000.FOLLOW_82); + pushFollow(FollowSets000.FOLLOW_83); lv_appliesTo_11_0=ruleContainmentPath(); state._fsp--; @@ -15585,7 +15602,7 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { break; default : - break loop94; + break loop95; } } while (true); @@ -15595,16 +15612,16 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { } - // InternalBehaviorAnnexParser.g:5362:3: (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? - int alt96=2; - int LA96_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5364:3: (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? + int alt97=2; + int LA97_0 = input.LA(1); - if ( (LA96_0==In) ) { - alt96=1; + if ( (LA97_0==In) ) { + alt97=1; } - switch (alt96) { + switch (alt97) { case 1 : - // InternalBehaviorAnnexParser.g:5363:4: otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis + // InternalBehaviorAnnexParser.g:5365:4: otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis { otherlv_12=(Token)match(input,In,FollowSets000.FOLLOW_54); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -15624,11 +15641,11 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { newLeafNode(otherlv_14, grammarAccess.getContainedPropertyAssociationAccess().getLeftParenthesisKeyword_5_2()); } - // InternalBehaviorAnnexParser.g:5375:4: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:5376:5: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:5377:4: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:5378:5: ( ruleQCREF ) { - // InternalBehaviorAnnexParser.g:5376:5: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:5377:6: ruleQCREF + // InternalBehaviorAnnexParser.g:5378:5: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:5379:6: ruleQCREF { if ( state.backtracking==0 ) { @@ -15701,7 +15718,7 @@ else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { // $ANTLR start "entryRuleContainmentPath" - // InternalBehaviorAnnexParser.g:5404:1: entryRuleContainmentPath returns [EObject current=null] : iv_ruleContainmentPath= ruleContainmentPath EOF ; + // InternalBehaviorAnnexParser.g:5406:1: entryRuleContainmentPath returns [EObject current=null] : iv_ruleContainmentPath= ruleContainmentPath EOF ; public final EObject entryRuleContainmentPath() throws RecognitionException { EObject current = null; @@ -15709,8 +15726,8 @@ public final EObject entryRuleContainmentPath() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5404:56: (iv_ruleContainmentPath= ruleContainmentPath EOF ) - // InternalBehaviorAnnexParser.g:5405:2: iv_ruleContainmentPath= ruleContainmentPath EOF + // InternalBehaviorAnnexParser.g:5406:56: (iv_ruleContainmentPath= ruleContainmentPath EOF ) + // InternalBehaviorAnnexParser.g:5407:2: iv_ruleContainmentPath= ruleContainmentPath EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainmentPathRule()); @@ -15741,7 +15758,7 @@ public final EObject entryRuleContainmentPath() throws RecognitionException { // $ANTLR start "ruleContainmentPath" - // InternalBehaviorAnnexParser.g:5411:1: ruleContainmentPath returns [EObject current=null] : ( (lv_path_0_0= ruleContainmentPathElement ) ) ; + // InternalBehaviorAnnexParser.g:5413:1: ruleContainmentPath returns [EObject current=null] : ( (lv_path_0_0= ruleContainmentPathElement ) ) ; public final EObject ruleContainmentPath() throws RecognitionException { EObject current = null; @@ -15752,14 +15769,14 @@ public final EObject ruleContainmentPath() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5417:2: ( ( (lv_path_0_0= ruleContainmentPathElement ) ) ) - // InternalBehaviorAnnexParser.g:5418:2: ( (lv_path_0_0= ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:5419:2: ( ( (lv_path_0_0= ruleContainmentPathElement ) ) ) + // InternalBehaviorAnnexParser.g:5420:2: ( (lv_path_0_0= ruleContainmentPathElement ) ) { - // InternalBehaviorAnnexParser.g:5418:2: ( (lv_path_0_0= ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:5419:3: (lv_path_0_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:5420:2: ( (lv_path_0_0= ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:5421:3: (lv_path_0_0= ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:5419:3: (lv_path_0_0= ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:5420:4: lv_path_0_0= ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:5421:3: (lv_path_0_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:5422:4: lv_path_0_0= ruleContainmentPathElement { if ( state.backtracking==0 ) { @@ -15812,7 +15829,7 @@ public final EObject ruleContainmentPath() throws RecognitionException { // $ANTLR start "entryRuleOptionalModalPropertyValue" - // InternalBehaviorAnnexParser.g:5440:1: entryRuleOptionalModalPropertyValue returns [EObject current=null] : iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF ; + // InternalBehaviorAnnexParser.g:5442:1: entryRuleOptionalModalPropertyValue returns [EObject current=null] : iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF ; public final EObject entryRuleOptionalModalPropertyValue() throws RecognitionException { EObject current = null; @@ -15820,8 +15837,8 @@ public final EObject entryRuleOptionalModalPropertyValue() throws RecognitionExc try { - // InternalBehaviorAnnexParser.g:5440:67: (iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF ) - // InternalBehaviorAnnexParser.g:5441:2: iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF + // InternalBehaviorAnnexParser.g:5442:67: (iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF ) + // InternalBehaviorAnnexParser.g:5443:2: iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getOptionalModalPropertyValueRule()); @@ -15852,7 +15869,7 @@ public final EObject entryRuleOptionalModalPropertyValue() throws RecognitionExc // $ANTLR start "ruleOptionalModalPropertyValue" - // InternalBehaviorAnnexParser.g:5447:1: ruleOptionalModalPropertyValue returns [EObject current=null] : ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? ) ; + // InternalBehaviorAnnexParser.g:5449:1: ruleOptionalModalPropertyValue returns [EObject current=null] : ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? ) ; public final EObject ruleOptionalModalPropertyValue() throws RecognitionException { EObject current = null; @@ -15870,17 +15887,17 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio enterRule(); try { - // InternalBehaviorAnnexParser.g:5453:2: ( ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? ) ) - // InternalBehaviorAnnexParser.g:5454:2: ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? ) + // InternalBehaviorAnnexParser.g:5455:2: ( ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? ) ) + // InternalBehaviorAnnexParser.g:5456:2: ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? ) { - // InternalBehaviorAnnexParser.g:5454:2: ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? ) - // InternalBehaviorAnnexParser.g:5455:3: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? + // InternalBehaviorAnnexParser.g:5456:2: ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? ) + // InternalBehaviorAnnexParser.g:5457:3: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? { - // InternalBehaviorAnnexParser.g:5455:3: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:5456:4: (lv_ownedValue_0_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:5457:3: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:5458:4: (lv_ownedValue_0_0= rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:5456:4: (lv_ownedValue_0_0= rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:5457:5: lv_ownedValue_0_0= rulePropertyExpression + // InternalBehaviorAnnexParser.g:5458:4: (lv_ownedValue_0_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:5459:5: lv_ownedValue_0_0= rulePropertyExpression { if ( state.backtracking==0 ) { @@ -15911,22 +15928,22 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio } - // InternalBehaviorAnnexParser.g:5474:3: (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? - int alt98=2; - int LA98_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5476:3: (otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis )? + int alt99=2; + int LA99_0 = input.LA(1); - if ( (LA98_0==In) ) { - int LA98_1 = input.LA(2); + if ( (LA99_0==In) ) { + int LA99_1 = input.LA(2); - if ( (LA98_1==Modes) ) { - alt98=1; + if ( (LA99_1==Modes) ) { + alt99=1; } } - switch (alt98) { + switch (alt99) { case 1 : - // InternalBehaviorAnnexParser.g:5475:4: otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis + // InternalBehaviorAnnexParser.g:5477:4: otherlv_1= In otherlv_2= Modes otherlv_3= LeftParenthesis ( (otherlv_4= RULE_ID ) ) (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* otherlv_7= RightParenthesis { - otherlv_1=(Token)match(input,In,FollowSets000.FOLLOW_83); if (state.failed) return current; + otherlv_1=(Token)match(input,In,FollowSets000.FOLLOW_84); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getOptionalModalPropertyValueAccess().getInKeyword_1_0()); @@ -15944,11 +15961,11 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio newLeafNode(otherlv_3, grammarAccess.getOptionalModalPropertyValueAccess().getLeftParenthesisKeyword_1_2()); } - // InternalBehaviorAnnexParser.g:5487:4: ( (otherlv_4= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:5488:5: (otherlv_4= RULE_ID ) + // InternalBehaviorAnnexParser.g:5489:4: ( (otherlv_4= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:5490:5: (otherlv_4= RULE_ID ) { - // InternalBehaviorAnnexParser.g:5488:5: (otherlv_4= RULE_ID ) - // InternalBehaviorAnnexParser.g:5489:6: otherlv_4= RULE_ID + // InternalBehaviorAnnexParser.g:5490:5: (otherlv_4= RULE_ID ) + // InternalBehaviorAnnexParser.g:5491:6: otherlv_4= RULE_ID { if ( state.backtracking==0 ) { @@ -15969,20 +15986,20 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio } - // InternalBehaviorAnnexParser.g:5500:4: (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* - loop97: + // InternalBehaviorAnnexParser.g:5502:4: (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* + loop98: do { - int alt97=2; - int LA97_0 = input.LA(1); + int alt98=2; + int LA98_0 = input.LA(1); - if ( (LA97_0==Comma) ) { - alt97=1; + if ( (LA98_0==Comma) ) { + alt98=1; } - switch (alt97) { + switch (alt98) { case 1 : - // InternalBehaviorAnnexParser.g:5501:5: otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:5503:5: otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) { otherlv_5=(Token)match(input,Comma,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -15990,11 +16007,11 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio newLeafNode(otherlv_5, grammarAccess.getOptionalModalPropertyValueAccess().getCommaKeyword_1_4_0()); } - // InternalBehaviorAnnexParser.g:5505:5: ( (otherlv_6= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:5506:6: (otherlv_6= RULE_ID ) + // InternalBehaviorAnnexParser.g:5507:5: ( (otherlv_6= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:5508:6: (otherlv_6= RULE_ID ) { - // InternalBehaviorAnnexParser.g:5506:6: (otherlv_6= RULE_ID ) - // InternalBehaviorAnnexParser.g:5507:7: otherlv_6= RULE_ID + // InternalBehaviorAnnexParser.g:5508:6: (otherlv_6= RULE_ID ) + // InternalBehaviorAnnexParser.g:5509:7: otherlv_6= RULE_ID { if ( state.backtracking==0 ) { @@ -16020,7 +16037,7 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio break; default : - break loop97; + break loop98; } } while (true); @@ -16061,7 +16078,7 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio // $ANTLR start "entryRulePropertyValue" - // InternalBehaviorAnnexParser.g:5528:1: entryRulePropertyValue returns [EObject current=null] : iv_rulePropertyValue= rulePropertyValue EOF ; + // InternalBehaviorAnnexParser.g:5530:1: entryRulePropertyValue returns [EObject current=null] : iv_rulePropertyValue= rulePropertyValue EOF ; public final EObject entryRulePropertyValue() throws RecognitionException { EObject current = null; @@ -16069,8 +16086,8 @@ public final EObject entryRulePropertyValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5528:54: (iv_rulePropertyValue= rulePropertyValue EOF ) - // InternalBehaviorAnnexParser.g:5529:2: iv_rulePropertyValue= rulePropertyValue EOF + // InternalBehaviorAnnexParser.g:5530:54: (iv_rulePropertyValue= rulePropertyValue EOF ) + // InternalBehaviorAnnexParser.g:5531:2: iv_rulePropertyValue= rulePropertyValue EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyValueRule()); @@ -16101,7 +16118,7 @@ public final EObject entryRulePropertyValue() throws RecognitionException { // $ANTLR start "rulePropertyValue" - // InternalBehaviorAnnexParser.g:5535:1: rulePropertyValue returns [EObject current=null] : ( (lv_ownedValue_0_0= rulePropertyExpression ) ) ; + // InternalBehaviorAnnexParser.g:5537:1: rulePropertyValue returns [EObject current=null] : ( (lv_ownedValue_0_0= rulePropertyExpression ) ) ; public final EObject rulePropertyValue() throws RecognitionException { EObject current = null; @@ -16112,14 +16129,14 @@ public final EObject rulePropertyValue() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5541:2: ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) ) - // InternalBehaviorAnnexParser.g:5542:2: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:5543:2: ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) ) + // InternalBehaviorAnnexParser.g:5544:2: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) { - // InternalBehaviorAnnexParser.g:5542:2: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:5543:3: (lv_ownedValue_0_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:5544:2: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:5545:3: (lv_ownedValue_0_0= rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:5543:3: (lv_ownedValue_0_0= rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:5544:4: lv_ownedValue_0_0= rulePropertyExpression + // InternalBehaviorAnnexParser.g:5545:3: (lv_ownedValue_0_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:5546:4: lv_ownedValue_0_0= rulePropertyExpression { if ( state.backtracking==0 ) { @@ -16172,7 +16189,7 @@ public final EObject rulePropertyValue() throws RecognitionException { // $ANTLR start "entryRulePropertyExpression" - // InternalBehaviorAnnexParser.g:5564:1: entryRulePropertyExpression returns [EObject current=null] : iv_rulePropertyExpression= rulePropertyExpression EOF ; + // InternalBehaviorAnnexParser.g:5566:1: entryRulePropertyExpression returns [EObject current=null] : iv_rulePropertyExpression= rulePropertyExpression EOF ; public final EObject entryRulePropertyExpression() throws RecognitionException { EObject current = null; @@ -16180,8 +16197,8 @@ public final EObject entryRulePropertyExpression() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5564:59: (iv_rulePropertyExpression= rulePropertyExpression EOF ) - // InternalBehaviorAnnexParser.g:5565:2: iv_rulePropertyExpression= rulePropertyExpression EOF + // InternalBehaviorAnnexParser.g:5566:59: (iv_rulePropertyExpression= rulePropertyExpression EOF ) + // InternalBehaviorAnnexParser.g:5567:2: iv_rulePropertyExpression= rulePropertyExpression EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyExpressionRule()); @@ -16212,7 +16229,7 @@ public final EObject entryRulePropertyExpression() throws RecognitionException { // $ANTLR start "rulePropertyExpression" - // InternalBehaviorAnnexParser.g:5571:1: rulePropertyExpression returns [EObject current=null] : (this_RecordTerm_0= ruleRecordTerm | this_ReferenceTerm_1= ruleReferenceTerm | this_ComponentClassifierTerm_2= ruleComponentClassifierTerm | this_ComputedTerm_3= ruleComputedTerm | this_StringTerm_4= ruleStringTerm | this_NumericRangeTerm_5= ruleNumericRangeTerm | this_RealTerm_6= ruleRealTerm | this_IntegerTerm_7= ruleIntegerTerm | this_ListTerm_8= ruleListTerm | this_BooleanLiteral_9= ruleBooleanLiteral | this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm ) ; + // InternalBehaviorAnnexParser.g:5573:1: rulePropertyExpression returns [EObject current=null] : (this_RecordTerm_0= ruleRecordTerm | this_ReferenceTerm_1= ruleReferenceTerm | this_ComponentClassifierTerm_2= ruleComponentClassifierTerm | this_ComputedTerm_3= ruleComputedTerm | this_StringTerm_4= ruleStringTerm | this_NumericRangeTerm_5= ruleNumericRangeTerm | this_RealTerm_6= ruleRealTerm | this_IntegerTerm_7= ruleIntegerTerm | this_ListTerm_8= ruleListTerm | this_BooleanLiteral_9= ruleBooleanLiteral | this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm ) ; public final EObject rulePropertyExpression() throws RecognitionException { EObject current = null; @@ -16243,15 +16260,15 @@ public final EObject rulePropertyExpression() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5577:2: ( (this_RecordTerm_0= ruleRecordTerm | this_ReferenceTerm_1= ruleReferenceTerm | this_ComponentClassifierTerm_2= ruleComponentClassifierTerm | this_ComputedTerm_3= ruleComputedTerm | this_StringTerm_4= ruleStringTerm | this_NumericRangeTerm_5= ruleNumericRangeTerm | this_RealTerm_6= ruleRealTerm | this_IntegerTerm_7= ruleIntegerTerm | this_ListTerm_8= ruleListTerm | this_BooleanLiteral_9= ruleBooleanLiteral | this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm ) ) - // InternalBehaviorAnnexParser.g:5578:2: (this_RecordTerm_0= ruleRecordTerm | this_ReferenceTerm_1= ruleReferenceTerm | this_ComponentClassifierTerm_2= ruleComponentClassifierTerm | this_ComputedTerm_3= ruleComputedTerm | this_StringTerm_4= ruleStringTerm | this_NumericRangeTerm_5= ruleNumericRangeTerm | this_RealTerm_6= ruleRealTerm | this_IntegerTerm_7= ruleIntegerTerm | this_ListTerm_8= ruleListTerm | this_BooleanLiteral_9= ruleBooleanLiteral | this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm ) + // InternalBehaviorAnnexParser.g:5579:2: ( (this_RecordTerm_0= ruleRecordTerm | this_ReferenceTerm_1= ruleReferenceTerm | this_ComponentClassifierTerm_2= ruleComponentClassifierTerm | this_ComputedTerm_3= ruleComputedTerm | this_StringTerm_4= ruleStringTerm | this_NumericRangeTerm_5= ruleNumericRangeTerm | this_RealTerm_6= ruleRealTerm | this_IntegerTerm_7= ruleIntegerTerm | this_ListTerm_8= ruleListTerm | this_BooleanLiteral_9= ruleBooleanLiteral | this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm ) ) + // InternalBehaviorAnnexParser.g:5580:2: (this_RecordTerm_0= ruleRecordTerm | this_ReferenceTerm_1= ruleReferenceTerm | this_ComponentClassifierTerm_2= ruleComponentClassifierTerm | this_ComputedTerm_3= ruleComputedTerm | this_StringTerm_4= ruleStringTerm | this_NumericRangeTerm_5= ruleNumericRangeTerm | this_RealTerm_6= ruleRealTerm | this_IntegerTerm_7= ruleIntegerTerm | this_ListTerm_8= ruleListTerm | this_BooleanLiteral_9= ruleBooleanLiteral | this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm ) { - // InternalBehaviorAnnexParser.g:5578:2: (this_RecordTerm_0= ruleRecordTerm | this_ReferenceTerm_1= ruleReferenceTerm | this_ComponentClassifierTerm_2= ruleComponentClassifierTerm | this_ComputedTerm_3= ruleComputedTerm | this_StringTerm_4= ruleStringTerm | this_NumericRangeTerm_5= ruleNumericRangeTerm | this_RealTerm_6= ruleRealTerm | this_IntegerTerm_7= ruleIntegerTerm | this_ListTerm_8= ruleListTerm | this_BooleanLiteral_9= ruleBooleanLiteral | this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm ) - int alt99=11; - alt99 = dfa99.predict(input); - switch (alt99) { + // InternalBehaviorAnnexParser.g:5580:2: (this_RecordTerm_0= ruleRecordTerm | this_ReferenceTerm_1= ruleReferenceTerm | this_ComponentClassifierTerm_2= ruleComponentClassifierTerm | this_ComputedTerm_3= ruleComputedTerm | this_StringTerm_4= ruleStringTerm | this_NumericRangeTerm_5= ruleNumericRangeTerm | this_RealTerm_6= ruleRealTerm | this_IntegerTerm_7= ruleIntegerTerm | this_ListTerm_8= ruleListTerm | this_BooleanLiteral_9= ruleBooleanLiteral | this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm ) + int alt100=11; + alt100 = dfa100.predict(input); + switch (alt100) { case 1 : - // InternalBehaviorAnnexParser.g:5579:3: this_RecordTerm_0= ruleRecordTerm + // InternalBehaviorAnnexParser.g:5581:3: this_RecordTerm_0= ruleRecordTerm { if ( state.backtracking==0 ) { @@ -16273,7 +16290,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:5588:3: this_ReferenceTerm_1= ruleReferenceTerm + // InternalBehaviorAnnexParser.g:5590:3: this_ReferenceTerm_1= ruleReferenceTerm { if ( state.backtracking==0 ) { @@ -16295,7 +16312,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:5597:3: this_ComponentClassifierTerm_2= ruleComponentClassifierTerm + // InternalBehaviorAnnexParser.g:5599:3: this_ComponentClassifierTerm_2= ruleComponentClassifierTerm { if ( state.backtracking==0 ) { @@ -16317,7 +16334,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 4 : - // InternalBehaviorAnnexParser.g:5606:3: this_ComputedTerm_3= ruleComputedTerm + // InternalBehaviorAnnexParser.g:5608:3: this_ComputedTerm_3= ruleComputedTerm { if ( state.backtracking==0 ) { @@ -16339,7 +16356,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 5 : - // InternalBehaviorAnnexParser.g:5615:3: this_StringTerm_4= ruleStringTerm + // InternalBehaviorAnnexParser.g:5617:3: this_StringTerm_4= ruleStringTerm { if ( state.backtracking==0 ) { @@ -16361,7 +16378,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 6 : - // InternalBehaviorAnnexParser.g:5624:3: this_NumericRangeTerm_5= ruleNumericRangeTerm + // InternalBehaviorAnnexParser.g:5626:3: this_NumericRangeTerm_5= ruleNumericRangeTerm { if ( state.backtracking==0 ) { @@ -16383,7 +16400,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 7 : - // InternalBehaviorAnnexParser.g:5633:3: this_RealTerm_6= ruleRealTerm + // InternalBehaviorAnnexParser.g:5635:3: this_RealTerm_6= ruleRealTerm { if ( state.backtracking==0 ) { @@ -16405,7 +16422,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 8 : - // InternalBehaviorAnnexParser.g:5642:3: this_IntegerTerm_7= ruleIntegerTerm + // InternalBehaviorAnnexParser.g:5644:3: this_IntegerTerm_7= ruleIntegerTerm { if ( state.backtracking==0 ) { @@ -16427,7 +16444,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 9 : - // InternalBehaviorAnnexParser.g:5651:3: this_ListTerm_8= ruleListTerm + // InternalBehaviorAnnexParser.g:5653:3: this_ListTerm_8= ruleListTerm { if ( state.backtracking==0 ) { @@ -16449,7 +16466,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 10 : - // InternalBehaviorAnnexParser.g:5660:3: this_BooleanLiteral_9= ruleBooleanLiteral + // InternalBehaviorAnnexParser.g:5662:3: this_BooleanLiteral_9= ruleBooleanLiteral { if ( state.backtracking==0 ) { @@ -16471,7 +16488,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 11 : - // InternalBehaviorAnnexParser.g:5669:3: this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm + // InternalBehaviorAnnexParser.g:5671:3: this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm { if ( state.backtracking==0 ) { @@ -16517,7 +16534,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { // $ANTLR start "entryRuleLiteralorReferenceTerm" - // InternalBehaviorAnnexParser.g:5681:1: entryRuleLiteralorReferenceTerm returns [EObject current=null] : iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF ; + // InternalBehaviorAnnexParser.g:5683:1: entryRuleLiteralorReferenceTerm returns [EObject current=null] : iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF ; public final EObject entryRuleLiteralorReferenceTerm() throws RecognitionException { EObject current = null; @@ -16525,8 +16542,8 @@ public final EObject entryRuleLiteralorReferenceTerm() throws RecognitionExcepti try { - // InternalBehaviorAnnexParser.g:5681:63: (iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF ) - // InternalBehaviorAnnexParser.g:5682:2: iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF + // InternalBehaviorAnnexParser.g:5683:63: (iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF ) + // InternalBehaviorAnnexParser.g:5684:2: iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getLiteralorReferenceTermRule()); @@ -16557,7 +16574,7 @@ public final EObject entryRuleLiteralorReferenceTerm() throws RecognitionExcepti // $ANTLR start "ruleLiteralorReferenceTerm" - // InternalBehaviorAnnexParser.g:5688:1: ruleLiteralorReferenceTerm returns [EObject current=null] : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:5690:1: ruleLiteralorReferenceTerm returns [EObject current=null] : ( ( ruleQPREF ) ) ; public final EObject ruleLiteralorReferenceTerm() throws RecognitionException { EObject current = null; @@ -16565,14 +16582,14 @@ public final EObject ruleLiteralorReferenceTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5694:2: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:5695:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:5696:2: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:5697:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:5695:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:5696:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5697:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:5698:3: ( ruleQPREF ) { - // InternalBehaviorAnnexParser.g:5696:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:5697:4: ruleQPREF + // InternalBehaviorAnnexParser.g:5698:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5699:4: ruleQPREF { if ( state.backtracking==0 ) { @@ -16624,7 +16641,7 @@ public final EObject ruleLiteralorReferenceTerm() throws RecognitionException { // $ANTLR start "entryRuleBooleanLiteral" - // InternalBehaviorAnnexParser.g:5714:1: entryRuleBooleanLiteral returns [EObject current=null] : iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ; + // InternalBehaviorAnnexParser.g:5716:1: entryRuleBooleanLiteral returns [EObject current=null] : iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ; public final EObject entryRuleBooleanLiteral() throws RecognitionException { EObject current = null; @@ -16632,8 +16649,8 @@ public final EObject entryRuleBooleanLiteral() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5714:55: (iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ) - // InternalBehaviorAnnexParser.g:5715:2: iv_ruleBooleanLiteral= ruleBooleanLiteral EOF + // InternalBehaviorAnnexParser.g:5716:55: (iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ) + // InternalBehaviorAnnexParser.g:5717:2: iv_ruleBooleanLiteral= ruleBooleanLiteral EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBooleanLiteralRule()); @@ -16664,7 +16681,7 @@ public final EObject entryRuleBooleanLiteral() throws RecognitionException { // $ANTLR start "ruleBooleanLiteral" - // InternalBehaviorAnnexParser.g:5721:1: ruleBooleanLiteral returns [EObject current=null] : ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ; + // InternalBehaviorAnnexParser.g:5723:1: ruleBooleanLiteral returns [EObject current=null] : ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ; public final EObject ruleBooleanLiteral() throws RecognitionException { EObject current = null; @@ -16675,14 +16692,14 @@ public final EObject ruleBooleanLiteral() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5727:2: ( ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ) - // InternalBehaviorAnnexParser.g:5728:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) + // InternalBehaviorAnnexParser.g:5729:2: ( ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ) + // InternalBehaviorAnnexParser.g:5730:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) { - // InternalBehaviorAnnexParser.g:5728:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) - // InternalBehaviorAnnexParser.g:5729:3: () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) + // InternalBehaviorAnnexParser.g:5730:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) + // InternalBehaviorAnnexParser.g:5731:3: () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) { - // InternalBehaviorAnnexParser.g:5729:3: () - // InternalBehaviorAnnexParser.g:5730:4: + // InternalBehaviorAnnexParser.g:5731:3: () + // InternalBehaviorAnnexParser.g:5732:4: { if ( state.backtracking==0 ) { @@ -16694,32 +16711,32 @@ public final EObject ruleBooleanLiteral() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:5736:3: ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) - int alt100=2; - int LA100_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5738:3: ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) + int alt101=2; + int LA101_0 = input.LA(1); - if ( (LA100_0==True) ) { - alt100=1; + if ( (LA101_0==True) ) { + alt101=1; } - else if ( (LA100_0==False) ) { - alt100=2; + else if ( (LA101_0==False) ) { + alt101=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 100, 0, input); + new NoViableAltException("", 101, 0, input); throw nvae; } - switch (alt100) { + switch (alt101) { case 1 : - // InternalBehaviorAnnexParser.g:5737:4: ( (lv_value_1_0= True ) ) + // InternalBehaviorAnnexParser.g:5739:4: ( (lv_value_1_0= True ) ) { - // InternalBehaviorAnnexParser.g:5737:4: ( (lv_value_1_0= True ) ) - // InternalBehaviorAnnexParser.g:5738:5: (lv_value_1_0= True ) + // InternalBehaviorAnnexParser.g:5739:4: ( (lv_value_1_0= True ) ) + // InternalBehaviorAnnexParser.g:5740:5: (lv_value_1_0= True ) { - // InternalBehaviorAnnexParser.g:5738:5: (lv_value_1_0= True ) - // InternalBehaviorAnnexParser.g:5739:6: lv_value_1_0= True + // InternalBehaviorAnnexParser.g:5740:5: (lv_value_1_0= True ) + // InternalBehaviorAnnexParser.g:5741:6: lv_value_1_0= True { lv_value_1_0=(Token)match(input,True,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -16745,7 +16762,7 @@ else if ( (LA100_0==False) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:5752:4: otherlv_2= False + // InternalBehaviorAnnexParser.g:5754:4: otherlv_2= False { otherlv_2=(Token)match(input,False,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -16784,7 +16801,7 @@ else if ( (LA100_0==False) ) { // $ANTLR start "entryRuleConstantValue" - // InternalBehaviorAnnexParser.g:5761:1: entryRuleConstantValue returns [EObject current=null] : iv_ruleConstantValue= ruleConstantValue EOF ; + // InternalBehaviorAnnexParser.g:5763:1: entryRuleConstantValue returns [EObject current=null] : iv_ruleConstantValue= ruleConstantValue EOF ; public final EObject entryRuleConstantValue() throws RecognitionException { EObject current = null; @@ -16792,8 +16809,8 @@ public final EObject entryRuleConstantValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5761:54: (iv_ruleConstantValue= ruleConstantValue EOF ) - // InternalBehaviorAnnexParser.g:5762:2: iv_ruleConstantValue= ruleConstantValue EOF + // InternalBehaviorAnnexParser.g:5763:54: (iv_ruleConstantValue= ruleConstantValue EOF ) + // InternalBehaviorAnnexParser.g:5764:2: iv_ruleConstantValue= ruleConstantValue EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getConstantValueRule()); @@ -16824,7 +16841,7 @@ public final EObject entryRuleConstantValue() throws RecognitionException { // $ANTLR start "ruleConstantValue" - // InternalBehaviorAnnexParser.g:5768:1: ruleConstantValue returns [EObject current=null] : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:5770:1: ruleConstantValue returns [EObject current=null] : ( ( ruleQPREF ) ) ; public final EObject ruleConstantValue() throws RecognitionException { EObject current = null; @@ -16832,14 +16849,14 @@ public final EObject ruleConstantValue() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5774:2: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:5775:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:5776:2: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:5777:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:5775:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:5776:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5777:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:5778:3: ( ruleQPREF ) { - // InternalBehaviorAnnexParser.g:5776:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:5777:4: ruleQPREF + // InternalBehaviorAnnexParser.g:5778:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5779:4: ruleQPREF { if ( state.backtracking==0 ) { @@ -16891,7 +16908,7 @@ public final EObject ruleConstantValue() throws RecognitionException { // $ANTLR start "entryRuleReferenceTerm" - // InternalBehaviorAnnexParser.g:5794:1: entryRuleReferenceTerm returns [EObject current=null] : iv_ruleReferenceTerm= ruleReferenceTerm EOF ; + // InternalBehaviorAnnexParser.g:5796:1: entryRuleReferenceTerm returns [EObject current=null] : iv_ruleReferenceTerm= ruleReferenceTerm EOF ; public final EObject entryRuleReferenceTerm() throws RecognitionException { EObject current = null; @@ -16899,8 +16916,8 @@ public final EObject entryRuleReferenceTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5794:54: (iv_ruleReferenceTerm= ruleReferenceTerm EOF ) - // InternalBehaviorAnnexParser.g:5795:2: iv_ruleReferenceTerm= ruleReferenceTerm EOF + // InternalBehaviorAnnexParser.g:5796:54: (iv_ruleReferenceTerm= ruleReferenceTerm EOF ) + // InternalBehaviorAnnexParser.g:5797:2: iv_ruleReferenceTerm= ruleReferenceTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceTermRule()); @@ -16931,7 +16948,7 @@ public final EObject entryRuleReferenceTerm() throws RecognitionException { // $ANTLR start "ruleReferenceTerm" - // InternalBehaviorAnnexParser.g:5801:1: ruleReferenceTerm returns [EObject current=null] : (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:5803:1: ruleReferenceTerm returns [EObject current=null] : (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) ; public final EObject ruleReferenceTerm() throws RecognitionException { EObject current = null; @@ -16945,11 +16962,11 @@ public final EObject ruleReferenceTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5807:2: ( (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:5808:2: (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) + // InternalBehaviorAnnexParser.g:5809:2: ( (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:5810:2: (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) { - // InternalBehaviorAnnexParser.g:5808:2: (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) - // InternalBehaviorAnnexParser.g:5809:3: otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis + // InternalBehaviorAnnexParser.g:5810:2: (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) + // InternalBehaviorAnnexParser.g:5811:3: otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis { otherlv_0=(Token)match(input,Reference,FollowSets000.FOLLOW_31); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -16963,11 +16980,11 @@ public final EObject ruleReferenceTerm() throws RecognitionException { newLeafNode(otherlv_1, grammarAccess.getReferenceTermAccess().getLeftParenthesisKeyword_1()); } - // InternalBehaviorAnnexParser.g:5817:3: ( (lv_path_2_0= ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:5818:4: (lv_path_2_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:5819:3: ( (lv_path_2_0= ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:5820:4: (lv_path_2_0= ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:5818:4: (lv_path_2_0= ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:5819:5: lv_path_2_0= ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:5820:4: (lv_path_2_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:5821:5: lv_path_2_0= ruleContainmentPathElement { if ( state.backtracking==0 ) { @@ -17029,7 +17046,7 @@ public final EObject ruleReferenceTerm() throws RecognitionException { // $ANTLR start "entryRuleRecordTerm" - // InternalBehaviorAnnexParser.g:5844:1: entryRuleRecordTerm returns [EObject current=null] : iv_ruleRecordTerm= ruleRecordTerm EOF ; + // InternalBehaviorAnnexParser.g:5846:1: entryRuleRecordTerm returns [EObject current=null] : iv_ruleRecordTerm= ruleRecordTerm EOF ; public final EObject entryRuleRecordTerm() throws RecognitionException { EObject current = null; @@ -17037,8 +17054,8 @@ public final EObject entryRuleRecordTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5844:51: (iv_ruleRecordTerm= ruleRecordTerm EOF ) - // InternalBehaviorAnnexParser.g:5845:2: iv_ruleRecordTerm= ruleRecordTerm EOF + // InternalBehaviorAnnexParser.g:5846:51: (iv_ruleRecordTerm= ruleRecordTerm EOF ) + // InternalBehaviorAnnexParser.g:5847:2: iv_ruleRecordTerm= ruleRecordTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getRecordTermRule()); @@ -17069,7 +17086,7 @@ public final EObject entryRuleRecordTerm() throws RecognitionException { // $ANTLR start "ruleRecordTerm" - // InternalBehaviorAnnexParser.g:5851:1: ruleRecordTerm returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:5853:1: ruleRecordTerm returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) ; public final EObject ruleRecordTerm() throws RecognitionException { EObject current = null; @@ -17082,11 +17099,11 @@ public final EObject ruleRecordTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5857:2: ( (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:5858:2: (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) + // InternalBehaviorAnnexParser.g:5859:2: ( (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:5860:2: (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:5858:2: (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) - // InternalBehaviorAnnexParser.g:5859:3: otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket + // InternalBehaviorAnnexParser.g:5860:2: (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) + // InternalBehaviorAnnexParser.g:5861:3: otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket { otherlv_0=(Token)match(input,LeftSquareBracket,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -17094,31 +17111,31 @@ public final EObject ruleRecordTerm() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getRecordTermAccess().getLeftSquareBracketKeyword_0()); } - // InternalBehaviorAnnexParser.g:5863:3: ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ - int cnt101=0; - loop101: + // InternalBehaviorAnnexParser.g:5865:3: ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ + int cnt102=0; + loop102: do { - int alt101=2; - int LA101_0 = input.LA(1); + int alt102=2; + int LA102_0 = input.LA(1); - if ( (LA101_0==RULE_ID) ) { - alt101=1; + if ( (LA102_0==RULE_ID) ) { + alt102=1; } - switch (alt101) { + switch (alt102) { case 1 : - // InternalBehaviorAnnexParser.g:5864:4: (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) + // InternalBehaviorAnnexParser.g:5866:4: (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) { - // InternalBehaviorAnnexParser.g:5864:4: (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) - // InternalBehaviorAnnexParser.g:5865:5: lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation + // InternalBehaviorAnnexParser.g:5866:4: (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) + // InternalBehaviorAnnexParser.g:5867:5: lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getRecordTermAccess().getOwnedFieldValueFieldPropertyAssociationParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_84); + pushFollow(FollowSets000.FOLLOW_85); lv_ownedFieldValue_1_0=ruleFieldPropertyAssociation(); state._fsp--; @@ -17144,13 +17161,13 @@ public final EObject ruleRecordTerm() throws RecognitionException { break; default : - if ( cnt101 >= 1 ) break loop101; + if ( cnt102 >= 1 ) break loop102; if (state.backtracking>0) {state.failed=true; return current;} EarlyExitException eee = - new EarlyExitException(101, input); + new EarlyExitException(102, input); throw eee; } - cnt101++; + cnt102++; } while (true); otherlv_2=(Token)match(input,RightSquareBracket,FollowSets000.FOLLOW_2); if (state.failed) return current; @@ -17184,7 +17201,7 @@ public final EObject ruleRecordTerm() throws RecognitionException { // $ANTLR start "entryRuleComputedTerm" - // InternalBehaviorAnnexParser.g:5890:1: entryRuleComputedTerm returns [EObject current=null] : iv_ruleComputedTerm= ruleComputedTerm EOF ; + // InternalBehaviorAnnexParser.g:5892:1: entryRuleComputedTerm returns [EObject current=null] : iv_ruleComputedTerm= ruleComputedTerm EOF ; public final EObject entryRuleComputedTerm() throws RecognitionException { EObject current = null; @@ -17192,8 +17209,8 @@ public final EObject entryRuleComputedTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5890:53: (iv_ruleComputedTerm= ruleComputedTerm EOF ) - // InternalBehaviorAnnexParser.g:5891:2: iv_ruleComputedTerm= ruleComputedTerm EOF + // InternalBehaviorAnnexParser.g:5892:53: (iv_ruleComputedTerm= ruleComputedTerm EOF ) + // InternalBehaviorAnnexParser.g:5893:2: iv_ruleComputedTerm= ruleComputedTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getComputedTermRule()); @@ -17224,7 +17241,7 @@ public final EObject entryRuleComputedTerm() throws RecognitionException { // $ANTLR start "ruleComputedTerm" - // InternalBehaviorAnnexParser.g:5897:1: ruleComputedTerm returns [EObject current=null] : (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:5899:1: ruleComputedTerm returns [EObject current=null] : (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) ; public final EObject ruleComputedTerm() throws RecognitionException { EObject current = null; @@ -17237,11 +17254,11 @@ public final EObject ruleComputedTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5903:2: ( (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:5904:2: (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) + // InternalBehaviorAnnexParser.g:5905:2: ( (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:5906:2: (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) { - // InternalBehaviorAnnexParser.g:5904:2: (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) - // InternalBehaviorAnnexParser.g:5905:3: otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis + // InternalBehaviorAnnexParser.g:5906:2: (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) + // InternalBehaviorAnnexParser.g:5907:3: otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis { otherlv_0=(Token)match(input,Compute,FollowSets000.FOLLOW_31); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -17255,11 +17272,11 @@ public final EObject ruleComputedTerm() throws RecognitionException { newLeafNode(otherlv_1, grammarAccess.getComputedTermAccess().getLeftParenthesisKeyword_1()); } - // InternalBehaviorAnnexParser.g:5913:3: ( (lv_function_2_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:5914:4: (lv_function_2_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:5915:3: ( (lv_function_2_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:5916:4: (lv_function_2_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:5914:4: (lv_function_2_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:5915:5: lv_function_2_0= RULE_ID + // InternalBehaviorAnnexParser.g:5916:4: (lv_function_2_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:5917:5: lv_function_2_0= RULE_ID { lv_function_2_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_39); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -17316,7 +17333,7 @@ public final EObject ruleComputedTerm() throws RecognitionException { // $ANTLR start "entryRuleComponentClassifierTerm" - // InternalBehaviorAnnexParser.g:5939:1: entryRuleComponentClassifierTerm returns [EObject current=null] : iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF ; + // InternalBehaviorAnnexParser.g:5941:1: entryRuleComponentClassifierTerm returns [EObject current=null] : iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF ; public final EObject entryRuleComponentClassifierTerm() throws RecognitionException { EObject current = null; @@ -17324,8 +17341,8 @@ public final EObject entryRuleComponentClassifierTerm() throws RecognitionExcept try { - // InternalBehaviorAnnexParser.g:5939:64: (iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF ) - // InternalBehaviorAnnexParser.g:5940:2: iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF + // InternalBehaviorAnnexParser.g:5941:64: (iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF ) + // InternalBehaviorAnnexParser.g:5942:2: iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getComponentClassifierTermRule()); @@ -17356,7 +17373,7 @@ public final EObject entryRuleComponentClassifierTerm() throws RecognitionExcept // $ANTLR start "ruleComponentClassifierTerm" - // InternalBehaviorAnnexParser.g:5946:1: ruleComponentClassifierTerm returns [EObject current=null] : (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:5948:1: ruleComponentClassifierTerm returns [EObject current=null] : (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) ; public final EObject ruleComponentClassifierTerm() throws RecognitionException { EObject current = null; @@ -17368,11 +17385,11 @@ public final EObject ruleComponentClassifierTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5952:2: ( (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:5953:2: (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) + // InternalBehaviorAnnexParser.g:5954:2: ( (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:5955:2: (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) { - // InternalBehaviorAnnexParser.g:5953:2: (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) - // InternalBehaviorAnnexParser.g:5954:3: otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis + // InternalBehaviorAnnexParser.g:5955:2: (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) + // InternalBehaviorAnnexParser.g:5956:3: otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis { otherlv_0=(Token)match(input,Classifier,FollowSets000.FOLLOW_31); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -17386,11 +17403,11 @@ public final EObject ruleComponentClassifierTerm() throws RecognitionException { newLeafNode(otherlv_1, grammarAccess.getComponentClassifierTermAccess().getLeftParenthesisKeyword_1()); } - // InternalBehaviorAnnexParser.g:5962:3: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:5963:4: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:5964:3: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:5965:4: ( ruleQCREF ) { - // InternalBehaviorAnnexParser.g:5963:4: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:5964:5: ruleQCREF + // InternalBehaviorAnnexParser.g:5965:4: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:5966:5: ruleQCREF { if ( state.backtracking==0 ) { @@ -17451,7 +17468,7 @@ public final EObject ruleComponentClassifierTerm() throws RecognitionException { // $ANTLR start "entryRuleListTerm" - // InternalBehaviorAnnexParser.g:5986:1: entryRuleListTerm returns [EObject current=null] : iv_ruleListTerm= ruleListTerm EOF ; + // InternalBehaviorAnnexParser.g:5988:1: entryRuleListTerm returns [EObject current=null] : iv_ruleListTerm= ruleListTerm EOF ; public final EObject entryRuleListTerm() throws RecognitionException { EObject current = null; @@ -17459,8 +17476,8 @@ public final EObject entryRuleListTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5986:49: (iv_ruleListTerm= ruleListTerm EOF ) - // InternalBehaviorAnnexParser.g:5987:2: iv_ruleListTerm= ruleListTerm EOF + // InternalBehaviorAnnexParser.g:5988:49: (iv_ruleListTerm= ruleListTerm EOF ) + // InternalBehaviorAnnexParser.g:5989:2: iv_ruleListTerm= ruleListTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getListTermRule()); @@ -17491,7 +17508,7 @@ public final EObject entryRuleListTerm() throws RecognitionException { // $ANTLR start "ruleListTerm" - // InternalBehaviorAnnexParser.g:5993:1: ruleListTerm returns [EObject current=null] : ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:5995:1: ruleListTerm returns [EObject current=null] : ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) ; public final EObject ruleListTerm() throws RecognitionException { EObject current = null; @@ -17507,14 +17524,14 @@ public final EObject ruleListTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5999:2: ( ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:6000:2: ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) + // InternalBehaviorAnnexParser.g:6001:2: ( ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:6002:2: ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) { - // InternalBehaviorAnnexParser.g:6000:2: ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) - // InternalBehaviorAnnexParser.g:6001:3: () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis + // InternalBehaviorAnnexParser.g:6002:2: ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) + // InternalBehaviorAnnexParser.g:6003:3: () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis { - // InternalBehaviorAnnexParser.g:6001:3: () - // InternalBehaviorAnnexParser.g:6002:4: + // InternalBehaviorAnnexParser.g:6003:3: () + // InternalBehaviorAnnexParser.g:6004:4: { if ( state.backtracking==0 ) { @@ -17526,28 +17543,28 @@ public final EObject ruleListTerm() throws RecognitionException { } - otherlv_1=(Token)match(input,LeftParenthesis,FollowSets000.FOLLOW_85); if (state.failed) return current; + otherlv_1=(Token)match(input,LeftParenthesis,FollowSets000.FOLLOW_86); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getListTermAccess().getLeftParenthesisKeyword_1()); } - // InternalBehaviorAnnexParser.g:6012:3: ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? - int alt103=2; - int LA103_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6014:3: ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? + int alt104=2; + int LA104_0 = input.LA(1); - if ( (LA103_0==Classifier||LA103_0==Reference||LA103_0==Compute||LA103_0==False||LA103_0==True||LA103_0==LeftParenthesis||LA103_0==PlusSign||LA103_0==HyphenMinus||LA103_0==LeftSquareBracket||LA103_0==RULE_REAL_LIT||LA103_0==RULE_INTEGER_LIT||(LA103_0>=RULE_STRING && LA103_0<=RULE_ID)) ) { - alt103=1; + if ( (LA104_0==Classifier||LA104_0==Reference||LA104_0==Compute||LA104_0==False||LA104_0==True||LA104_0==LeftParenthesis||LA104_0==PlusSign||LA104_0==HyphenMinus||LA104_0==LeftSquareBracket||LA104_0==RULE_REAL_LIT||LA104_0==RULE_INTEGER_LIT||(LA104_0>=RULE_STRING && LA104_0<=RULE_ID)) ) { + alt104=1; } - switch (alt103) { + switch (alt104) { case 1 : - // InternalBehaviorAnnexParser.g:6013:4: ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* + // InternalBehaviorAnnexParser.g:6015:4: ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* { - // InternalBehaviorAnnexParser.g:6013:4: ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:6014:5: (lv_ownedListElement_2_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6015:4: ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:6016:5: (lv_ownedListElement_2_0= rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:6014:5: (lv_ownedListElement_2_0= rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:6015:6: lv_ownedListElement_2_0= rulePropertyExpression + // InternalBehaviorAnnexParser.g:6016:5: (lv_ownedListElement_2_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6017:6: lv_ownedListElement_2_0= rulePropertyExpression { if ( state.backtracking==0 ) { @@ -17578,20 +17595,20 @@ public final EObject ruleListTerm() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6032:4: (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* - loop102: + // InternalBehaviorAnnexParser.g:6034:4: (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* + loop103: do { - int alt102=2; - int LA102_0 = input.LA(1); + int alt103=2; + int LA103_0 = input.LA(1); - if ( (LA102_0==Comma) ) { - alt102=1; + if ( (LA103_0==Comma) ) { + alt103=1; } - switch (alt102) { + switch (alt103) { case 1 : - // InternalBehaviorAnnexParser.g:6033:5: otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:6035:5: otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) { otherlv_3=(Token)match(input,Comma,FollowSets000.FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -17599,11 +17616,11 @@ public final EObject ruleListTerm() throws RecognitionException { newLeafNode(otherlv_3, grammarAccess.getListTermAccess().getCommaKeyword_2_1_0()); } - // InternalBehaviorAnnexParser.g:6037:5: ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:6038:6: (lv_ownedListElement_4_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6039:5: ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:6040:6: (lv_ownedListElement_4_0= rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:6038:6: (lv_ownedListElement_4_0= rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:6039:7: lv_ownedListElement_4_0= rulePropertyExpression + // InternalBehaviorAnnexParser.g:6040:6: (lv_ownedListElement_4_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6041:7: lv_ownedListElement_4_0= rulePropertyExpression { if ( state.backtracking==0 ) { @@ -17639,7 +17656,7 @@ public final EObject ruleListTerm() throws RecognitionException { break; default : - break loop102; + break loop103; } } while (true); @@ -17680,7 +17697,7 @@ public final EObject ruleListTerm() throws RecognitionException { // $ANTLR start "entryRuleFieldPropertyAssociation" - // InternalBehaviorAnnexParser.g:6066:1: entryRuleFieldPropertyAssociation returns [EObject current=null] : iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF ; + // InternalBehaviorAnnexParser.g:6068:1: entryRuleFieldPropertyAssociation returns [EObject current=null] : iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF ; public final EObject entryRuleFieldPropertyAssociation() throws RecognitionException { EObject current = null; @@ -17688,8 +17705,8 @@ public final EObject entryRuleFieldPropertyAssociation() throws RecognitionExcep try { - // InternalBehaviorAnnexParser.g:6066:65: (iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF ) - // InternalBehaviorAnnexParser.g:6067:2: iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF + // InternalBehaviorAnnexParser.g:6068:65: (iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF ) + // InternalBehaviorAnnexParser.g:6069:2: iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getFieldPropertyAssociationRule()); @@ -17720,7 +17737,7 @@ public final EObject entryRuleFieldPropertyAssociation() throws RecognitionExcep // $ANTLR start "ruleFieldPropertyAssociation" - // InternalBehaviorAnnexParser.g:6073:1: ruleFieldPropertyAssociation returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) ; + // InternalBehaviorAnnexParser.g:6075:1: ruleFieldPropertyAssociation returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) ; public final EObject ruleFieldPropertyAssociation() throws RecognitionException { EObject current = null; @@ -17734,17 +17751,17 @@ public final EObject ruleFieldPropertyAssociation() throws RecognitionException enterRule(); try { - // InternalBehaviorAnnexParser.g:6079:2: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) ) - // InternalBehaviorAnnexParser.g:6080:2: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) + // InternalBehaviorAnnexParser.g:6081:2: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) ) + // InternalBehaviorAnnexParser.g:6082:2: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) { - // InternalBehaviorAnnexParser.g:6080:2: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) - // InternalBehaviorAnnexParser.g:6081:3: ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon + // InternalBehaviorAnnexParser.g:6082:2: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) + // InternalBehaviorAnnexParser.g:6083:3: ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon { - // InternalBehaviorAnnexParser.g:6081:3: ( (otherlv_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:6082:4: (otherlv_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:6083:3: ( (otherlv_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:6084:4: (otherlv_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:6082:4: (otherlv_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:6083:5: otherlv_0= RULE_ID + // InternalBehaviorAnnexParser.g:6084:4: (otherlv_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:6085:5: otherlv_0= RULE_ID { if ( state.backtracking==0 ) { @@ -17771,11 +17788,11 @@ public final EObject ruleFieldPropertyAssociation() throws RecognitionException newLeafNode(otherlv_1, grammarAccess.getFieldPropertyAssociationAccess().getEqualsSignGreaterThanSignKeyword_1()); } - // InternalBehaviorAnnexParser.g:6098:3: ( (lv_ownedValue_2_0= rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:6099:4: (lv_ownedValue_2_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6100:3: ( (lv_ownedValue_2_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:6101:4: (lv_ownedValue_2_0= rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:6099:4: (lv_ownedValue_2_0= rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:6100:5: lv_ownedValue_2_0= rulePropertyExpression + // InternalBehaviorAnnexParser.g:6101:4: (lv_ownedValue_2_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6102:5: lv_ownedValue_2_0= rulePropertyExpression { if ( state.backtracking==0 ) { @@ -17837,7 +17854,7 @@ public final EObject ruleFieldPropertyAssociation() throws RecognitionException // $ANTLR start "entryRuleContainmentPathElement" - // InternalBehaviorAnnexParser.g:6125:1: entryRuleContainmentPathElement returns [EObject current=null] : iv_ruleContainmentPathElement= ruleContainmentPathElement EOF ; + // InternalBehaviorAnnexParser.g:6127:1: entryRuleContainmentPathElement returns [EObject current=null] : iv_ruleContainmentPathElement= ruleContainmentPathElement EOF ; public final EObject entryRuleContainmentPathElement() throws RecognitionException { EObject current = null; @@ -17845,8 +17862,8 @@ public final EObject entryRuleContainmentPathElement() throws RecognitionExcepti try { - // InternalBehaviorAnnexParser.g:6125:63: (iv_ruleContainmentPathElement= ruleContainmentPathElement EOF ) - // InternalBehaviorAnnexParser.g:6126:2: iv_ruleContainmentPathElement= ruleContainmentPathElement EOF + // InternalBehaviorAnnexParser.g:6127:63: (iv_ruleContainmentPathElement= ruleContainmentPathElement EOF ) + // InternalBehaviorAnnexParser.g:6128:2: iv_ruleContainmentPathElement= ruleContainmentPathElement EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainmentPathElementRule()); @@ -17877,7 +17894,7 @@ public final EObject entryRuleContainmentPathElement() throws RecognitionExcepti // $ANTLR start "ruleContainmentPathElement" - // InternalBehaviorAnnexParser.g:6132:1: ruleContainmentPathElement returns [EObject current=null] : ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) ; + // InternalBehaviorAnnexParser.g:6134:1: ruleContainmentPathElement returns [EObject current=null] : ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) ; public final EObject ruleContainmentPathElement() throws RecognitionException { EObject current = null; @@ -17892,20 +17909,20 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6138:2: ( ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) ) - // InternalBehaviorAnnexParser.g:6139:2: ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) + // InternalBehaviorAnnexParser.g:6140:2: ( ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) ) + // InternalBehaviorAnnexParser.g:6141:2: ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) { - // InternalBehaviorAnnexParser.g:6139:2: ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) - // InternalBehaviorAnnexParser.g:6140:3: ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? + // InternalBehaviorAnnexParser.g:6141:2: ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) + // InternalBehaviorAnnexParser.g:6142:3: ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? { - // InternalBehaviorAnnexParser.g:6140:3: ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) - // InternalBehaviorAnnexParser.g:6141:4: ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* + // InternalBehaviorAnnexParser.g:6142:3: ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) + // InternalBehaviorAnnexParser.g:6143:4: ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* { - // InternalBehaviorAnnexParser.g:6141:4: ( (otherlv_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:6142:5: (otherlv_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:6143:4: ( (otherlv_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:6144:5: (otherlv_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:6142:5: (otherlv_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:6143:6: otherlv_0= RULE_ID + // InternalBehaviorAnnexParser.g:6144:5: (otherlv_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:6145:6: otherlv_0= RULE_ID { if ( state.backtracking==0 ) { @@ -17914,7 +17931,7 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { } } - otherlv_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_72); if (state.failed) return current; + otherlv_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_73); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getContainmentPathElementAccess().getNamedElementNamedElementCrossReference_0_0_0()); @@ -17926,30 +17943,30 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6154:4: ( (lv_arrayRange_1_0= ruleArrayRange ) )* - loop104: + // InternalBehaviorAnnexParser.g:6156:4: ( (lv_arrayRange_1_0= ruleArrayRange ) )* + loop105: do { - int alt104=2; - int LA104_0 = input.LA(1); + int alt105=2; + int LA105_0 = input.LA(1); - if ( (LA104_0==LeftSquareBracket) ) { - alt104=1; + if ( (LA105_0==LeftSquareBracket) ) { + alt105=1; } - switch (alt104) { + switch (alt105) { case 1 : - // InternalBehaviorAnnexParser.g:6155:5: (lv_arrayRange_1_0= ruleArrayRange ) + // InternalBehaviorAnnexParser.g:6157:5: (lv_arrayRange_1_0= ruleArrayRange ) { - // InternalBehaviorAnnexParser.g:6155:5: (lv_arrayRange_1_0= ruleArrayRange ) - // InternalBehaviorAnnexParser.g:6156:6: lv_arrayRange_1_0= ruleArrayRange + // InternalBehaviorAnnexParser.g:6157:5: (lv_arrayRange_1_0= ruleArrayRange ) + // InternalBehaviorAnnexParser.g:6158:6: lv_arrayRange_1_0= ruleArrayRange { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainmentPathElementAccess().getArrayRangeArrayRangeParserRuleCall_0_1_0()); } - pushFollow(FollowSets000.FOLLOW_72); + pushFollow(FollowSets000.FOLLOW_73); lv_arrayRange_1_0=ruleArrayRange(); state._fsp--; @@ -17975,23 +17992,23 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { break; default : - break loop104; + break loop105; } } while (true); } - // InternalBehaviorAnnexParser.g:6174:3: (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? - int alt105=2; - int LA105_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6176:3: (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? + int alt106=2; + int LA106_0 = input.LA(1); - if ( (LA105_0==FullStop) ) { - alt105=1; + if ( (LA106_0==FullStop) ) { + alt106=1; } - switch (alt105) { + switch (alt106) { case 1 : - // InternalBehaviorAnnexParser.g:6175:4: otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:6177:4: otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) { otherlv_2=(Token)match(input,FullStop,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -17999,11 +18016,11 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { newLeafNode(otherlv_2, grammarAccess.getContainmentPathElementAccess().getFullStopKeyword_1_0()); } - // InternalBehaviorAnnexParser.g:6179:4: ( (lv_path_3_0= ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:6180:5: (lv_path_3_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:6181:4: ( (lv_path_3_0= ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:6182:5: (lv_path_3_0= ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:6180:5: (lv_path_3_0= ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:6181:6: lv_path_3_0= ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:6182:5: (lv_path_3_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:6183:6: lv_path_3_0= ruleContainmentPathElement { if ( state.backtracking==0 ) { @@ -18065,7 +18082,7 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { // $ANTLR start "entryRulePlusMinus" - // InternalBehaviorAnnexParser.g:6203:1: entryRulePlusMinus returns [String current=null] : iv_rulePlusMinus= rulePlusMinus EOF ; + // InternalBehaviorAnnexParser.g:6205:1: entryRulePlusMinus returns [String current=null] : iv_rulePlusMinus= rulePlusMinus EOF ; public final String entryRulePlusMinus() throws RecognitionException { String current = null; @@ -18073,8 +18090,8 @@ public final String entryRulePlusMinus() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6203:49: (iv_rulePlusMinus= rulePlusMinus EOF ) - // InternalBehaviorAnnexParser.g:6204:2: iv_rulePlusMinus= rulePlusMinus EOF + // InternalBehaviorAnnexParser.g:6205:49: (iv_rulePlusMinus= rulePlusMinus EOF ) + // InternalBehaviorAnnexParser.g:6206:2: iv_rulePlusMinus= rulePlusMinus EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPlusMinusRule()); @@ -18105,7 +18122,7 @@ public final String entryRulePlusMinus() throws RecognitionException { // $ANTLR start "rulePlusMinus" - // InternalBehaviorAnnexParser.g:6210:1: rulePlusMinus returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= PlusSign | kw= HyphenMinus ) ; + // InternalBehaviorAnnexParser.g:6212:1: rulePlusMinus returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= PlusSign | kw= HyphenMinus ) ; public final AntlrDatatypeRuleToken rulePlusMinus() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -18115,29 +18132,29 @@ public final AntlrDatatypeRuleToken rulePlusMinus() throws RecognitionException enterRule(); try { - // InternalBehaviorAnnexParser.g:6216:2: ( (kw= PlusSign | kw= HyphenMinus ) ) - // InternalBehaviorAnnexParser.g:6217:2: (kw= PlusSign | kw= HyphenMinus ) + // InternalBehaviorAnnexParser.g:6218:2: ( (kw= PlusSign | kw= HyphenMinus ) ) + // InternalBehaviorAnnexParser.g:6219:2: (kw= PlusSign | kw= HyphenMinus ) { - // InternalBehaviorAnnexParser.g:6217:2: (kw= PlusSign | kw= HyphenMinus ) - int alt106=2; - int LA106_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6219:2: (kw= PlusSign | kw= HyphenMinus ) + int alt107=2; + int LA107_0 = input.LA(1); - if ( (LA106_0==PlusSign) ) { - alt106=1; + if ( (LA107_0==PlusSign) ) { + alt107=1; } - else if ( (LA106_0==HyphenMinus) ) { - alt106=2; + else if ( (LA107_0==HyphenMinus) ) { + alt107=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 106, 0, input); + new NoViableAltException("", 107, 0, input); throw nvae; } - switch (alt106) { + switch (alt107) { case 1 : - // InternalBehaviorAnnexParser.g:6218:3: kw= PlusSign + // InternalBehaviorAnnexParser.g:6220:3: kw= PlusSign { kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -18150,7 +18167,7 @@ else if ( (LA106_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:6224:3: kw= HyphenMinus + // InternalBehaviorAnnexParser.g:6226:3: kw= HyphenMinus { kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -18187,7 +18204,7 @@ else if ( (LA106_0==HyphenMinus) ) { // $ANTLR start "entryRuleStringTerm" - // InternalBehaviorAnnexParser.g:6233:1: entryRuleStringTerm returns [EObject current=null] : iv_ruleStringTerm= ruleStringTerm EOF ; + // InternalBehaviorAnnexParser.g:6235:1: entryRuleStringTerm returns [EObject current=null] : iv_ruleStringTerm= ruleStringTerm EOF ; public final EObject entryRuleStringTerm() throws RecognitionException { EObject current = null; @@ -18195,8 +18212,8 @@ public final EObject entryRuleStringTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6233:51: (iv_ruleStringTerm= ruleStringTerm EOF ) - // InternalBehaviorAnnexParser.g:6234:2: iv_ruleStringTerm= ruleStringTerm EOF + // InternalBehaviorAnnexParser.g:6235:51: (iv_ruleStringTerm= ruleStringTerm EOF ) + // InternalBehaviorAnnexParser.g:6236:2: iv_ruleStringTerm= ruleStringTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getStringTermRule()); @@ -18227,7 +18244,7 @@ public final EObject entryRuleStringTerm() throws RecognitionException { // $ANTLR start "ruleStringTerm" - // InternalBehaviorAnnexParser.g:6240:1: ruleStringTerm returns [EObject current=null] : ( (lv_value_0_0= ruleNoQuoteString ) ) ; + // InternalBehaviorAnnexParser.g:6242:1: ruleStringTerm returns [EObject current=null] : ( (lv_value_0_0= ruleNoQuoteString ) ) ; public final EObject ruleStringTerm() throws RecognitionException { EObject current = null; @@ -18238,14 +18255,14 @@ public final EObject ruleStringTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6246:2: ( ( (lv_value_0_0= ruleNoQuoteString ) ) ) - // InternalBehaviorAnnexParser.g:6247:2: ( (lv_value_0_0= ruleNoQuoteString ) ) + // InternalBehaviorAnnexParser.g:6248:2: ( ( (lv_value_0_0= ruleNoQuoteString ) ) ) + // InternalBehaviorAnnexParser.g:6249:2: ( (lv_value_0_0= ruleNoQuoteString ) ) { - // InternalBehaviorAnnexParser.g:6247:2: ( (lv_value_0_0= ruleNoQuoteString ) ) - // InternalBehaviorAnnexParser.g:6248:3: (lv_value_0_0= ruleNoQuoteString ) + // InternalBehaviorAnnexParser.g:6249:2: ( (lv_value_0_0= ruleNoQuoteString ) ) + // InternalBehaviorAnnexParser.g:6250:3: (lv_value_0_0= ruleNoQuoteString ) { - // InternalBehaviorAnnexParser.g:6248:3: (lv_value_0_0= ruleNoQuoteString ) - // InternalBehaviorAnnexParser.g:6249:4: lv_value_0_0= ruleNoQuoteString + // InternalBehaviorAnnexParser.g:6250:3: (lv_value_0_0= ruleNoQuoteString ) + // InternalBehaviorAnnexParser.g:6251:4: lv_value_0_0= ruleNoQuoteString { if ( state.backtracking==0 ) { @@ -18298,7 +18315,7 @@ public final EObject ruleStringTerm() throws RecognitionException { // $ANTLR start "entryRuleNoQuoteString" - // InternalBehaviorAnnexParser.g:6269:1: entryRuleNoQuoteString returns [String current=null] : iv_ruleNoQuoteString= ruleNoQuoteString EOF ; + // InternalBehaviorAnnexParser.g:6271:1: entryRuleNoQuoteString returns [String current=null] : iv_ruleNoQuoteString= ruleNoQuoteString EOF ; public final String entryRuleNoQuoteString() throws RecognitionException { String current = null; @@ -18306,8 +18323,8 @@ public final String entryRuleNoQuoteString() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6269:53: (iv_ruleNoQuoteString= ruleNoQuoteString EOF ) - // InternalBehaviorAnnexParser.g:6270:2: iv_ruleNoQuoteString= ruleNoQuoteString EOF + // InternalBehaviorAnnexParser.g:6271:53: (iv_ruleNoQuoteString= ruleNoQuoteString EOF ) + // InternalBehaviorAnnexParser.g:6272:2: iv_ruleNoQuoteString= ruleNoQuoteString EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNoQuoteStringRule()); @@ -18338,7 +18355,7 @@ public final String entryRuleNoQuoteString() throws RecognitionException { // $ANTLR start "ruleNoQuoteString" - // InternalBehaviorAnnexParser.g:6276:1: ruleNoQuoteString returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_STRING_0= RULE_STRING ; + // InternalBehaviorAnnexParser.g:6278:1: ruleNoQuoteString returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_STRING_0= RULE_STRING ; public final AntlrDatatypeRuleToken ruleNoQuoteString() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -18348,8 +18365,8 @@ public final AntlrDatatypeRuleToken ruleNoQuoteString() throws RecognitionExcept enterRule(); try { - // InternalBehaviorAnnexParser.g:6282:2: (this_STRING_0= RULE_STRING ) - // InternalBehaviorAnnexParser.g:6283:2: this_STRING_0= RULE_STRING + // InternalBehaviorAnnexParser.g:6284:2: (this_STRING_0= RULE_STRING ) + // InternalBehaviorAnnexParser.g:6285:2: this_STRING_0= RULE_STRING { this_STRING_0=(Token)match(input,RULE_STRING,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -18384,7 +18401,7 @@ public final AntlrDatatypeRuleToken ruleNoQuoteString() throws RecognitionExcept // $ANTLR start "entryRuleArrayRange" - // InternalBehaviorAnnexParser.g:6293:1: entryRuleArrayRange returns [EObject current=null] : iv_ruleArrayRange= ruleArrayRange EOF ; + // InternalBehaviorAnnexParser.g:6295:1: entryRuleArrayRange returns [EObject current=null] : iv_ruleArrayRange= ruleArrayRange EOF ; public final EObject entryRuleArrayRange() throws RecognitionException { EObject current = null; @@ -18392,8 +18409,8 @@ public final EObject entryRuleArrayRange() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6293:51: (iv_ruleArrayRange= ruleArrayRange EOF ) - // InternalBehaviorAnnexParser.g:6294:2: iv_ruleArrayRange= ruleArrayRange EOF + // InternalBehaviorAnnexParser.g:6295:51: (iv_ruleArrayRange= ruleArrayRange EOF ) + // InternalBehaviorAnnexParser.g:6296:2: iv_ruleArrayRange= ruleArrayRange EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getArrayRangeRule()); @@ -18424,7 +18441,7 @@ public final EObject entryRuleArrayRange() throws RecognitionException { // $ANTLR start "ruleArrayRange" - // InternalBehaviorAnnexParser.g:6300:1: ruleArrayRange returns [EObject current=null] : ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:6302:1: ruleArrayRange returns [EObject current=null] : ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) ; public final EObject ruleArrayRange() throws RecognitionException { EObject current = null; @@ -18440,14 +18457,14 @@ public final EObject ruleArrayRange() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6306:2: ( ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:6307:2: ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) + // InternalBehaviorAnnexParser.g:6308:2: ( ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:6309:2: ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:6307:2: ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) - // InternalBehaviorAnnexParser.g:6308:3: () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket + // InternalBehaviorAnnexParser.g:6309:2: ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) + // InternalBehaviorAnnexParser.g:6310:3: () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket { - // InternalBehaviorAnnexParser.g:6308:3: () - // InternalBehaviorAnnexParser.g:6309:4: + // InternalBehaviorAnnexParser.g:6310:3: () + // InternalBehaviorAnnexParser.g:6311:4: { if ( state.backtracking==0 ) { @@ -18465,18 +18482,18 @@ public final EObject ruleArrayRange() throws RecognitionException { newLeafNode(otherlv_1, grammarAccess.getArrayRangeAccess().getLeftSquareBracketKeyword_1()); } - // InternalBehaviorAnnexParser.g:6319:3: ( (lv_lowerBound_2_0= ruleINTVALUE ) ) - // InternalBehaviorAnnexParser.g:6320:4: (lv_lowerBound_2_0= ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:6321:3: ( (lv_lowerBound_2_0= ruleINTVALUE ) ) + // InternalBehaviorAnnexParser.g:6322:4: (lv_lowerBound_2_0= ruleINTVALUE ) { - // InternalBehaviorAnnexParser.g:6320:4: (lv_lowerBound_2_0= ruleINTVALUE ) - // InternalBehaviorAnnexParser.g:6321:5: lv_lowerBound_2_0= ruleINTVALUE + // InternalBehaviorAnnexParser.g:6322:4: (lv_lowerBound_2_0= ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:6323:5: lv_lowerBound_2_0= ruleINTVALUE { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getArrayRangeAccess().getLowerBoundINTVALUEParserRuleCall_2_0()); } - pushFollow(FollowSets000.FOLLOW_86); + pushFollow(FollowSets000.FOLLOW_87); lv_lowerBound_2_0=ruleINTVALUE(); state._fsp--; @@ -18500,16 +18517,16 @@ public final EObject ruleArrayRange() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6338:3: (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? - int alt107=2; - int LA107_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6340:3: (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? + int alt108=2; + int LA108_0 = input.LA(1); - if ( (LA107_0==FullStopFullStop) ) { - alt107=1; + if ( (LA108_0==FullStopFullStop) ) { + alt108=1; } - switch (alt107) { + switch (alt108) { case 1 : - // InternalBehaviorAnnexParser.g:6339:4: otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) + // InternalBehaviorAnnexParser.g:6341:4: otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) { otherlv_3=(Token)match(input,FullStopFullStop,FollowSets000.FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -18517,11 +18534,11 @@ public final EObject ruleArrayRange() throws RecognitionException { newLeafNode(otherlv_3, grammarAccess.getArrayRangeAccess().getFullStopFullStopKeyword_3_0()); } - // InternalBehaviorAnnexParser.g:6343:4: ( (lv_upperBound_4_0= ruleINTVALUE ) ) - // InternalBehaviorAnnexParser.g:6344:5: (lv_upperBound_4_0= ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:6345:4: ( (lv_upperBound_4_0= ruleINTVALUE ) ) + // InternalBehaviorAnnexParser.g:6346:5: (lv_upperBound_4_0= ruleINTVALUE ) { - // InternalBehaviorAnnexParser.g:6344:5: (lv_upperBound_4_0= ruleINTVALUE ) - // InternalBehaviorAnnexParser.g:6345:6: lv_upperBound_4_0= ruleINTVALUE + // InternalBehaviorAnnexParser.g:6346:5: (lv_upperBound_4_0= ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:6347:6: lv_upperBound_4_0= ruleINTVALUE { if ( state.backtracking==0 ) { @@ -18589,7 +18606,7 @@ public final EObject ruleArrayRange() throws RecognitionException { // $ANTLR start "entryRuleSignedConstant" - // InternalBehaviorAnnexParser.g:6371:1: entryRuleSignedConstant returns [EObject current=null] : iv_ruleSignedConstant= ruleSignedConstant EOF ; + // InternalBehaviorAnnexParser.g:6373:1: entryRuleSignedConstant returns [EObject current=null] : iv_ruleSignedConstant= ruleSignedConstant EOF ; public final EObject entryRuleSignedConstant() throws RecognitionException { EObject current = null; @@ -18597,8 +18614,8 @@ public final EObject entryRuleSignedConstant() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6371:55: (iv_ruleSignedConstant= ruleSignedConstant EOF ) - // InternalBehaviorAnnexParser.g:6372:2: iv_ruleSignedConstant= ruleSignedConstant EOF + // InternalBehaviorAnnexParser.g:6373:55: (iv_ruleSignedConstant= ruleSignedConstant EOF ) + // InternalBehaviorAnnexParser.g:6374:2: iv_ruleSignedConstant= ruleSignedConstant EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSignedConstantRule()); @@ -18629,7 +18646,7 @@ public final EObject entryRuleSignedConstant() throws RecognitionException { // $ANTLR start "ruleSignedConstant" - // InternalBehaviorAnnexParser.g:6378:1: ruleSignedConstant returns [EObject current=null] : ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) ; + // InternalBehaviorAnnexParser.g:6380:1: ruleSignedConstant returns [EObject current=null] : ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) ; public final EObject ruleSignedConstant() throws RecognitionException { EObject current = null; @@ -18642,24 +18659,24 @@ public final EObject ruleSignedConstant() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6384:2: ( ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) ) - // InternalBehaviorAnnexParser.g:6385:2: ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) + // InternalBehaviorAnnexParser.g:6386:2: ( ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) ) + // InternalBehaviorAnnexParser.g:6387:2: ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) { - // InternalBehaviorAnnexParser.g:6385:2: ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) - // InternalBehaviorAnnexParser.g:6386:3: ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) + // InternalBehaviorAnnexParser.g:6387:2: ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) + // InternalBehaviorAnnexParser.g:6388:3: ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) { - // InternalBehaviorAnnexParser.g:6386:3: ( (lv_op_0_0= rulePlusMinus ) ) - // InternalBehaviorAnnexParser.g:6387:4: (lv_op_0_0= rulePlusMinus ) + // InternalBehaviorAnnexParser.g:6388:3: ( (lv_op_0_0= rulePlusMinus ) ) + // InternalBehaviorAnnexParser.g:6389:4: (lv_op_0_0= rulePlusMinus ) { - // InternalBehaviorAnnexParser.g:6387:4: (lv_op_0_0= rulePlusMinus ) - // InternalBehaviorAnnexParser.g:6388:5: lv_op_0_0= rulePlusMinus + // InternalBehaviorAnnexParser.g:6389:4: (lv_op_0_0= rulePlusMinus ) + // InternalBehaviorAnnexParser.g:6390:5: lv_op_0_0= rulePlusMinus { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSignedConstantAccess().getOpPlusMinusParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_87); + pushFollow(FollowSets000.FOLLOW_88); lv_op_0_0=rulePlusMinus(); state._fsp--; @@ -18683,11 +18700,11 @@ public final EObject ruleSignedConstant() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6405:3: ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) - // InternalBehaviorAnnexParser.g:6406:4: (lv_ownedPropertyExpression_1_0= ruleConstantValue ) + // InternalBehaviorAnnexParser.g:6407:3: ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) + // InternalBehaviorAnnexParser.g:6408:4: (lv_ownedPropertyExpression_1_0= ruleConstantValue ) { - // InternalBehaviorAnnexParser.g:6406:4: (lv_ownedPropertyExpression_1_0= ruleConstantValue ) - // InternalBehaviorAnnexParser.g:6407:5: lv_ownedPropertyExpression_1_0= ruleConstantValue + // InternalBehaviorAnnexParser.g:6408:4: (lv_ownedPropertyExpression_1_0= ruleConstantValue ) + // InternalBehaviorAnnexParser.g:6409:5: lv_ownedPropertyExpression_1_0= ruleConstantValue { if ( state.backtracking==0 ) { @@ -18743,7 +18760,7 @@ public final EObject ruleSignedConstant() throws RecognitionException { // $ANTLR start "entryRuleIntegerTerm" - // InternalBehaviorAnnexParser.g:6428:1: entryRuleIntegerTerm returns [EObject current=null] : iv_ruleIntegerTerm= ruleIntegerTerm EOF ; + // InternalBehaviorAnnexParser.g:6430:1: entryRuleIntegerTerm returns [EObject current=null] : iv_ruleIntegerTerm= ruleIntegerTerm EOF ; public final EObject entryRuleIntegerTerm() throws RecognitionException { EObject current = null; @@ -18751,8 +18768,8 @@ public final EObject entryRuleIntegerTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6428:52: (iv_ruleIntegerTerm= ruleIntegerTerm EOF ) - // InternalBehaviorAnnexParser.g:6429:2: iv_ruleIntegerTerm= ruleIntegerTerm EOF + // InternalBehaviorAnnexParser.g:6430:52: (iv_ruleIntegerTerm= ruleIntegerTerm EOF ) + // InternalBehaviorAnnexParser.g:6431:2: iv_ruleIntegerTerm= ruleIntegerTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getIntegerTermRule()); @@ -18783,7 +18800,7 @@ public final EObject entryRuleIntegerTerm() throws RecognitionException { // $ANTLR start "ruleIntegerTerm" - // InternalBehaviorAnnexParser.g:6435:1: ruleIntegerTerm returns [EObject current=null] : ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) ; + // InternalBehaviorAnnexParser.g:6437:1: ruleIntegerTerm returns [EObject current=null] : ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) ; public final EObject ruleIntegerTerm() throws RecognitionException { EObject current = null; @@ -18795,17 +18812,17 @@ public final EObject ruleIntegerTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6441:2: ( ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) ) - // InternalBehaviorAnnexParser.g:6442:2: ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) + // InternalBehaviorAnnexParser.g:6443:2: ( ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) ) + // InternalBehaviorAnnexParser.g:6444:2: ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) { - // InternalBehaviorAnnexParser.g:6442:2: ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) - // InternalBehaviorAnnexParser.g:6443:3: ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? + // InternalBehaviorAnnexParser.g:6444:2: ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) + // InternalBehaviorAnnexParser.g:6445:3: ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? { - // InternalBehaviorAnnexParser.g:6443:3: ( (lv_value_0_0= ruleSignedInt ) ) - // InternalBehaviorAnnexParser.g:6444:4: (lv_value_0_0= ruleSignedInt ) + // InternalBehaviorAnnexParser.g:6445:3: ( (lv_value_0_0= ruleSignedInt ) ) + // InternalBehaviorAnnexParser.g:6446:4: (lv_value_0_0= ruleSignedInt ) { - // InternalBehaviorAnnexParser.g:6444:4: (lv_value_0_0= ruleSignedInt ) - // InternalBehaviorAnnexParser.g:6445:5: lv_value_0_0= ruleSignedInt + // InternalBehaviorAnnexParser.g:6446:4: (lv_value_0_0= ruleSignedInt ) + // InternalBehaviorAnnexParser.g:6447:5: lv_value_0_0= ruleSignedInt { if ( state.backtracking==0 ) { @@ -18836,19 +18853,19 @@ public final EObject ruleIntegerTerm() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6462:3: ( (otherlv_1= RULE_ID ) )? - int alt108=2; - int LA108_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6464:3: ( (otherlv_1= RULE_ID ) )? + int alt109=2; + int LA109_0 = input.LA(1); - if ( (LA108_0==RULE_ID) ) { - alt108=1; + if ( (LA109_0==RULE_ID) ) { + alt109=1; } - switch (alt108) { + switch (alt109) { case 1 : - // InternalBehaviorAnnexParser.g:6463:4: (otherlv_1= RULE_ID ) + // InternalBehaviorAnnexParser.g:6465:4: (otherlv_1= RULE_ID ) { - // InternalBehaviorAnnexParser.g:6463:4: (otherlv_1= RULE_ID ) - // InternalBehaviorAnnexParser.g:6464:5: otherlv_1= RULE_ID + // InternalBehaviorAnnexParser.g:6465:4: (otherlv_1= RULE_ID ) + // InternalBehaviorAnnexParser.g:6466:5: otherlv_1= RULE_ID { if ( state.backtracking==0 ) { @@ -18897,7 +18914,7 @@ public final EObject ruleIntegerTerm() throws RecognitionException { // $ANTLR start "entryRuleSignedInt" - // InternalBehaviorAnnexParser.g:6479:1: entryRuleSignedInt returns [String current=null] : iv_ruleSignedInt= ruleSignedInt EOF ; + // InternalBehaviorAnnexParser.g:6481:1: entryRuleSignedInt returns [String current=null] : iv_ruleSignedInt= ruleSignedInt EOF ; public final String entryRuleSignedInt() throws RecognitionException { String current = null; @@ -18905,8 +18922,8 @@ public final String entryRuleSignedInt() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6479:49: (iv_ruleSignedInt= ruleSignedInt EOF ) - // InternalBehaviorAnnexParser.g:6480:2: iv_ruleSignedInt= ruleSignedInt EOF + // InternalBehaviorAnnexParser.g:6481:49: (iv_ruleSignedInt= ruleSignedInt EOF ) + // InternalBehaviorAnnexParser.g:6482:2: iv_ruleSignedInt= ruleSignedInt EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSignedIntRule()); @@ -18937,7 +18954,7 @@ public final String entryRuleSignedInt() throws RecognitionException { // $ANTLR start "ruleSignedInt" - // InternalBehaviorAnnexParser.g:6486:1: ruleSignedInt returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) ; + // InternalBehaviorAnnexParser.g:6488:1: ruleSignedInt returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) ; public final AntlrDatatypeRuleToken ruleSignedInt() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -18948,25 +18965,25 @@ public final AntlrDatatypeRuleToken ruleSignedInt() throws RecognitionException enterRule(); try { - // InternalBehaviorAnnexParser.g:6492:2: ( ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:6493:2: ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:6494:2: ( ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:6495:2: ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) { - // InternalBehaviorAnnexParser.g:6493:2: ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:6494:3: (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:6495:2: ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:6496:3: (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT { - // InternalBehaviorAnnexParser.g:6494:3: (kw= PlusSign | kw= HyphenMinus )? - int alt109=3; - int LA109_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6496:3: (kw= PlusSign | kw= HyphenMinus )? + int alt110=3; + int LA110_0 = input.LA(1); - if ( (LA109_0==PlusSign) ) { - alt109=1; + if ( (LA110_0==PlusSign) ) { + alt110=1; } - else if ( (LA109_0==HyphenMinus) ) { - alt109=2; + else if ( (LA110_0==HyphenMinus) ) { + alt110=2; } - switch (alt109) { + switch (alt110) { case 1 : - // InternalBehaviorAnnexParser.g:6495:4: kw= PlusSign + // InternalBehaviorAnnexParser.g:6497:4: kw= PlusSign { kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -18979,7 +18996,7 @@ else if ( (LA109_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:6501:4: kw= HyphenMinus + // InternalBehaviorAnnexParser.g:6503:4: kw= HyphenMinus { kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -19030,7 +19047,7 @@ else if ( (LA109_0==HyphenMinus) ) { // $ANTLR start "entryRuleRealTerm" - // InternalBehaviorAnnexParser.g:6518:1: entryRuleRealTerm returns [EObject current=null] : iv_ruleRealTerm= ruleRealTerm EOF ; + // InternalBehaviorAnnexParser.g:6520:1: entryRuleRealTerm returns [EObject current=null] : iv_ruleRealTerm= ruleRealTerm EOF ; public final EObject entryRuleRealTerm() throws RecognitionException { EObject current = null; @@ -19038,8 +19055,8 @@ public final EObject entryRuleRealTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6518:49: (iv_ruleRealTerm= ruleRealTerm EOF ) - // InternalBehaviorAnnexParser.g:6519:2: iv_ruleRealTerm= ruleRealTerm EOF + // InternalBehaviorAnnexParser.g:6520:49: (iv_ruleRealTerm= ruleRealTerm EOF ) + // InternalBehaviorAnnexParser.g:6521:2: iv_ruleRealTerm= ruleRealTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getRealTermRule()); @@ -19070,7 +19087,7 @@ public final EObject entryRuleRealTerm() throws RecognitionException { // $ANTLR start "ruleRealTerm" - // InternalBehaviorAnnexParser.g:6525:1: ruleRealTerm returns [EObject current=null] : ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) ; + // InternalBehaviorAnnexParser.g:6527:1: ruleRealTerm returns [EObject current=null] : ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) ; public final EObject ruleRealTerm() throws RecognitionException { EObject current = null; @@ -19082,17 +19099,17 @@ public final EObject ruleRealTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6531:2: ( ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) ) - // InternalBehaviorAnnexParser.g:6532:2: ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) + // InternalBehaviorAnnexParser.g:6533:2: ( ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) ) + // InternalBehaviorAnnexParser.g:6534:2: ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) { - // InternalBehaviorAnnexParser.g:6532:2: ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) - // InternalBehaviorAnnexParser.g:6533:3: ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? + // InternalBehaviorAnnexParser.g:6534:2: ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) + // InternalBehaviorAnnexParser.g:6535:3: ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? { - // InternalBehaviorAnnexParser.g:6533:3: ( (lv_value_0_0= ruleSignedReal ) ) - // InternalBehaviorAnnexParser.g:6534:4: (lv_value_0_0= ruleSignedReal ) + // InternalBehaviorAnnexParser.g:6535:3: ( (lv_value_0_0= ruleSignedReal ) ) + // InternalBehaviorAnnexParser.g:6536:4: (lv_value_0_0= ruleSignedReal ) { - // InternalBehaviorAnnexParser.g:6534:4: (lv_value_0_0= ruleSignedReal ) - // InternalBehaviorAnnexParser.g:6535:5: lv_value_0_0= ruleSignedReal + // InternalBehaviorAnnexParser.g:6536:4: (lv_value_0_0= ruleSignedReal ) + // InternalBehaviorAnnexParser.g:6537:5: lv_value_0_0= ruleSignedReal { if ( state.backtracking==0 ) { @@ -19123,19 +19140,19 @@ public final EObject ruleRealTerm() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6552:3: ( (otherlv_1= RULE_ID ) )? - int alt110=2; - int LA110_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6554:3: ( (otherlv_1= RULE_ID ) )? + int alt111=2; + int LA111_0 = input.LA(1); - if ( (LA110_0==RULE_ID) ) { - alt110=1; + if ( (LA111_0==RULE_ID) ) { + alt111=1; } - switch (alt110) { + switch (alt111) { case 1 : - // InternalBehaviorAnnexParser.g:6553:4: (otherlv_1= RULE_ID ) + // InternalBehaviorAnnexParser.g:6555:4: (otherlv_1= RULE_ID ) { - // InternalBehaviorAnnexParser.g:6553:4: (otherlv_1= RULE_ID ) - // InternalBehaviorAnnexParser.g:6554:5: otherlv_1= RULE_ID + // InternalBehaviorAnnexParser.g:6555:4: (otherlv_1= RULE_ID ) + // InternalBehaviorAnnexParser.g:6556:5: otherlv_1= RULE_ID { if ( state.backtracking==0 ) { @@ -19184,7 +19201,7 @@ public final EObject ruleRealTerm() throws RecognitionException { // $ANTLR start "entryRuleSignedReal" - // InternalBehaviorAnnexParser.g:6569:1: entryRuleSignedReal returns [String current=null] : iv_ruleSignedReal= ruleSignedReal EOF ; + // InternalBehaviorAnnexParser.g:6571:1: entryRuleSignedReal returns [String current=null] : iv_ruleSignedReal= ruleSignedReal EOF ; public final String entryRuleSignedReal() throws RecognitionException { String current = null; @@ -19192,8 +19209,8 @@ public final String entryRuleSignedReal() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6569:50: (iv_ruleSignedReal= ruleSignedReal EOF ) - // InternalBehaviorAnnexParser.g:6570:2: iv_ruleSignedReal= ruleSignedReal EOF + // InternalBehaviorAnnexParser.g:6571:50: (iv_ruleSignedReal= ruleSignedReal EOF ) + // InternalBehaviorAnnexParser.g:6572:2: iv_ruleSignedReal= ruleSignedReal EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSignedRealRule()); @@ -19224,7 +19241,7 @@ public final String entryRuleSignedReal() throws RecognitionException { // $ANTLR start "ruleSignedReal" - // InternalBehaviorAnnexParser.g:6576:1: ruleSignedReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) ; + // InternalBehaviorAnnexParser.g:6578:1: ruleSignedReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) ; public final AntlrDatatypeRuleToken ruleSignedReal() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -19235,27 +19252,27 @@ public final AntlrDatatypeRuleToken ruleSignedReal() throws RecognitionException enterRule(); try { - // InternalBehaviorAnnexParser.g:6582:2: ( ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) ) - // InternalBehaviorAnnexParser.g:6583:2: ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:6584:2: ( ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) ) + // InternalBehaviorAnnexParser.g:6585:2: ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) { - // InternalBehaviorAnnexParser.g:6583:2: ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) - // InternalBehaviorAnnexParser.g:6584:3: (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT + // InternalBehaviorAnnexParser.g:6585:2: ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:6586:3: (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT { - // InternalBehaviorAnnexParser.g:6584:3: (kw= PlusSign | kw= HyphenMinus )? - int alt111=3; - int LA111_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6586:3: (kw= PlusSign | kw= HyphenMinus )? + int alt112=3; + int LA112_0 = input.LA(1); - if ( (LA111_0==PlusSign) ) { - alt111=1; + if ( (LA112_0==PlusSign) ) { + alt112=1; } - else if ( (LA111_0==HyphenMinus) ) { - alt111=2; + else if ( (LA112_0==HyphenMinus) ) { + alt112=2; } - switch (alt111) { + switch (alt112) { case 1 : - // InternalBehaviorAnnexParser.g:6585:4: kw= PlusSign + // InternalBehaviorAnnexParser.g:6587:4: kw= PlusSign { - kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_88); if (state.failed) return current; + kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_89); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(kw); @@ -19266,9 +19283,9 @@ else if ( (LA111_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:6591:4: kw= HyphenMinus + // InternalBehaviorAnnexParser.g:6593:4: kw= HyphenMinus { - kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_88); if (state.failed) return current; + kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_89); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(kw); @@ -19317,7 +19334,7 @@ else if ( (LA111_0==HyphenMinus) ) { // $ANTLR start "entryRuleNumericRangeTerm" - // InternalBehaviorAnnexParser.g:6608:1: entryRuleNumericRangeTerm returns [EObject current=null] : iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF ; + // InternalBehaviorAnnexParser.g:6610:1: entryRuleNumericRangeTerm returns [EObject current=null] : iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF ; public final EObject entryRuleNumericRangeTerm() throws RecognitionException { EObject current = null; @@ -19325,8 +19342,8 @@ public final EObject entryRuleNumericRangeTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6608:57: (iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF ) - // InternalBehaviorAnnexParser.g:6609:2: iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF + // InternalBehaviorAnnexParser.g:6610:57: (iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF ) + // InternalBehaviorAnnexParser.g:6611:2: iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNumericRangeTermRule()); @@ -19357,7 +19374,7 @@ public final EObject entryRuleNumericRangeTerm() throws RecognitionException { // $ANTLR start "ruleNumericRangeTerm" - // InternalBehaviorAnnexParser.g:6615:1: ruleNumericRangeTerm returns [EObject current=null] : ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) ; + // InternalBehaviorAnnexParser.g:6617:1: ruleNumericRangeTerm returns [EObject current=null] : ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) ; public final EObject ruleNumericRangeTerm() throws RecognitionException { EObject current = null; @@ -19374,24 +19391,24 @@ public final EObject ruleNumericRangeTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6621:2: ( ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) ) - // InternalBehaviorAnnexParser.g:6622:2: ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) + // InternalBehaviorAnnexParser.g:6623:2: ( ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) ) + // InternalBehaviorAnnexParser.g:6624:2: ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) { - // InternalBehaviorAnnexParser.g:6622:2: ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) - // InternalBehaviorAnnexParser.g:6623:3: ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? + // InternalBehaviorAnnexParser.g:6624:2: ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) + // InternalBehaviorAnnexParser.g:6625:3: ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? { - // InternalBehaviorAnnexParser.g:6623:3: ( (lv_minimum_0_0= ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:6624:4: (lv_minimum_0_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6625:3: ( (lv_minimum_0_0= ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:6626:4: (lv_minimum_0_0= ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:6624:4: (lv_minimum_0_0= ruleNumAlt ) - // InternalBehaviorAnnexParser.g:6625:5: lv_minimum_0_0= ruleNumAlt + // InternalBehaviorAnnexParser.g:6626:4: (lv_minimum_0_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6627:5: lv_minimum_0_0= ruleNumAlt { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNumericRangeTermAccess().getMinimumNumAltParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_89); + pushFollow(FollowSets000.FOLLOW_90); lv_minimum_0_0=ruleNumAlt(); state._fsp--; @@ -19415,24 +19432,24 @@ public final EObject ruleNumericRangeTerm() throws RecognitionException { } - otherlv_1=(Token)match(input,FullStopFullStop,FollowSets000.FOLLOW_87); if (state.failed) return current; + otherlv_1=(Token)match(input,FullStopFullStop,FollowSets000.FOLLOW_88); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getNumericRangeTermAccess().getFullStopFullStopKeyword_1()); } - // InternalBehaviorAnnexParser.g:6646:3: ( (lv_maximum_2_0= ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:6647:4: (lv_maximum_2_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6648:3: ( (lv_maximum_2_0= ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:6649:4: (lv_maximum_2_0= ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:6647:4: (lv_maximum_2_0= ruleNumAlt ) - // InternalBehaviorAnnexParser.g:6648:5: lv_maximum_2_0= ruleNumAlt + // InternalBehaviorAnnexParser.g:6649:4: (lv_maximum_2_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6650:5: lv_maximum_2_0= ruleNumAlt { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNumericRangeTermAccess().getMaximumNumAltParserRuleCall_2_0()); } - pushFollow(FollowSets000.FOLLOW_90); + pushFollow(FollowSets000.FOLLOW_91); lv_maximum_2_0=ruleNumAlt(); state._fsp--; @@ -19456,28 +19473,28 @@ public final EObject ruleNumericRangeTerm() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6665:3: (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? - int alt112=2; - int LA112_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6667:3: (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? + int alt113=2; + int LA113_0 = input.LA(1); - if ( (LA112_0==Delta) ) { - alt112=1; + if ( (LA113_0==Delta) ) { + alt113=1; } - switch (alt112) { + switch (alt113) { case 1 : - // InternalBehaviorAnnexParser.g:6666:4: otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:6668:4: otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) { - otherlv_3=(Token)match(input,Delta,FollowSets000.FOLLOW_87); if (state.failed) return current; + otherlv_3=(Token)match(input,Delta,FollowSets000.FOLLOW_88); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getNumericRangeTermAccess().getDeltaKeyword_3_0()); } - // InternalBehaviorAnnexParser.g:6670:4: ( (lv_delta_4_0= ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:6671:5: (lv_delta_4_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6672:4: ( (lv_delta_4_0= ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:6673:5: (lv_delta_4_0= ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:6671:5: (lv_delta_4_0= ruleNumAlt ) - // InternalBehaviorAnnexParser.g:6672:6: lv_delta_4_0= ruleNumAlt + // InternalBehaviorAnnexParser.g:6673:5: (lv_delta_4_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6674:6: lv_delta_4_0= ruleNumAlt { if ( state.backtracking==0 ) { @@ -19539,7 +19556,7 @@ public final EObject ruleNumericRangeTerm() throws RecognitionException { // $ANTLR start "entryRuleNumAlt" - // InternalBehaviorAnnexParser.g:6694:1: entryRuleNumAlt returns [EObject current=null] : iv_ruleNumAlt= ruleNumAlt EOF ; + // InternalBehaviorAnnexParser.g:6696:1: entryRuleNumAlt returns [EObject current=null] : iv_ruleNumAlt= ruleNumAlt EOF ; public final EObject entryRuleNumAlt() throws RecognitionException { EObject current = null; @@ -19547,8 +19564,8 @@ public final EObject entryRuleNumAlt() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6694:47: (iv_ruleNumAlt= ruleNumAlt EOF ) - // InternalBehaviorAnnexParser.g:6695:2: iv_ruleNumAlt= ruleNumAlt EOF + // InternalBehaviorAnnexParser.g:6696:47: (iv_ruleNumAlt= ruleNumAlt EOF ) + // InternalBehaviorAnnexParser.g:6697:2: iv_ruleNumAlt= ruleNumAlt EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNumAltRule()); @@ -19579,7 +19596,7 @@ public final EObject entryRuleNumAlt() throws RecognitionException { // $ANTLR start "ruleNumAlt" - // InternalBehaviorAnnexParser.g:6701:1: ruleNumAlt returns [EObject current=null] : (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) ; + // InternalBehaviorAnnexParser.g:6703:1: ruleNumAlt returns [EObject current=null] : (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) ; public final EObject ruleNumAlt() throws RecognitionException { EObject current = null; @@ -19596,34 +19613,34 @@ public final EObject ruleNumAlt() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6707:2: ( (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) ) - // InternalBehaviorAnnexParser.g:6708:2: (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) + // InternalBehaviorAnnexParser.g:6709:2: ( (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) ) + // InternalBehaviorAnnexParser.g:6710:2: (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) { - // InternalBehaviorAnnexParser.g:6708:2: (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) - int alt113=4; + // InternalBehaviorAnnexParser.g:6710:2: (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) + int alt114=4; switch ( input.LA(1) ) { case PlusSign: { switch ( input.LA(2) ) { - case RULE_REAL_LIT: + case RULE_ID: { - alt113=1; + alt114=3; } break; - case RULE_INTEGER_LIT: + case RULE_REAL_LIT: { - alt113=2; + alt114=1; } break; - case RULE_ID: + case RULE_INTEGER_LIT: { - alt113=3; + alt114=2; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 113, 1, input); + new NoViableAltException("", 114, 1, input); throw nvae; } @@ -19633,25 +19650,25 @@ public final EObject ruleNumAlt() throws RecognitionException { case HyphenMinus: { switch ( input.LA(2) ) { - case RULE_REAL_LIT: + case RULE_ID: { - alt113=1; + alt114=3; } break; - case RULE_INTEGER_LIT: + case RULE_REAL_LIT: { - alt113=2; + alt114=1; } break; - case RULE_ID: + case RULE_INTEGER_LIT: { - alt113=3; + alt114=2; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 113, 2, input); + new NoViableAltException("", 114, 2, input); throw nvae; } @@ -19660,30 +19677,30 @@ public final EObject ruleNumAlt() throws RecognitionException { break; case RULE_REAL_LIT: { - alt113=1; + alt114=1; } break; case RULE_INTEGER_LIT: { - alt113=2; + alt114=2; } break; case RULE_ID: { - alt113=4; + alt114=4; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 113, 0, input); + new NoViableAltException("", 114, 0, input); throw nvae; } - switch (alt113) { + switch (alt114) { case 1 : - // InternalBehaviorAnnexParser.g:6709:3: this_RealTerm_0= ruleRealTerm + // InternalBehaviorAnnexParser.g:6711:3: this_RealTerm_0= ruleRealTerm { if ( state.backtracking==0 ) { @@ -19705,7 +19722,7 @@ public final EObject ruleNumAlt() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:6718:3: this_IntegerTerm_1= ruleIntegerTerm + // InternalBehaviorAnnexParser.g:6720:3: this_IntegerTerm_1= ruleIntegerTerm { if ( state.backtracking==0 ) { @@ -19727,7 +19744,7 @@ public final EObject ruleNumAlt() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:6727:3: this_SignedConstant_2= ruleSignedConstant + // InternalBehaviorAnnexParser.g:6729:3: this_SignedConstant_2= ruleSignedConstant { if ( state.backtracking==0 ) { @@ -19749,7 +19766,7 @@ public final EObject ruleNumAlt() throws RecognitionException { } break; case 4 : - // InternalBehaviorAnnexParser.g:6736:3: this_ConstantValue_3= ruleConstantValue + // InternalBehaviorAnnexParser.g:6738:3: this_ConstantValue_3= ruleConstantValue { if ( state.backtracking==0 ) { @@ -19795,7 +19812,7 @@ public final EObject ruleNumAlt() throws RecognitionException { // $ANTLR start "entryRuleINTVALUE" - // InternalBehaviorAnnexParser.g:6748:1: entryRuleINTVALUE returns [String current=null] : iv_ruleINTVALUE= ruleINTVALUE EOF ; + // InternalBehaviorAnnexParser.g:6750:1: entryRuleINTVALUE returns [String current=null] : iv_ruleINTVALUE= ruleINTVALUE EOF ; public final String entryRuleINTVALUE() throws RecognitionException { String current = null; @@ -19803,8 +19820,8 @@ public final String entryRuleINTVALUE() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6748:48: (iv_ruleINTVALUE= ruleINTVALUE EOF ) - // InternalBehaviorAnnexParser.g:6749:2: iv_ruleINTVALUE= ruleINTVALUE EOF + // InternalBehaviorAnnexParser.g:6750:48: (iv_ruleINTVALUE= ruleINTVALUE EOF ) + // InternalBehaviorAnnexParser.g:6751:2: iv_ruleINTVALUE= ruleINTVALUE EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getINTVALUERule()); @@ -19835,7 +19852,7 @@ public final String entryRuleINTVALUE() throws RecognitionException { // $ANTLR start "ruleINTVALUE" - // InternalBehaviorAnnexParser.g:6755:1: ruleINTVALUE returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_INTEGER_LIT_0= RULE_INTEGER_LIT ; + // InternalBehaviorAnnexParser.g:6757:1: ruleINTVALUE returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_INTEGER_LIT_0= RULE_INTEGER_LIT ; public final AntlrDatatypeRuleToken ruleINTVALUE() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -19845,8 +19862,8 @@ public final AntlrDatatypeRuleToken ruleINTVALUE() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6761:2: (this_INTEGER_LIT_0= RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:6762:2: this_INTEGER_LIT_0= RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:6763:2: (this_INTEGER_LIT_0= RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:6764:2: this_INTEGER_LIT_0= RULE_INTEGER_LIT { this_INTEGER_LIT_0=(Token)match(input,RULE_INTEGER_LIT,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -19881,7 +19898,7 @@ public final AntlrDatatypeRuleToken ruleINTVALUE() throws RecognitionException { // $ANTLR start "entryRuleQPREF" - // InternalBehaviorAnnexParser.g:6772:1: entryRuleQPREF returns [String current=null] : iv_ruleQPREF= ruleQPREF EOF ; + // InternalBehaviorAnnexParser.g:6774:1: entryRuleQPREF returns [String current=null] : iv_ruleQPREF= ruleQPREF EOF ; public final String entryRuleQPREF() throws RecognitionException { String current = null; @@ -19889,8 +19906,8 @@ public final String entryRuleQPREF() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6772:45: (iv_ruleQPREF= ruleQPREF EOF ) - // InternalBehaviorAnnexParser.g:6773:2: iv_ruleQPREF= ruleQPREF EOF + // InternalBehaviorAnnexParser.g:6774:45: (iv_ruleQPREF= ruleQPREF EOF ) + // InternalBehaviorAnnexParser.g:6775:2: iv_ruleQPREF= ruleQPREF EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getQPREFRule()); @@ -19921,7 +19938,7 @@ public final String entryRuleQPREF() throws RecognitionException { // $ANTLR start "ruleQPREF" - // InternalBehaviorAnnexParser.g:6779:1: ruleQPREF returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) ; + // InternalBehaviorAnnexParser.g:6781:1: ruleQPREF returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) ; public final AntlrDatatypeRuleToken ruleQPREF() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -19933,13 +19950,13 @@ public final AntlrDatatypeRuleToken ruleQPREF() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6785:2: ( (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) ) - // InternalBehaviorAnnexParser.g:6786:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) + // InternalBehaviorAnnexParser.g:6787:2: ( (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) ) + // InternalBehaviorAnnexParser.g:6788:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) { - // InternalBehaviorAnnexParser.g:6786:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) - // InternalBehaviorAnnexParser.g:6787:3: this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? + // InternalBehaviorAnnexParser.g:6788:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) + // InternalBehaviorAnnexParser.g:6789:3: this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? { - this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_77); if (state.failed) return current; + this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_78); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(this_ID_0); @@ -19950,16 +19967,16 @@ public final AntlrDatatypeRuleToken ruleQPREF() throws RecognitionException { newLeafNode(this_ID_0, grammarAccess.getQPREFAccess().getIDTerminalRuleCall_0()); } - // InternalBehaviorAnnexParser.g:6794:3: (kw= ColonColon this_ID_2= RULE_ID )? - int alt114=2; - int LA114_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6796:3: (kw= ColonColon this_ID_2= RULE_ID )? + int alt115=2; + int LA115_0 = input.LA(1); - if ( (LA114_0==ColonColon) ) { - alt114=1; + if ( (LA115_0==ColonColon) ) { + alt115=1; } - switch (alt114) { + switch (alt115) { case 1 : - // InternalBehaviorAnnexParser.g:6795:4: kw= ColonColon this_ID_2= RULE_ID + // InternalBehaviorAnnexParser.g:6797:4: kw= ColonColon this_ID_2= RULE_ID { kw=(Token)match(input,ColonColon,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -20010,7 +20027,7 @@ public final AntlrDatatypeRuleToken ruleQPREF() throws RecognitionException { // $ANTLR start "entryRuleQCREF" - // InternalBehaviorAnnexParser.g:6812:1: entryRuleQCREF returns [String current=null] : iv_ruleQCREF= ruleQCREF EOF ; + // InternalBehaviorAnnexParser.g:6814:1: entryRuleQCREF returns [String current=null] : iv_ruleQCREF= ruleQCREF EOF ; public final String entryRuleQCREF() throws RecognitionException { String current = null; @@ -20018,8 +20035,8 @@ public final String entryRuleQCREF() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6812:45: (iv_ruleQCREF= ruleQCREF EOF ) - // InternalBehaviorAnnexParser.g:6813:2: iv_ruleQCREF= ruleQCREF EOF + // InternalBehaviorAnnexParser.g:6814:45: (iv_ruleQCREF= ruleQCREF EOF ) + // InternalBehaviorAnnexParser.g:6815:2: iv_ruleQCREF= ruleQCREF EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getQCREFRule()); @@ -20050,7 +20067,7 @@ public final String entryRuleQCREF() throws RecognitionException { // $ANTLR start "ruleQCREF" - // InternalBehaviorAnnexParser.g:6819:1: ruleQCREF returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) ; + // InternalBehaviorAnnexParser.g:6821:1: ruleQCREF returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) ; public final AntlrDatatypeRuleToken ruleQCREF() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -20063,34 +20080,34 @@ public final AntlrDatatypeRuleToken ruleQCREF() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6825:2: ( ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) ) - // InternalBehaviorAnnexParser.g:6826:2: ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) + // InternalBehaviorAnnexParser.g:6827:2: ( ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) ) + // InternalBehaviorAnnexParser.g:6828:2: ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) { - // InternalBehaviorAnnexParser.g:6826:2: ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) - // InternalBehaviorAnnexParser.g:6827:3: (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? + // InternalBehaviorAnnexParser.g:6828:2: ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) + // InternalBehaviorAnnexParser.g:6829:3: (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? { - // InternalBehaviorAnnexParser.g:6827:3: (this_ID_0= RULE_ID kw= ColonColon )* - loop115: + // InternalBehaviorAnnexParser.g:6829:3: (this_ID_0= RULE_ID kw= ColonColon )* + loop116: do { - int alt115=2; - int LA115_0 = input.LA(1); + int alt116=2; + int LA116_0 = input.LA(1); - if ( (LA115_0==RULE_ID) ) { - int LA115_1 = input.LA(2); + if ( (LA116_0==RULE_ID) ) { + int LA116_1 = input.LA(2); - if ( (LA115_1==ColonColon) ) { - alt115=1; + if ( (LA116_1==ColonColon) ) { + alt116=1; } } - switch (alt115) { + switch (alt116) { case 1 : - // InternalBehaviorAnnexParser.g:6828:4: this_ID_0= RULE_ID kw= ColonColon + // InternalBehaviorAnnexParser.g:6830:4: this_ID_0= RULE_ID kw= ColonColon { - this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_91); if (state.failed) return current; + this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_92); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(this_ID_0); @@ -20113,11 +20130,11 @@ public final AntlrDatatypeRuleToken ruleQCREF() throws RecognitionException { break; default : - break loop115; + break loop116; } } while (true); - this_ID_2=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_73); if (state.failed) return current; + this_ID_2=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_74); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(this_ID_2); @@ -20128,16 +20145,16 @@ public final AntlrDatatypeRuleToken ruleQCREF() throws RecognitionException { newLeafNode(this_ID_2, grammarAccess.getQCREFAccess().getIDTerminalRuleCall_1()); } - // InternalBehaviorAnnexParser.g:6848:3: (kw= FullStop this_ID_4= RULE_ID )? - int alt116=2; - int LA116_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6850:3: (kw= FullStop this_ID_4= RULE_ID )? + int alt117=2; + int LA117_0 = input.LA(1); - if ( (LA116_0==FullStop) ) { - alt116=1; + if ( (LA117_0==FullStop) ) { + alt117=1; } - switch (alt116) { + switch (alt117) { case 1 : - // InternalBehaviorAnnexParser.g:6849:4: kw= FullStop this_ID_4= RULE_ID + // InternalBehaviorAnnexParser.g:6851:4: kw= FullStop this_ID_4= RULE_ID { kw=(Token)match(input,FullStop,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -20188,7 +20205,7 @@ public final AntlrDatatypeRuleToken ruleQCREF() throws RecognitionException { // $ANTLR start "entryRuleSTAR" - // InternalBehaviorAnnexParser.g:6866:1: entryRuleSTAR returns [String current=null] : iv_ruleSTAR= ruleSTAR EOF ; + // InternalBehaviorAnnexParser.g:6868:1: entryRuleSTAR returns [String current=null] : iv_ruleSTAR= ruleSTAR EOF ; public final String entryRuleSTAR() throws RecognitionException { String current = null; @@ -20196,8 +20213,8 @@ public final String entryRuleSTAR() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6866:44: (iv_ruleSTAR= ruleSTAR EOF ) - // InternalBehaviorAnnexParser.g:6867:2: iv_ruleSTAR= ruleSTAR EOF + // InternalBehaviorAnnexParser.g:6868:44: (iv_ruleSTAR= ruleSTAR EOF ) + // InternalBehaviorAnnexParser.g:6869:2: iv_ruleSTAR= ruleSTAR EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSTARRule()); @@ -20228,7 +20245,7 @@ public final String entryRuleSTAR() throws RecognitionException { // $ANTLR start "ruleSTAR" - // InternalBehaviorAnnexParser.g:6873:1: ruleSTAR returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= Asterisk ; + // InternalBehaviorAnnexParser.g:6875:1: ruleSTAR returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= Asterisk ; public final AntlrDatatypeRuleToken ruleSTAR() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -20238,8 +20255,8 @@ public final AntlrDatatypeRuleToken ruleSTAR() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6879:2: (kw= Asterisk ) - // InternalBehaviorAnnexParser.g:6880:2: kw= Asterisk + // InternalBehaviorAnnexParser.g:6881:2: (kw= Asterisk ) + // InternalBehaviorAnnexParser.g:6882:2: kw= Asterisk { kw=(Token)match(input,Asterisk,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -20302,7 +20319,7 @@ public final boolean synpred1_InternalBehaviorAnnexParser() { protected DFA41 dfa41 = new DFA41(this); - protected DFA99 dfa99 = new DFA99(this); + protected DFA100 dfa100 = new DFA100(this); static final String dfa_1s = "\13\uffff"; static final String dfa_2s = "\1\4\1\0\11\uffff"; static final String dfa_3s = "\1\141\1\0\11\uffff"; @@ -20410,11 +20427,11 @@ public int specialStateTransition(int s, IntStream _input) throws NoViableAltExc static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s); - class DFA99 extends DFA { + class DFA100 extends DFA { - public DFA99(BaseRecognizer recognizer) { + public DFA100(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 99; + this.decisionNumber = 100; this.eot = dfa_7; this.eof = dfa_8; this.min = dfa_9; @@ -20424,7 +20441,7 @@ public DFA99(BaseRecognizer recognizer) { this.transition = dfa_13; } public String getDescription() { - return "5578:2: (this_RecordTerm_0= ruleRecordTerm | this_ReferenceTerm_1= ruleReferenceTerm | this_ComponentClassifierTerm_2= ruleComponentClassifierTerm | this_ComputedTerm_3= ruleComputedTerm | this_StringTerm_4= ruleStringTerm | this_NumericRangeTerm_5= ruleNumericRangeTerm | this_RealTerm_6= ruleRealTerm | this_IntegerTerm_7= ruleIntegerTerm | this_ListTerm_8= ruleListTerm | this_BooleanLiteral_9= ruleBooleanLiteral | this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm )"; + return "5580:2: (this_RecordTerm_0= ruleRecordTerm | this_ReferenceTerm_1= ruleReferenceTerm | this_ComponentClassifierTerm_2= ruleComponentClassifierTerm | this_ComputedTerm_3= ruleComputedTerm | this_StringTerm_4= ruleStringTerm | this_NumericRangeTerm_5= ruleNumericRangeTerm | this_RealTerm_6= ruleRealTerm | this_IntegerTerm_7= ruleIntegerTerm | this_ListTerm_8= ruleListTerm | this_BooleanLiteral_9= ruleBooleanLiteral | this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm )"; } } @@ -20488,40 +20505,41 @@ private static class FollowSets000 { public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000040202000000L}); public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000040000000000L}); public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x2000000000000000L}); - public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x4000000000000000L}); - public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); - public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000080000000L}); - public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0020000000000002L}); - public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000810000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000200000002L}); - public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000800000002L}); - public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0502000000000002L,0x0000000000070000L}); - public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000A00L}); - public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000500000000002L,0x0000000000002100L}); - public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0008000000000002L}); - public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000001004000000L,0x0000000350000048L}); - public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080028L}); - public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000010880000L}); - public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000002L,0x0000000000101000L}); - public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001000L}); - public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000240000008L}); - public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080020L}); - public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0040000000000002L,0x0000000000001000L}); - public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0040000000000002L}); - public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0200002000000000L}); - public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000001004010940L,0x0000000350100A40L}); - public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x4000000000004000L,0x0000000000008400L}); - public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); - public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x4000000000000000L,0x0000000000008400L}); - public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000020000000L}); - public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000000000000000L,0x0000000200200000L}); - public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000001004010140L,0x0000000350100AC0L}); - public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0020000000000000L,0x0000000000200000L}); - public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000000000000L,0x0000000250000A00L}); - public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); - public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0020000000000000L}); - public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000001000002L}); - public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0040000000000000L}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x4000000000000000L,0x0000000000004000L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x4000000000000000L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000080000000L}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0020000000000002L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000810000000002L,0x0000000000000001L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000200000002L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000800000002L}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0502000000000002L,0x0000000000070000L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000A00L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000500000000002L,0x0000000000002100L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0008000000000002L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000001004000000L,0x0000000350000048L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080028L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000010880000L}); + public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000002L,0x0000000000101000L}); + public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001000L}); + public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000000L,0x0000000240000008L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080020L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0040000000000002L,0x0000000000001000L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0040000000000002L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0200002000000000L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000001004010940L,0x0000000350100A40L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x4000000000004000L,0x0000000000008400L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x4000000000000000L,0x0000000000008400L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000000020000000L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000000000L,0x0000000200200000L}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000001004010140L,0x0000000350100AC0L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0020000000000000L,0x0000000000200000L}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000000000L,0x0000000250000A00L}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0020000000000000L}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000000001000002L}); + public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0040000000000000L}); } diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/serializer/AbstractBehaviorAnnexSemanticSequencer.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/serializer/AbstractBehaviorAnnexSemanticSequencer.java index 2923fd0936..a22d785e49 100644 --- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/serializer/AbstractBehaviorAnnexSemanticSequencer.java +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/serializer/AbstractBehaviorAnnexSemanticSequencer.java @@ -1129,7 +1129,7 @@ protected void sequence_Factor(ISerializationContext context, UnaryExpression se * ForStatement returns ForStatement * * Constraint: - * ((for?='for' | forall?='forall') variable=ID dataClassifier=[ComponentClassifier|QCREF] values=ElementValues actions=BehaviorActions) + * ((for?='for' | forall?='forall') variable=ID dataClassifier=[ComponentClassifier|QCREF]? values=ElementValues actions=BehaviorActions) * */ protected void sequence_ForStatement(ISerializationContext context, ForStatement semanticObject) { diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/services/BehaviorAnnexGrammarAccess.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/services/BehaviorAnnexGrammarAccess.java index 2e80e685a9..fc9f0041f1 100644 --- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/services/BehaviorAnnexGrammarAccess.java +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/services/BehaviorAnnexGrammarAccess.java @@ -1733,29 +1733,32 @@ public class ForStatementElements extends AbstractParserRuleElementFinder { private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1); private final Assignment cVariableAssignment_2 = (Assignment)cGroup.eContents().get(2); private final RuleCall cVariableIDTerminalRuleCall_2_0 = (RuleCall)cVariableAssignment_2.eContents().get(0); - private final Keyword cColonKeyword_3 = (Keyword)cGroup.eContents().get(3); - private final Assignment cDataClassifierAssignment_4 = (Assignment)cGroup.eContents().get(4); - private final CrossReference cDataClassifierComponentClassifierCrossReference_4_0 = (CrossReference)cDataClassifierAssignment_4.eContents().get(0); - private final RuleCall cDataClassifierComponentClassifierQCREFParserRuleCall_4_0_1 = (RuleCall)cDataClassifierComponentClassifierCrossReference_4_0.eContents().get(1); - private final Keyword cInKeyword_5 = (Keyword)cGroup.eContents().get(5); - private final Assignment cValuesAssignment_6 = (Assignment)cGroup.eContents().get(6); - private final RuleCall cValuesElementValuesParserRuleCall_6_0 = (RuleCall)cValuesAssignment_6.eContents().get(0); - private final Keyword cRightParenthesisKeyword_7 = (Keyword)cGroup.eContents().get(7); - private final Keyword cLeftCurlyBracketKeyword_8 = (Keyword)cGroup.eContents().get(8); - private final Assignment cActionsAssignment_9 = (Assignment)cGroup.eContents().get(9); - private final RuleCall cActionsBehaviorActionsParserRuleCall_9_0 = (RuleCall)cActionsAssignment_9.eContents().get(0); - private final Keyword cRightCurlyBracketKeyword_10 = (Keyword)cGroup.eContents().get(10); - + private final Group cGroup_3 = (Group)cGroup.eContents().get(3); + private final Keyword cColonKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); + private final Assignment cDataClassifierAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); + private final CrossReference cDataClassifierComponentClassifierCrossReference_3_1_0 = (CrossReference)cDataClassifierAssignment_3_1.eContents().get(0); + private final RuleCall cDataClassifierComponentClassifierQCREFParserRuleCall_3_1_0_1 = (RuleCall)cDataClassifierComponentClassifierCrossReference_3_1_0.eContents().get(1); + private final Keyword cInKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Assignment cValuesAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final RuleCall cValuesElementValuesParserRuleCall_5_0 = (RuleCall)cValuesAssignment_5.eContents().get(0); + private final Keyword cRightParenthesisKeyword_6 = (Keyword)cGroup.eContents().get(6); + private final Keyword cLeftCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7); + private final Assignment cActionsAssignment_8 = (Assignment)cGroup.eContents().get(8); + private final RuleCall cActionsBehaviorActionsParserRuleCall_8_0 = (RuleCall)cActionsAssignment_8.eContents().get(0); + private final Keyword cRightCurlyBracketKeyword_9 = (Keyword)cGroup.eContents().get(9); + + //// D.6 writes the iterator as 'element_identifier [ : data_unique_component_classifier_reference ]', so the classifier + //// is optional. When it is left out the iterated values determine the element type, which the translator resolves. //ForStatement: // (for?='for' | forall?='forall') - // '(' variable=ID ':' dataClassifier=[aadl2::ComponentClassifier|QCREF] + // '(' variable=ID (':' dataClassifier=[aadl2::ComponentClassifier|QCREF])? // 'in' values=ElementValues ')' // '{' actions=BehaviorActions '}' //; @Override public ParserRule getRule() { return rule; } //(for?='for' | forall?='forall') - //'(' variable=ID ':' dataClassifier=[aadl2::ComponentClassifier|QCREF] + //'(' variable=ID (':' dataClassifier=[aadl2::ComponentClassifier|QCREF])? //'in' values=ElementValues ')' //'{' actions=BehaviorActions '}' public Group getGroup() { return cGroup; } @@ -1784,41 +1787,44 @@ public class ForStatementElements extends AbstractParserRuleElementFinder { //ID public RuleCall getVariableIDTerminalRuleCall_2_0() { return cVariableIDTerminalRuleCall_2_0; } + //(':' dataClassifier=[aadl2::ComponentClassifier|QCREF])? + public Group getGroup_3() { return cGroup_3; } + //':' - public Keyword getColonKeyword_3() { return cColonKeyword_3; } + public Keyword getColonKeyword_3_0() { return cColonKeyword_3_0; } //dataClassifier=[aadl2::ComponentClassifier|QCREF] - public Assignment getDataClassifierAssignment_4() { return cDataClassifierAssignment_4; } + public Assignment getDataClassifierAssignment_3_1() { return cDataClassifierAssignment_3_1; } //[aadl2::ComponentClassifier|QCREF] - public CrossReference getDataClassifierComponentClassifierCrossReference_4_0() { return cDataClassifierComponentClassifierCrossReference_4_0; } + public CrossReference getDataClassifierComponentClassifierCrossReference_3_1_0() { return cDataClassifierComponentClassifierCrossReference_3_1_0; } //QCREF - public RuleCall getDataClassifierComponentClassifierQCREFParserRuleCall_4_0_1() { return cDataClassifierComponentClassifierQCREFParserRuleCall_4_0_1; } + public RuleCall getDataClassifierComponentClassifierQCREFParserRuleCall_3_1_0_1() { return cDataClassifierComponentClassifierQCREFParserRuleCall_3_1_0_1; } //'in' - public Keyword getInKeyword_5() { return cInKeyword_5; } + public Keyword getInKeyword_4() { return cInKeyword_4; } //values=ElementValues - public Assignment getValuesAssignment_6() { return cValuesAssignment_6; } + public Assignment getValuesAssignment_5() { return cValuesAssignment_5; } //ElementValues - public RuleCall getValuesElementValuesParserRuleCall_6_0() { return cValuesElementValuesParserRuleCall_6_0; } + public RuleCall getValuesElementValuesParserRuleCall_5_0() { return cValuesElementValuesParserRuleCall_5_0; } //')' - public Keyword getRightParenthesisKeyword_7() { return cRightParenthesisKeyword_7; } + public Keyword getRightParenthesisKeyword_6() { return cRightParenthesisKeyword_6; } //'{' - public Keyword getLeftCurlyBracketKeyword_8() { return cLeftCurlyBracketKeyword_8; } + public Keyword getLeftCurlyBracketKeyword_7() { return cLeftCurlyBracketKeyword_7; } //actions=BehaviorActions - public Assignment getActionsAssignment_9() { return cActionsAssignment_9; } + public Assignment getActionsAssignment_8() { return cActionsAssignment_8; } //BehaviorActions - public RuleCall getActionsBehaviorActionsParserRuleCall_9_0() { return cActionsBehaviorActionsParserRuleCall_9_0; } + public RuleCall getActionsBehaviorActionsParserRuleCall_8_0() { return cActionsBehaviorActionsParserRuleCall_8_0; } //'}' - public Keyword getRightCurlyBracketKeyword_10() { return cRightCurlyBracketKeyword_10; } + public Keyword getRightCurlyBracketKeyword_9() { return cRightCurlyBracketKeyword_9; } } public class WhileStatementElements extends AbstractParserRuleElementFinder { private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.WhileStatement"); @@ -3792,9 +3798,11 @@ public ParserRule getElseIfClauseRule() { return getElseIfClauseAccess().getRule(); } + //// D.6 writes the iterator as 'element_identifier [ : data_unique_component_classifier_reference ]', so the classifier + //// is optional. When it is left out the iterated values determine the element type, which the translator resolves. //ForStatement: // (for?='for' | forall?='forall') - // '(' variable=ID ':' dataClassifier=[aadl2::ComponentClassifier|QCREF] + // '(' variable=ID (':' dataClassifier=[aadl2::ComponentClassifier|QCREF])? // 'in' values=ElementValues ')' // '{' actions=BehaviorActions '}' //; diff --git a/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/BehaviorAnnex.xtext b/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/BehaviorAnnex.xtext index 51bb0004c8..b5fce8e56f 100644 --- a/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/BehaviorAnnex.xtext +++ b/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/BehaviorAnnex.xtext @@ -193,9 +193,11 @@ ElseIfClause: 'elsif' '(' condition=ValueExpression ')' actions=BehaviorActions ; +// D.6 writes the iterator as 'element_identifier [ : data_unique_component_classifier_reference ]', so the classifier +// is optional. When it is left out the iterated values determine the element type, which the translator resolves. ForStatement: (for?='for' | forall?='forall') - '(' variable=ID ':' dataClassifier=[aadl2::ComponentClassifier|QCREF] + '(' variable=ID (':' dataClassifier=[aadl2::ComponentClassifier|QCREF])? 'in' values=ElementValues ')' '{' actions=BehaviorActions '}' ; diff --git a/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/translation/DeclarativeToStrictTranslator.java b/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/translation/DeclarativeToStrictTranslator.java index 86af1a2f24..980d2184e4 100644 --- a/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/translation/DeclarativeToStrictTranslator.java +++ b/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/translation/DeclarativeToStrictTranslator.java @@ -125,6 +125,7 @@ import org.osate.ba.aadlba.ValueExpression; import org.osate.ba.analyzers.BehaviorTransitionContext; import org.osate.ba.utils.AadlBaUtils; +import org.osate.ba.utils.DimensionException; import org.osate.utils.internal.Aadl2Utils; import org.osate.utils.internal.Aadl2Visitors; import org.osate.utils.internal.PropertyUtils; @@ -720,6 +721,11 @@ private org.osate.ba.aadlba.ForOrForAllStatement toForStatement(final ForStateme if (statement.getValues() != null) { result.setIteratedValues(toElementValues(statement.getValues())); } + // Resolve the classifier before the body, because a data element reached through the iterator needs the + // iterator's own type to resolve. + if (statement.getDataClassifier() == null) { + variable.setDataClassifier(iteratedElementClassifier(result)); + } result.setBehaviorActions(toActions(statement.getActions())); } finally { iterativeScopes.remove(iterativeScopes.size() - 1); @@ -727,6 +733,34 @@ private org.osate.ba.aadlba.ForOrForAllStatement toForStatement(final ForStateme return result; } + /** + * Returns the data classifier of the elements the given loop iterates, or {@code null} when no classifier denotes + * them. + * + *

+ * D.6 leaves the iterator classifier optional and its semantics give the iterator the type of the iterated + * element, so an omitted classifier is resolved here, the way every other name in the annex is. An integer range + * is the one case with no classifier to resolve: the iterator is a universal integer, which no data classifier + * denotes, the same way a port count value is one. Any other iterated value is a port or a data component, whose + * element type is its own type with the array dimension dropped, so the classifier is the one the type of the + * iterated values names. A written classifier that translation cannot carry is deliberately not replaced: the + * declaration is reported as written instead. + *

+ */ + private DataClassifier iteratedElementClassifier(final org.osate.ba.aadlba.ForOrForAllStatement loop) { + if (!(loop.getIteratedValues() instanceof Element iterated)) { + return null; + } + try { + // The iterated values are contained by the loop by now, which is what makes getTypeHolder resolve a + // Data Model array to its base type instead of reporting the array itself. + return AadlBaUtils.getTypeHolder(iterated, owner).getKlass(); + } catch (final DimensionException | UnsupportedOperationException exception) { + // The type checker reports an iterated value it cannot type, over the same model. + return null; + } + } + private ElementValues toElementValues(final org.osate.xtext.aadl2.ba.behaviorAnnex.ElementValues values) { if (values.getUpper() == null) { return (ElementValues) toIntegerValue(values.getLower()); diff --git a/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/validation/BehaviorAnnexValidator.java b/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/validation/BehaviorAnnexValidator.java index 645c01cb5c..db358f4e78 100644 --- a/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/validation/BehaviorAnnexValidator.java +++ b/ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/validation/BehaviorAnnexValidator.java @@ -44,6 +44,7 @@ import org.eclipse.xtext.validation.ValidationMessageAcceptor; import org.osate.aadl2.ComponentClassifier; import org.osate.aadl2.ComponentImplementation; +import org.osate.aadl2.DataClassifier; import org.osate.aadl2.DataSubcomponent; import org.osate.aadl2.DirectionType; import org.osate.aadl2.Element; @@ -95,6 +96,7 @@ public final class BehaviorAnnexValidator extends AbstractBehaviorAnnexValidator public static final String TIMEOUT_RESET_PORT = "org.osate.xtext.aadl2.ba.timeoutResetPort"; public static final String TIMEOUT_RESET_PORT_TIME = "org.osate.xtext.aadl2.ba.timeoutResetPortTime"; public static final String ITERATIVE_VARIABLE_TARGET = "org.osate.xtext.aadl2.ba.iterativeVariableTarget"; + public static final String ITERATOR_CLASSIFIER = "org.osate.xtext.aadl2.ba.iteratorClassifier"; public static final String ARRAY_SIZE = "org.osate.xtext.aadl2.ba.arraySize"; public static final String PROPERTY_REFERENCE_VALUE = "org.osate.xtext.aadl2.ba.propertyReferenceValue"; public static final String MODE_REFINEMENT = "org.osate.xtext.aadl2.ba.modeRefinement"; @@ -128,6 +130,7 @@ public void checkBehaviorAnnex(final BehaviorAnnex source) { // Each check describes a use no strict checker can reject, and a model can get each one wrong independently, // so report them all before deciding whether the strict checkers have a model to work on. var representable = checkArraySizes(source); + representable &= checkIteratorClassifiers(source); representable &= checkInternalPortUses(source, translation); representable &= checkInternalConditionPorts(source, translation); representable &= checkTimeoutResetPorts(source, translation); @@ -188,6 +191,31 @@ private boolean checkArraySizes(final BehaviorAnnex source) { return accepted; } + /** + * The AS5506/3 Rev A D.6 {@code for} and {@code forall} productions write the iterator classifier as a + * data_unique_component_classifier_reference, and an iterative variable is typed by a data classifier alone, so a + * classifier of any other category has nothing to become in the strict model. Because the same production leaves the + * classifier out altogether, letting it pass would not leave the declaration rejected either: the iterated values + * would supply the iterator's type as if nothing had been written. Report it on the reference the loop writes. + * + * @return {@code true} when every written iterator classifier is a data classifier + */ + private boolean checkIteratorClassifiers(final BehaviorAnnex source) { + var accepted = true; + for (var contents = source.eAllContents(); contents.hasNext();) { + if (!(contents.next() instanceof ForStatement loop) || loop.getDataClassifier() == null + || loop.getDataClassifier() instanceof DataClassifier) { + continue; + } + error("'" + loop.getDataClassifier().getName() + "' is not a data classifier: a for or forall iterator can" + + " only name a data component classifier", loop, + BehaviorAnnexPackage.eINSTANCE.getForStatement_DataClassifier(), + ValidationMessageAcceptor.INSIGNIFICANT_INDEX, ITERATOR_CLASSIFIER); + accepted = false; + } + return accepted; + } + /** * D.5 defines {@code count}, {@code fresh}, and {@code updated} in terms of receiving or freezing input, so none has * a defined value on an outgoing port. The D.7 value-variable grammar nevertheless names a general port for all