diff --git a/ba/doc/conformance.md b/ba/doc/conformance.md index f129a7de70..fb01e1390b 100644 --- a/ba/doc/conformance.md +++ b/ba/doc/conformance.md @@ -13,7 +13,7 @@ The user directed that the report findings be treated as valid and filed without | Finding | Issue | Finding | Issue | | --- | --- | --- | --- | | G01 ✅ | [#3165](https://github.com/osate/osate2/issues/3165) | G15 | [#3179](https://github.com/osate/osate2/issues/3179) | -| G02 | [#3166](https://github.com/osate/osate2/issues/3166) | G16 ✅ | [#3180](https://github.com/osate/osate2/issues/3180) | +| G02 ✅ | [#3166](https://github.com/osate/osate2/issues/3166) | G16 ✅ | [#3180](https://github.com/osate/osate2/issues/3180) | | G03 ✅ | [#3167](https://github.com/osate/osate2/issues/3167) | G17 | [#3181](https://github.com/osate/osate2/issues/3181) | | G04 ✅ | [#3168](https://github.com/osate/osate2/issues/3168) | V01 ✅ | [#3182](https://github.com/osate/osate2/issues/3182) | | G05 ✅ | [#3169](https://github.com/osate/osate2/issues/3169) | V02 ✅ | [#3183](https://github.com/osate/osate2/issues/3183) | @@ -24,11 +24,11 @@ The user directed that the report findings be treated as valid and filed without | G10 ✅ | [#3174](https://github.com/osate/osate2/issues/3174) | V07 | [#3188](https://github.com/osate/osate2/issues/3188) | | G11 ✅ | [#3175](https://github.com/osate/osate2/issues/3175) | V08 | [#3189](https://github.com/osate/osate2/issues/3189) | | G12 ✅ | [#3176](https://github.com/osate/osate2/issues/3176) | V09 | [#3190](https://github.com/osate/osate2/issues/3190) | -| G13 | [#3177](https://github.com/osate/osate2/issues/3177) | V10 | [#3191](https://github.com/osate/osate2/issues/3191) | +| G13 ✅ | [#3177](https://github.com/osate/osate2/issues/3177) | V10 | [#3191](https://github.com/osate/osate2/issues/3191) | | G14 | [#3178](https://github.com/osate/osate2/issues/3178) | V11 | [#3192](https://github.com/osate/osate2/issues/3192) | | G18 | [#3199](https://github.com/osate/osate2/issues/3199) | | | -Closed since the review: G01 ([#3165](https://github.com/osate/osate2/issues/3165), internal conditions), G03 ([#3167](https://github.com/osate/osate2/issues/3167), frozen-port parentheses), G04 ([#3168](https://github.com/osate/osate2/issues/3168), timeout reset ports), G08 ([#3172](https://github.com/osate/osate2/issues/3172), `self` property references), G10 ([#3174](https://github.com/osate/osate2/issues/3174), internal port actions), G11 ([#3175](https://github.com/osate/osate2/issues/3175), numeric literals), G16 ([#3180](https://github.com/osate/osate2/issues/3180), loop-variable assignment targets), V01 ([#3182](https://github.com/osate/osate2/issues/3182), declaration naming rules), and V02 ([#3183](https://github.com/osate/osate2/issues/3183), otherwise-transition rules). G12 ([#3176](https://github.com/osate/osate2/issues/3176), array extents) and its follow-ups [#3208](https://github.com/osate/osate2/issues/3208) and [#3210](https://github.com/osate/osate2/issues/3210) are addressed on branches not yet merged into `master`. +Closed since the review: G01 ([#3165](https://github.com/osate/osate2/issues/3165), internal conditions), G02 ([#3166](https://github.com/osate/osate2/issues/3166), external-condition expressions), G03 ([#3167](https://github.com/osate/osate2/issues/3167), frozen-port parentheses), G04 ([#3168](https://github.com/osate/osate2/issues/3168), timeout reset ports), G05 ([#3169](https://github.com/osate/osate2/issues/3169), short-circuit logical operators), G07 ([#3171](https://github.com/osate/osate2/issues/3171), the port `updated` value), G08 ([#3172](https://github.com/osate/osate2/issues/3172), `self` property references), G10 ([#3174](https://github.com/osate/osate2/issues/3174), internal port actions), G11 ([#3175](https://github.com/osate/osate2/issues/3175), numeric literals), G12 ([#3176](https://github.com/osate/osate2/issues/3176), array extents) together with its follow-ups [#3208](https://github.com/osate/osate2/issues/3208) and [#3210](https://github.com/osate/osate2/issues/3210), G13 ([#3177](https://github.com/osate/osate2/issues/3177), expression precedence and grouping), G16 ([#3180](https://github.com/osate/osate2/issues/3180), loop-variable assignment targets), V01 ([#3182](https://github.com/osate/osate2/issues/3182), declaration naming rules), V02 ([#3183](https://github.com/osate/osate2/issues/3183), otherwise-transition rules), and V03 ([#3184](https://github.com/osate/osate2/issues/3184), action timeout legality rules). That work opened four defects the review itself did not name: [#3195](https://github.com/osate/osate2/issues/3195), a bare `on dispatch` losing its condition unless exactly one space separated the keywords; [#3205](https://github.com/osate/osate2/issues/3205), the dequeue form of the G16 rule, which the assignment check did not reach; and [#3208](https://github.com/osate/osate2/issues/3208) and [#3210](https://github.com/osate/osate2/issues/3210), both from G12 and both described in that row. Each row's assessment below still describes the state at the review date unless it says otherwise. @@ -40,7 +40,7 @@ The reference is the supplied **AS5506/3 Rev. A, approved 2017-07, Annex D: Beha SHA-256: `88da0a3157a47a265fc1f2ba0bdfdcd243457df7e136484bb9625792f0701868`. -The document was read using a `textutil -convert txt` extraction. References below use Annex D section numbers, production names, and the wording/topic of rules. Word automatic numbering and table layout are not fully retained in that extraction, so this report does not infer individual rule numbers from extracted paragraph positions. The document's contents identify AS5506C as its core-language reference. No later edition or errata was substituted. +The document was read using a `textutil -convert txt` extraction. That extraction is now kept beside the document as `AS5506_3RevA_2017_Jul copy.txt` (SHA-256 `20f3983eed760e4237a7ef7c090991da41817324fa683a6ade29f65f3720a08c`) so later work can quote the same text without reconverting. References below use Annex D section numbers, production names, and the wording/topic of rules. Word automatic numbering and table layout are not fully retained in that extraction, so this report does not infer individual rule numbers from extracted paragraph positions. The document's contents identify AS5506C as its core-language reference. No later edition or errata was substituted. The review follows the registered implementation: [BA plug-in registrations](../../ba/org.osate.xtext.aadl2.ba/plugin.xml), the [Xtext grammar](../../ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/BehaviorAnnex.xtext), the [declarative-to-strict translator](../../ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/translation/DeclarativeToStrictTranslator.java), and the [validator](../../ba/org.osate.xtext.aadl2.ba/src/org/osate/xtext/aadl2/ba/validation/BehaviorAnnexValidator.java). The validator translates the embedded annex, runs `AadlBaTypeChecker`, then runs `AadlBaRulesCheckersDriver` if type checking succeeds. Retained strict-model classes and old comments are not, by themselves, evidence that the current front end supports a construct. @@ -61,7 +61,7 @@ The review itself was a source and test-artifact audit. No Maven tests, simulato | 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) and internal events were represented incorrectly (G10), both since fixed; call-signature and 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.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); value-expression grouping/precedence and numeric translation differ from the document; initialization analysis is not demonstrated. | +| 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 is still accepted (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. | Useful positive evidence includes [CoveringSyntaxTest](../../ba/org.osate.ba.tests/src/org/osate/ba/tests/CoveringSyntaxTest.xtend), [CoveringSemanticTest](../../ba/org.osate.ba.tests/src/org/osate/ba/tests/CoveringSemanticTest.xtend), [GrammarHazards.aadl](../../ba/org.osate.ba.tests/models/characterization/GrammarHazards.aadl), [BehaviorAnnexIntegrationTest](../../ba/org.osate.xtext.aadl2.ba.tests/src/org/osate/xtext/aadl2/ba/tests/BehaviorAnnexIntegrationTest.java), and [Issue3153Test](../../ba/org.osate.ba.tests/src/org/osate/ba/tests/Issue3153Test.java), [Issue3154Test](../../ba/org.osate.ba.tests/src/org/osate/ba/tests/Issue3154Test.java), and [Issue3155Test](../../ba/org.osate.ba.tests/src/org/osate/ba/tests/Issue3155Test.java). The latter tests establish specific diagnostic behavior and source locations, rather than general standard coverage. @@ -126,6 +126,8 @@ The AST precedence error and the strict-model flattening error must be assessed **Required coverage:** Assert AST and strict-model grouping for mixed logical operators, nested logical parentheses, unary minus with exponentiation, and permitted/rejected power forms. Compare meaning, not only serialized text. +**Addressed by [#3177](https://github.com/osate/osate2/issues/3177):** the expression rules are now the D.7 productions themselves — `value_expression`, `relation`, `simple_expression`, `term`, `factor`, and `value` — instead of one rule per operator. All logical operators share one precedence level and associate from left to right, the unary adding operator leads a whole simple expression so it binds below the multiplying and numeric operators, and a factor admits at most one exponentiation and a single value as the operand of `abs` or `not`. `a ** b ** c`, `- -a`, `abs -a`, and `not not a` are therefore syntax errors, as the standard grammar requires. A parenthesized group is a `ParenthesizedExpression` of its own, so the translator no longer infers grouping from node text: `appendLogical` flattens only the left-associated chain the grammar builds, a group stays one relation, and `toValue` turns it into the nested strict value expression D.7's `value` production admits. That also restores two operators the old translator dropped: `-a mod b` kept no sign at all, and `-2 ** 2` became `(-2) ** 2`. Because a group is now an object, the serializer emits the requested parentheses from the model rather than reconstructing them from the parse text, and each expression object's reported source range excludes the enclosing parentheses. `Issue3177Test` asserts the declarative shape as a prefix tree and the strict shape in the standard's nesting for mixed operators, a nested logical group, a signed exponentiation, a signed multiplying term, and the parenthesized exponentiation chain that is the positive control, plus one fixture per rejected form and an unparse/reparse round trip. Unary plus is deliberately still accepted; it is [#3170](https://github.com/osate/osate2/issues/3170). + ### G14 — Complete states are not bound to their corresponding AADL modes **Standard:** D.3 allows complete states to represent same-named modes and requires consistency with the corresponding mode transitions. It also constrains mixtures of complete states that do and do not represent modes. @@ -223,8 +225,8 @@ These are proposed follow-up changes, not changes made by this review. | Order | Work | Concrete evidence needed to close it | | --- | --- | --- | | 1 | ~~Repair the conformance test oracle and ensure deterministic BA validator registration. Separate legacy characterization from standard expectations.~~ **Done**, branch `repair_conformance_test_oracle` (commit `Repair the Behavior Annex conformance test oracle`). | Exact diagnostics are compared, by `expected/diagnostics` and the new `expected/diagnostics-validated`; registration is proved end to end by requiring at least one BA rule diagnostic in the validated suite and none in the plain baseline; both suites and the conformance class assert nonzero executed cases; the nine skips it left were listed in `TRACKED_SKIPS` against their own issues and enforced by reflection, and that list has shrunk to five as those issues closed; `SelfPropertyReference.aadl` no longer carries an unrelated D.3 error. Each repaired expectation was confirmed to fail for its intended reason by temporarily removing its `@Ignore`. | -| 2 | Preserve strict-model meaning: numeric literals, array extents, logical grouping, `self`, internal events, and mode bindings (G08, G10–G14). **Under way:** G08, G10, and G11 are closed and G12's pull request is open; logical grouping (G13) and mode bindings (G14) remain. | External AADL input produces correct literal values, extents, references, operation kinds, and mode links; no test-only model mutation is needed. Assert attributes and semantic structure directly. | -| 3 | Implement the missing standard syntax and remove unwanted overacceptance (G01–G07, G09, G13). **Under way:** G01, G03, G04, and G05 are closed; G02, G06, G07, G09, and G13 remain. | Each standard form parses and translates; nonstandard forms have deliberate rejection/extension policy. Enable corrected standard acceptance tests and add AST/strict-model expression tests. | +| 2 | Preserve strict-model meaning: numeric literals, array extents, logical grouping, `self`, internal events, and mode bindings (G08, G10–G14). **Under way:** G08, G10, G11, G12, and G13 are closed; mode bindings (G14) remain. | External AADL input produces correct literal values, extents, references, operation kinds, and mode links; no test-only model mutation is needed. Assert attributes and semantic structure directly. | +| 3 | Implement the missing standard syntax and remove unwanted overacceptance (G01–G07, G09, G13). **Under way:** G01–G05, G07, and G13 are closed; G06 and G09 remain. | Each standard form parses and translates; nonstandard forms have deliberate rejection/extension policy. Enable corrected standard acceptance tests and add AST/strict-model expression tests. | | 4 | Correct the explicit validation mismatches and add the remaining static legality checks (G15–G18, V01–V03, V06–V07, V10–V11). G18 belongs first in this step: with type conformance disabled, several of the others cannot be demonstrated. **Under way:** G16 and V01–V03 are addressed; G15, G17, G18, V06, V07, V10, and V11 remain, and the G16 dequeue form (#3205) is open. | Each negative model has an exact rule diagnostic and a nearby positive control. For G18, every diagnostic that appears in the existing corpus is triaged and its golden updated deliberately. Reproduce independently before opening an issue; use one independently reviewable defect per issue/fix. | | 5 | Establish behavioral/dataflow coverage and consumer boundaries (V04–V05, V08–V09, D.5 and D.8 runtime semantics). | State which obligations the front end can prove, which are warnings/approximations, and which belong to a simulator, analyzer, or generator. Validate queue behavior, timeouts, lock lifetimes, initialization, and call synchronization in the responsible consumer. | diff --git a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt new file mode 100644 index 0000000000..dd8f688016 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt @@ -0,0 +1,2 @@ +error | syntax | 38 | 31 | 2 | no viable alternative at input ':=' +error | syntax | 38 | 39 | 5 | extraneous input 'total' expecting '}' diff --git a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_Issue3177.txt b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_Issue3177.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_PowerChain.txt b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_PowerChain.txt new file mode 100644 index 0000000000..c261baf95b --- /dev/null +++ b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_PowerChain.txt @@ -0,0 +1 @@ +error | syntax | 38 | 45 | 2 | mismatched input '**' expecting '}' diff --git a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_RepeatedNot.txt b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_RepeatedNot.txt new file mode 100644 index 0000000000..161c1684b5 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_RepeatedNot.txt @@ -0,0 +1,2 @@ +error | syntax | 36 | 29 | 2 | no viable alternative at input ':=' +error | syntax | 36 | 40 | 4 | extraneous input 'flag' expecting '}' diff --git a/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt new file mode 100644 index 0000000000..7919e21c83 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/diagnostics-validated/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt @@ -0,0 +1,2 @@ +error | syntax | 38 | 31 | 2 | no viable alternative at input ':=' +error | syntax | 38 | 37 | 5 | extraneous input 'total' expecting '}' diff --git a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt new file mode 100644 index 0000000000..dd8f688016 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt @@ -0,0 +1,2 @@ +error | syntax | 38 | 31 | 2 | no viable alternative at input ':=' +error | syntax | 38 | 39 | 5 | extraneous input 'total' expecting '}' diff --git a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_Issue3177.txt b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_Issue3177.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_PowerChain.txt b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_PowerChain.txt new file mode 100644 index 0000000000..c261baf95b --- /dev/null +++ b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_PowerChain.txt @@ -0,0 +1 @@ +error | syntax | 38 | 45 | 2 | mismatched input '**' expecting '}' diff --git a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_RepeatedNot.txt b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_RepeatedNot.txt new file mode 100644 index 0000000000..161c1684b5 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_RepeatedNot.txt @@ -0,0 +1,2 @@ +error | syntax | 36 | 29 | 2 | no viable alternative at input ':=' +error | syntax | 36 | 40 | 4 | extraneous input 'flag' expecting '}' diff --git a/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt new file mode 100644 index 0000000000..7919e21c83 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/diagnostics/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt @@ -0,0 +1,2 @@ +error | syntax | 38 | 31 | 2 | no viable alternative at input ':=' +error | syntax | 38 | 37 | 5 | extraneous input 'total' expecting '}' diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_GrammarHazards.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_GrammarHazards.txt index 2a1b1240af..f8d522c4a6 100644 --- a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_GrammarHazards.txt +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_GrammarHazards.txt @@ -121,6 +121,7 @@ annex[0] owner=Issue2445_Grammar_Hazards::hazards (HashPropertyReference, , 1272, 15) (IfStatement, , 1736, 104) (ListValue, , 1007, 5) + (ParenthesizedExpression, , 1484, 13) (Reference, , 1191, 5) (Reference, , 1218, 5) (Reference, , 1239, 5) @@ -177,7 +178,7 @@ annex[0] owner=Issue2445_Grammar_Hazards::hazards (ReferenceExpression, , 1425, 5) (ReferenceExpression, , 1445, 5) (ReferenceExpression, , 1455, 5) - (ReferenceExpression, , 1484, 13) + (ReferenceExpression, , 1485, 11) (ReferenceExpression, , 1501, 11) (ReferenceExpression, , 1592, 5) (ReferenceExpression, , 1618, 5) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_syntax_errors_UnbalancedParentheses.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_syntax_errors_UnbalancedParentheses.txt index 352b0969c9..0e5ea6389f 100644 --- a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_syntax_errors_UnbalancedParentheses.txt +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_characterization_syntax_errors_UnbalancedParentheses.txt @@ -2,13 +2,14 @@ annex[0] owner=UnbalancedParentheses::t (AssignmentAction, , 312, 6) (BehaviorActionBlock, , 294, 28) (BehaviorAnnex, behavior_specification, 203, 120) - (BehaviorBooleanLiteral, , 303, 6) + (BehaviorBooleanLiteral, , 304, 4) (BehaviorIntegerLiteral, , 317, 1) (BehaviorState, s, 246, 1) (BehaviorStateGroup, , 246, 23) (BehaviorTransition, , 284, 39) (BehaviorVariable, x, 213, 1) (BehaviorVariableGroup, , 213, 23) + (ParenthesizedExpression, , 303, 6) (Reference, , 312, 1) (ReferenceSegment, x, 312, 1) (WhileStatement, , 296, 24) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_covering_syntax_aadlBaTest001.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_covering_syntax_aadlBaTest001.txt index d736076f93..bba8700693 100644 --- a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_covering_syntax_aadlBaTest001.txt +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_covering_syntax_aadlBaTest001.txt @@ -788,16 +788,16 @@ annex[1] owner=NamesResolutionTest::thread1.impl (BinaryExpression, , 12147, 6) (BinaryExpression, , 12179, 6) (BinaryExpression, , 12238, 75) - (BinaryExpression, , 12241, 30) (BinaryExpression, , 12242, 13) (BinaryExpression, , 12242, 23) + (BinaryExpression, , 12242, 28) (BinaryExpression, , 12242, 9) (BinaryExpression, , 12258, 7) - (BinaryExpression, , 12275, 38) (BinaryExpression, , 12276, 15) - (BinaryExpression, , 12281, 10) - (BinaryExpression, , 12295, 17) + (BinaryExpression, , 12276, 36) + (BinaryExpression, , 12282, 8) (BinaryExpression, , 12296, 11) + (BinaryExpression, , 12296, 15) (BinaryExpression, , 5314, 5) (BinaryExpression, , 5332, 5) (BinaryExpression, , 5350, 6) @@ -814,7 +814,7 @@ annex[1] owner=NamesResolutionTest::thread1.impl (BinaryExpression, , 5611, 3) (BinaryExpression, , 5611, 7) (BinaryExpression, , 5631, 10) - (BinaryExpression, , 5631, 6) + (BinaryExpression, , 5632, 5) (BinaryExpression, , 5654, 4) (BinaryExpression, , 5654, 8) (BinaryExpression, , 5675, 39) @@ -823,7 +823,7 @@ annex[1] owner=NamesResolutionTest::thread1.impl (BinaryExpression, , 5739, 34) (BinaryExpression, , 5739, 43) (BinaryExpression, , 5795, 12) - (BinaryExpression, , 5795, 8) + (BinaryExpression, , 5796, 7) (BinaryExpression, , 5820, 10) (BinaryExpression, , 5820, 20) (BinaryExpression, , 5820, 29) @@ -833,7 +833,7 @@ annex[1] owner=NamesResolutionTest::thread1.impl (BinaryExpression, , 6015, 3) (BinaryExpression, , 6015, 7) (BinaryExpression, , 6035, 10) - (BinaryExpression, , 6035, 6) + (BinaryExpression, , 6036, 5) (BinaryExpression, , 6058, 4) (BinaryExpression, , 6058, 8) (BinaryExpression, , 6079, 11) @@ -846,8 +846,8 @@ annex[1] owner=NamesResolutionTest::thread1.impl (BinaryExpression, , 6184, 29) (BinaryExpression, , 6201, 12) (BinaryExpression, , 7624, 3) - (BinaryExpression, , 7657, 8) - (BinaryExpression, , 7698, 7) + (BinaryExpression, , 7658, 7) + (BinaryExpression, , 7699, 5) (BinaryExpression, , 7736, 5) (BinaryExpression, , 7793, 5) (BinaryExpression, , 8386, 5) @@ -1036,6 +1036,13 @@ annex[1] owner=NamesResolutionTest::thread1.impl (IfStatement, , 8733, 39) (IfStatement, , 8789, 34) (IfStatement, , 8842, 80) + (ParenthesizedExpression, , 12241, 30) + (ParenthesizedExpression, , 12275, 38) + (ParenthesizedExpression, , 12281, 10) + (ParenthesizedExpression, , 12295, 17) + (ParenthesizedExpression, , 12296, 7) + (ParenthesizedExpression, , 6148, 16) + (ParenthesizedExpression, , 7698, 7) (PropertyReferenceTail, , 7002, 13) (PropertyReferenceTail, , 7075, 7) (Reference, , 10029, 3) @@ -1886,19 +1893,19 @@ annex[1] owner=NamesResolutionTest::thread1.impl (UnaryExpression, , 11876, 2) (UnaryExpression, , 12238, 33) (UnaryExpression, , 12242, 5) - (UnaryExpression, , 12296, 7) + (UnaryExpression, , 12297, 5) (UnaryExpression, , 5487, 9) (UnaryExpression, , 5534, 9) (UnaryExpression, , 5592, 2) - (UnaryExpression, , 5631, 2) - (UnaryExpression, , 5795, 2) + (UnaryExpression, , 5631, 6) + (UnaryExpression, , 5795, 8) (UnaryExpression, , 5824, 2) (UnaryExpression, , 5862, 5) (UnaryExpression, , 5996, 2) - (UnaryExpression, , 6035, 2) + (UnaryExpression, , 6035, 6) (UnaryExpression, , 6145, 19) - (UnaryExpression, , 6148, 16) - (UnaryExpression, , 7657, 2) + (UnaryExpression, , 6149, 14) + (UnaryExpression, , 7657, 8) (UnaryExpression, , 7694, 11) (WhileStatement, , 10054, 20) (WhileStatement, , 10092, 30) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_covering_syntax_aadlBaTest006.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_covering_syntax_aadlBaTest006.txt index 74311a5b65..7d80063d2f 100644 --- a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_covering_syntax_aadlBaTest006.txt +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_covering_syntax_aadlBaTest006.txt @@ -105,6 +105,7 @@ annex[0] owner=ParseTest::t (ExecuteCondition, , 2681, 5) (ExecuteCondition, , 2868, 5) (ExecuteCondition, , 3041, 1) + (ParenthesizedExpression, , 2125, 7) (Reference, , 1461, 2) (Reference, , 1472, 2) (Reference, , 1476, 2) @@ -120,7 +121,7 @@ annex[0] owner=ParseTest::t (ReferenceExpression, , 1554, 2) (ReferenceExpression, , 1699, 1) (ReferenceExpression, , 1736, 1) - (ReferenceExpression, , 2125, 7) + (ReferenceExpression, , 2126, 5) (ReferenceExpression, , 2681, 5) (ReferenceExpression, , 2868, 5) (ReferenceExpression, , 3041, 1) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt new file mode 100644 index 0000000000..5067a3ec5c --- /dev/null +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt @@ -0,0 +1,15 @@ +annex[0] owner=AbsNegatedOperand::evaluate + (BehaviorActionBlock, , 2170, 24) + (BehaviorAnnex, behavior_specification, 2002, 193) + (BehaviorState, done, 2115, 4) + (BehaviorState, start, 2089, 5) + (BehaviorStateGroup, , 2089, 22) + (BehaviorStateGroup, , 2115, 19) + (BehaviorTransition, , 2152, 43) + (BehaviorVariable, result, 2047, 6) + (BehaviorVariable, total, 2015, 5) + (BehaviorVariableGroup, , 2015, 28) + (BehaviorVariableGroup, , 2047, 29) + (CommunicationAction, , 2172, 15) + (Reference, , 2172, 6) + (ReferenceSegment, result, 2172, 6) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_Issue3177.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_Issue3177.txt new file mode 100644 index 0000000000..b10f3fd809 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_Issue3177.txt @@ -0,0 +1,77 @@ +annex[0] owner=Issue3177::evaluate + (AssignmentAction, , 2295, 32) + (AssignmentAction, , 2468, 34) + (AssignmentAction, , 2611, 17) + (AssignmentAction, , 2792, 22) + (AssignmentAction, , 2900, 27) + (BehaviorActionBlock, , 2137, 795) + (BehaviorActionSequence, , 2295, 632) + (BehaviorAnnex, behavior_specification, 1842, 1091) + (BehaviorIntegerLiteral, , 2622, 1) + (BehaviorIntegerLiteral, , 2627, 1) + (BehaviorIntegerLiteral, , 2813, 1) + (BehaviorIntegerLiteral, , 2920, 1) + (BehaviorIntegerLiteral, , 2926, 1) + (BehaviorState, done, 2082, 4) + (BehaviorState, start, 2056, 5) + (BehaviorStateGroup, , 2056, 22) + (BehaviorStateGroup, , 2082, 19) + (BehaviorTransition, , 2119, 814) + (BehaviorVariable, flag, 2016, 4) + (BehaviorVariable, left, 1920, 4) + (BehaviorVariable, middle, 1951, 6) + (BehaviorVariable, result, 1887, 6) + (BehaviorVariable, right, 1984, 5) + (BehaviorVariable, total, 1855, 5) + (BehaviorVariableGroup, , 1855, 28) + (BehaviorVariableGroup, , 1887, 29) + (BehaviorVariableGroup, , 1920, 27) + (BehaviorVariableGroup, , 1951, 29) + (BehaviorVariableGroup, , 1984, 28) + (BehaviorVariableGroup, , 2016, 27) + (BinaryExpression, , 2303, 14) + (BinaryExpression, , 2303, 24) + (BinaryExpression, , 2476, 26) + (BinaryExpression, , 2486, 15) + (BinaryExpression, , 2622, 6) + (BinaryExpression, , 2803, 11) + (BinaryExpression, , 2910, 17) + (BinaryExpression, , 2911, 10) + (ParenthesizedExpression, , 2485, 17) + (ParenthesizedExpression, , 2910, 12) + (Reference, , 2295, 4) + (Reference, , 2303, 4) + (Reference, , 2311, 6) + (Reference, , 2322, 5) + (Reference, , 2468, 4) + (Reference, , 2476, 4) + (Reference, , 2486, 6) + (Reference, , 2496, 5) + (Reference, , 2611, 6) + (Reference, , 2792, 6) + (Reference, , 2803, 5) + (Reference, , 2900, 6) + (Reference, , 2911, 5) + (ReferenceExpression, , 2303, 4) + (ReferenceExpression, , 2311, 6) + (ReferenceExpression, , 2322, 5) + (ReferenceExpression, , 2476, 4) + (ReferenceExpression, , 2486, 6) + (ReferenceExpression, , 2496, 5) + (ReferenceExpression, , 2803, 5) + (ReferenceExpression, , 2911, 5) + (ReferenceSegment, flag, 2295, 4) + (ReferenceSegment, flag, 2468, 4) + (ReferenceSegment, left, 2303, 4) + (ReferenceSegment, left, 2476, 4) + (ReferenceSegment, middle, 2311, 6) + (ReferenceSegment, middle, 2486, 6) + (ReferenceSegment, result, 2611, 6) + (ReferenceSegment, result, 2792, 6) + (ReferenceSegment, result, 2900, 6) + (ReferenceSegment, right, 2322, 5) + (ReferenceSegment, right, 2496, 5) + (ReferenceSegment, total, 2803, 5) + (ReferenceSegment, total, 2911, 5) + (UnaryExpression, , 2621, 7) + (UnaryExpression, , 2802, 12) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_PowerChain.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_PowerChain.txt new file mode 100644 index 0000000000..25aa0678c1 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_PowerChain.txt @@ -0,0 +1,20 @@ +annex[0] owner=PowerChain::evaluate + (AssignmentAction, , 2151, 20) + (BehaviorActionBlock, , 2149, 29) + (BehaviorAnnex, behavior_specification, 1981, 198) + (BehaviorIntegerLiteral, , 2170, 1) + (BehaviorState, done, 2094, 4) + (BehaviorState, start, 2068, 5) + (BehaviorStateGroup, , 2068, 22) + (BehaviorStateGroup, , 2094, 19) + (BehaviorTransition, , 2131, 48) + (BehaviorVariable, result, 2026, 6) + (BehaviorVariable, total, 1994, 5) + (BehaviorVariableGroup, , 1994, 28) + (BehaviorVariableGroup, , 2026, 29) + (BinaryExpression, , 2161, 10) + (Reference, , 2151, 6) + (Reference, , 2161, 5) + (ReferenceExpression, , 2161, 5) + (ReferenceSegment, result, 2151, 6) + (ReferenceSegment, total, 2161, 5) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_RepeatedNot.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_RepeatedNot.txt new file mode 100644 index 0000000000..f5eb046d49 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_RepeatedNot.txt @@ -0,0 +1,13 @@ +annex[0] owner=RepeatedNot::evaluate + (BehaviorActionBlock, , 2079, 24) + (BehaviorAnnex, behavior_specification, 1945, 159) + (BehaviorState, done, 2024, 4) + (BehaviorState, start, 1998, 5) + (BehaviorStateGroup, , 1998, 22) + (BehaviorStateGroup, , 2024, 19) + (BehaviorTransition, , 2061, 43) + (BehaviorVariable, flag, 1958, 4) + (BehaviorVariableGroup, , 1958, 27) + (CommunicationAction, , 2081, 15) + (Reference, , 2081, 4) + (ReferenceSegment, flag, 2081, 4) diff --git a/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt new file mode 100644 index 0000000000..738324903d --- /dev/null +++ b/ba/org.osate.ba.tests/expected/positions/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt @@ -0,0 +1,15 @@ +annex[0] owner=RepeatedUnaryMinus::evaluate + (BehaviorActionBlock, , 2222, 22) + (BehaviorAnnex, behavior_specification, 2054, 191) + (BehaviorState, done, 2167, 4) + (BehaviorState, start, 2141, 5) + (BehaviorStateGroup, , 2141, 22) + (BehaviorStateGroup, , 2167, 19) + (BehaviorTransition, , 2204, 41) + (BehaviorVariable, result, 2099, 6) + (BehaviorVariable, total, 2067, 5) + (BehaviorVariableGroup, , 2067, 28) + (BehaviorVariableGroup, , 2099, 29) + (CommunicationAction, , 2224, 13) + (Reference, , 2224, 6) + (ReferenceSegment, result, 2224, 6) diff --git a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt new file mode 100644 index 0000000000..ac7474ac3b --- /dev/null +++ b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt @@ -0,0 +1,10 @@ +annex[0] owner=AbsNegatedOperand::evaluate + parsedAnnexSubclause : BehaviorAnnex name=behavior_specification + variables[0] : BehaviorVariable name=total + variables[1] : BehaviorVariable name=result + states[0] : BehaviorState name=start + states[1] : BehaviorState name=done + transitions[0] : BehaviorTransition + actions[0] : BehaviorActionBlock + content : SubprogramCallAction + proxy : BehaviorVariableHolder element=result [BehaviorVariable] diff --git a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_Issue3177.txt b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_Issue3177.txt new file mode 100644 index 0000000000..362e0d3fae --- /dev/null +++ b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_Issue3177.txt @@ -0,0 +1,88 @@ +annex[0] owner=Issue3177::evaluate + parsedAnnexSubclause : BehaviorAnnex name=behavior_specification + variables[0] : BehaviorVariable name=total + variables[1] : BehaviorVariable name=result + variables[2] : BehaviorVariable name=left + variables[3] : BehaviorVariable name=middle + variables[4] : BehaviorVariable name=right + variables[5] : BehaviorVariable name=flag + states[0] : BehaviorState name=start + states[1] : BehaviorState name=done + transitions[0] : BehaviorTransition + actions[0] : BehaviorActionBlock + content : BehaviorActionSequence + actions[0] : AssignmentAction + target : BehaviorVariableHolder element=flag [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=left [BehaviorVariable] + relations[1] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=middle [BehaviorVariable] + relations[2] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=right [BehaviorVariable] + actions[1] : AssignmentAction + target : BehaviorVariableHolder element=flag [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=left [BehaviorVariable] + relations[1] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=middle [BehaviorVariable] + relations[1] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=right [BehaviorVariable] + actions[2] : AssignmentAction + target : BehaviorVariableHolder element=result [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : BehaviorIntegerLiteral + secondValue : BehaviorIntegerLiteral + actions[3] : AssignmentAction + target : BehaviorVariableHolder element=result [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=total [BehaviorVariable] + factors[1] : Factor + firstValue : BehaviorIntegerLiteral + actions[4] : AssignmentAction + target : BehaviorVariableHolder element=result [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=total [BehaviorVariable] + secondValue : BehaviorIntegerLiteral + secondValue : BehaviorIntegerLiteral diff --git a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_PowerChain.txt b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_PowerChain.txt new file mode 100644 index 0000000000..e31872d2a3 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_PowerChain.txt @@ -0,0 +1,17 @@ +annex[0] owner=PowerChain::evaluate + parsedAnnexSubclause : BehaviorAnnex name=behavior_specification + variables[0] : BehaviorVariable name=total + variables[1] : BehaviorVariable name=result + states[0] : BehaviorState name=start + states[1] : BehaviorState name=done + transitions[0] : BehaviorTransition + actions[0] : BehaviorActionBlock + content : AssignmentAction + target : BehaviorVariableHolder element=result [BehaviorVariable] + valueExpression : ValueExpression + relations[0] : Relation + firstExpression : SimpleExpression + terms[0] : Term + factors[0] : Factor + firstValue : BehaviorVariableHolder element=total [BehaviorVariable] + secondValue : BehaviorIntegerLiteral diff --git a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_RepeatedNot.txt b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_RepeatedNot.txt new file mode 100644 index 0000000000..d3a767214b --- /dev/null +++ b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_RepeatedNot.txt @@ -0,0 +1,9 @@ +annex[0] owner=RepeatedNot::evaluate + parsedAnnexSubclause : BehaviorAnnex name=behavior_specification + variables[0] : BehaviorVariable name=flag + states[0] : BehaviorState name=start + states[1] : BehaviorState name=done + transitions[0] : BehaviorTransition + actions[0] : BehaviorActionBlock + content : SubprogramCallAction + proxy : BehaviorVariableHolder element=flag [BehaviorVariable] diff --git a/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt new file mode 100644 index 0000000000..85b1c8875b --- /dev/null +++ b/ba/org.osate.ba.tests/expected/resolved-model/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt @@ -0,0 +1,10 @@ +annex[0] owner=RepeatedUnaryMinus::evaluate + parsedAnnexSubclause : BehaviorAnnex name=behavior_specification + variables[0] : BehaviorVariable name=total + variables[1] : BehaviorVariable name=result + states[0] : BehaviorState name=start + states[1] : BehaviorState name=done + transitions[0] : BehaviorTransition + actions[0] : BehaviorActionBlock + content : SubprogramCallAction + proxy : BehaviorVariableHolder element=result [BehaviorVariable] diff --git a/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt new file mode 100644 index 0000000000..eead9f39ed --- /dev/null +++ b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_AbsNegatedOperand.txt @@ -0,0 +1,13 @@ +===== annex[0] owner=AbsNegatedOperand::evaluate ===== + +\t\tvariables +\t\t\ttotal : Base_Types::Integer; +\t\t\tresult : Base_Types::Integer; +\t\tstates +\t\t\tstart : initial state; +\t\t\tdone : final state; +\t\ttransitions +\t\t\tstart -[ ]-> done { result := abs -total }; +\t +----- Xtext reparse ----- +reparsed diff --git a/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_Issue3177.txt b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_Issue3177.txt new file mode 100644 index 0000000000..12c0331632 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_Issue3177.txt @@ -0,0 +1,31 @@ +===== annex[0] owner=Issue3177::evaluate ===== + +\t\tvariables +\t\t\ttotal : Base_Types::Integer; +\t\t\tresult : Base_Types::Integer; +\t\t\tleft : Base_Types::Boolean; +\t\t\tmiddle : Base_Types::Boolean; +\t\t\tright : Base_Types::Boolean; +\t\t\tflag : Base_Types::Boolean; +\t\tstates +\t\t\tstart : initial state; +\t\t\tdone : final state; +\t\ttransitions +\t\t\tstart -[ ]-> done { +\t\t\t\t-- D.7 puts every logical operator on one precedence level and associates a level from left to +\t\t\t\t-- right, so this is (left or middle) and right. +\t\t\t\tflag := left or middle and right; +\t\t\t\t-- The parenthesized group is a single operand of and, not a pair of relations spliced into the +\t\t\t\t-- enclosing value expression. +\t\t\t\tflag := left and (middle or right); +\t\t\t\t-- The binary numeric operator binds tighter than the unary adding operator, so this is -(2 ** 2). +\t\t\t\tresult := -2 ** 2; +\t\t\t\t-- The unary adding operator applies to the whole first term, so this is -(total mod 3). The sign +\t\t\t\t-- matters: -(1 mod 3) is -1 while (-1) mod 3 is 2. +\t\t\t\tresult := -total mod 3; +\t\t\t\t-- factor admits one exponentiation, so a chain needs explicit parentheses. +\t\t\t\tresult := (total ** 2) ** 3 +\t\t\t}; +\t +----- Xtext reparse ----- +reparsed diff --git a/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_PowerChain.txt b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_PowerChain.txt new file mode 100644 index 0000000000..231f23fc83 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_PowerChain.txt @@ -0,0 +1,13 @@ +===== annex[0] owner=PowerChain::evaluate ===== + +\t\tvariables +\t\t\ttotal : Base_Types::Integer; +\t\t\tresult : Base_Types::Integer; +\t\tstates +\t\t\tstart : initial state; +\t\t\tdone : final state; +\t\ttransitions +\t\t\tstart -[ ]-> done { result := total ** 2 ** 3 }; +\t +----- Xtext reparse ----- +reparsed diff --git a/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_RepeatedNot.txt b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_RepeatedNot.txt new file mode 100644 index 0000000000..5ca38beae8 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_RepeatedNot.txt @@ -0,0 +1,12 @@ +===== annex[0] owner=RepeatedNot::evaluate ===== + +\t\tvariables +\t\t\tflag : Base_Types::Boolean; +\t\tstates +\t\t\tstart : initial state; +\t\t\tdone : final state; +\t\ttransitions +\t\t\tstart -[ ]-> done { flag := not not flag }; +\t +----- Xtext reparse ----- +reparsed diff --git a/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt new file mode 100644 index 0000000000..660424cfb5 --- /dev/null +++ b/ba/org.osate.ba.tests/expected/unparse/org.osate.ba.tests_models_issue3177_RepeatedUnaryMinus.txt @@ -0,0 +1,13 @@ +===== annex[0] owner=RepeatedUnaryMinus::evaluate ===== + +\t\tvariables +\t\t\ttotal : Base_Types::Integer; +\t\t\tresult : Base_Types::Integer; +\t\tstates +\t\t\tstart : initial state; +\t\t\tdone : final state; +\t\ttransitions +\t\t\tstart -[ ]-> done { result := - -total }; +\t +----- Xtext reparse ----- +reparsed diff --git a/ba/org.osate.ba.tests/models/issue3177/.gitignore b/ba/org.osate.ba.tests/models/issue3177/.gitignore new file mode 100644 index 0000000000..afce51184c --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3177/.gitignore @@ -0,0 +1,2 @@ +/.aadlbin-gen/ +/instances/ diff --git a/ba/org.osate.ba.tests/models/issue3177/.project b/ba/org.osate.ba.tests/models/issue3177/.project new file mode 100644 index 0000000000..96c4b8f283 --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3177/.project @@ -0,0 +1,18 @@ + + + issue3177 + + + + + + org.eclipse.xtext.ui.shared.xtextBuilder + + + + + + org.osate.core.aadlnature + org.eclipse.xtext.ui.shared.xtextNature + + diff --git a/ba/org.osate.ba.tests/models/issue3177/AbsNegatedOperand.aadl b/ba/org.osate.ba.tests/models/issue3177/AbsNegatedOperand.aadl new file mode 100644 index 0000000000..023a6cb532 --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3177/AbsNegatedOperand.aadl @@ -0,0 +1,41 @@ +-- 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. + +-- factor ::= unary_numeric_operator value, so the operand of abs is a value. A numeric literal cannot be +-- negative, so abs -total needs parentheses. +package AbsNegatedOperand +public + with Base_Types; + + subprogram evaluate + annex behavior_specification {** + variables + total : Base_Types::Integer; + result : Base_Types::Integer; + states + start : initial state; + done : final state; + transitions + start -[ ]-> done { result := abs -total }; + **}; + end evaluate; +end AbsNegatedOperand; diff --git a/ba/org.osate.ba.tests/models/issue3177/Issue3177.aadl b/ba/org.osate.ba.tests/models/issue3177/Issue3177.aadl new file mode 100644 index 0000000000..3a36574df2 --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3177/Issue3177.aadl @@ -0,0 +1,57 @@ +-- 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 Issue3177 +public + with Base_Types; + + subprogram evaluate + annex behavior_specification {** + variables + total : Base_Types::Integer; + result : Base_Types::Integer; + left : Base_Types::Boolean; + middle : Base_Types::Boolean; + right : Base_Types::Boolean; + flag : Base_Types::Boolean; + states + start : initial state; + done : final state; + transitions + start -[ ]-> done { + -- D.7 puts every logical operator on one precedence level and associates a level from left to + -- right, so this is (left or middle) and right. + flag := left or middle and right; + -- The parenthesized group is a single operand of and, not a pair of relations spliced into the + -- enclosing value expression. + flag := left and (middle or right); + -- The binary numeric operator binds tighter than the unary adding operator, so this is -(2 ** 2). + result := -2 ** 2; + -- The unary adding operator applies to the whole first term, so this is -(total mod 3). The sign + -- matters: -(1 mod 3) is -1 while (-1) mod 3 is 2. + result := -total mod 3; + -- factor admits one exponentiation, so a chain needs explicit parentheses. + result := (total ** 2) ** 3 + }; + **}; + end evaluate; +end Issue3177; diff --git a/ba/org.osate.ba.tests/models/issue3177/PowerChain.aadl b/ba/org.osate.ba.tests/models/issue3177/PowerChain.aadl new file mode 100644 index 0000000000..0cbf904bfd --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3177/PowerChain.aadl @@ -0,0 +1,41 @@ +-- 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. + +-- factor ::= value [ binary_numeric_operator value ], so an unparenthesized chain of exponentiations is not an +-- admissible expression. +package PowerChain +public + with Base_Types; + + subprogram evaluate + annex behavior_specification {** + variables + total : Base_Types::Integer; + result : Base_Types::Integer; + states + start : initial state; + done : final state; + transitions + start -[ ]-> done { result := total ** 2 ** 3 }; + **}; + end evaluate; +end PowerChain; diff --git a/ba/org.osate.ba.tests/models/issue3177/RepeatedNot.aadl b/ba/org.osate.ba.tests/models/issue3177/RepeatedNot.aadl new file mode 100644 index 0000000000..375bcb0e1a --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3177/RepeatedNot.aadl @@ -0,0 +1,39 @@ +-- 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. + +-- factor ::= unary_boolean_operator value, so the operand of not is a value and not another factor. +package RepeatedNot +public + with Base_Types; + + subprogram evaluate + annex behavior_specification {** + variables + flag : Base_Types::Boolean; + states + start : initial state; + done : final state; + transitions + start -[ ]-> done { flag := not not flag }; + **}; + end evaluate; +end RepeatedNot; diff --git a/ba/org.osate.ba.tests/models/issue3177/RepeatedUnaryMinus.aadl b/ba/org.osate.ba.tests/models/issue3177/RepeatedUnaryMinus.aadl new file mode 100644 index 0000000000..99e30272b8 --- /dev/null +++ b/ba/org.osate.ba.tests/models/issue3177/RepeatedUnaryMinus.aadl @@ -0,0 +1,41 @@ +-- 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. + +-- simple_expression ::= [ unary_adding_operator ] term { binary_adding_operator term }*, so the unary adding +-- operator appears at most once and its operand is a term, never another signed expression. +package RepeatedUnaryMinus +public + with Base_Types; + + subprogram evaluate + annex behavior_specification {** + variables + total : Base_Types::Integer; + result : Base_Types::Integer; + states + start : initial state; + done : final state; + transitions + start -[ ]-> done { result := - -total }; + **}; + end evaluate; +end RepeatedUnaryMinus; diff --git a/ba/org.osate.ba.tests/src/org/osate/ba/tests/Issue3177Test.java b/ba/org.osate.ba.tests/src/org/osate/ba/tests/Issue3177Test.java new file mode 100644 index 0000000000..12473931ba --- /dev/null +++ b/ba/org.osate.ba.tests/src/org/osate/ba/tests/Issue3177Test.java @@ -0,0 +1,328 @@ +/** + * 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.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.util.List; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.util.EcoreUtil; +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.aadl2.DefaultAnnexSubclause; +import org.osate.aadl2.IntegerLiteral; +import org.osate.annexsupport.AnnexRegistry; +import org.osate.annexsupport.AnnexUnparserRegistry; +import org.osate.annexsupport.AnnexUtil; +import org.osate.ba.aadlba.AssignmentAction; +import org.osate.ba.aadlba.BehaviorActionSequence; +import org.osate.ba.aadlba.ElementHolder; +import org.osate.ba.aadlba.Factor; +import org.osate.ba.aadlba.Relation; +import org.osate.ba.aadlba.SimpleExpression; +import org.osate.ba.aadlba.Term; +import org.osate.ba.aadlba.Value; +import org.osate.ba.aadlba.ValueExpression; +import org.osate.testsupport.TestHelper; +import org.osate.xtext.aadl2.ba.behaviorAnnex.BehaviorAnnex; +import org.osate.xtext.aadl2.ba.behaviorAnnex.BehaviorIntegerLiteral; +import org.osate.xtext.aadl2.ba.behaviorAnnex.BinaryExpression; +import org.osate.xtext.aadl2.ba.behaviorAnnex.ReferenceExpression; +import org.osate.xtext.aadl2.ba.behaviorAnnex.UnaryExpression; +import org.osate.xtext.aadl2.ba.util.BehaviorAnnexUtil; + +import com.google.inject.Inject; + +/** + * AS5506/3 Rev. A D.7 puts every logical operator on one precedence level, associates operators of one level from left + * to right, applies the unary adding operator to a whole term, and admits at most one exponentiation and a single + * value as the operand of a unary numeric or boolean operator. Verifies that the declarative model records that + * grouping, that the strict model keeps a parenthesized value expression as one operand instead of splicing it into + * the enclosing expression, that no operator is dropped, and that the forms the standard grammar does not admit are + * rejected. + * + *

+ * The declarative renderings below are prefix trees so that a shape difference cannot be hidden by textual + * association, and the strict renderings follow the standard's value_expression/relation/simple_expression/term/factor + * nesting, parenthesizing a nested value expression only. + */ +@RunWith(XtextRunner.class) +@InjectWith(BehaviorAnnexInjectorProvider.class) +public class Issue3177Test { + private static final String MODELS = "org.osate.ba.tests/models/issue3177/"; + private static final String MODEL = MODELS + "Issue3177.aadl"; + + @Inject + private TestHelper testHelper; + + @Inject + private ValidationTestHelper validationHelper; + + @Test + public void mixedLogicalOperatorsAssociateLeftToRight() throws Exception { + var root = parse(); + assertEquals("(and (or left middle) right)", declarativeExpression(root, 0)); + assertEquals("left or middle and right", strictExpression(root, 0)); + } + + @Test + public void aParenthesizedLogicalGroupStaysOneOperand() throws Exception { + var root = parse(); + assertEquals("(and left (group (or middle right)))", declarativeExpression(root, 1)); + assertEquals("left and (middle or right)", strictExpression(root, 1)); + } + + @Test + public void exponentiationBindsTighterThanTheUnaryAddingOperator() throws Exception { + var root = parse(); + assertEquals("(- (** 2 2))", declarativeExpression(root, 2)); + assertEquals("-2 ** 2", strictExpression(root, 2)); + } + + @Test + public void theUnaryAddingOperatorAppliesToTheWholeTerm() throws Exception { + var root = parse(); + assertEquals("(- (mod total 3))", declarativeExpression(root, 3)); + assertEquals("-total mod 3", strictExpression(root, 3)); + } + + @Test + public void aParenthesizedExponentiationChainIsAccepted() throws Exception { + var root = parse(); + assertEquals("(** (group (** total 2)) 3)", declarativeExpression(root, 4)); + assertEquals("(total ** 2) ** 3", strictExpression(root, 4)); + } + + /** + * Requires the serializer to emit the grouping from the model rather than from the parse text, which is what makes + * an explicitly grouped expression survive a model-to-text round trip. + */ + @Test + public void groupingSurvivesTheUnparserRoundTrip() throws Exception { + var root = parse(); + var copy = EcoreUtil.copy(annex(root).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); + } + var normalized = serialized.replaceAll("\\s+", " ").replace("( ", "(").replace(" )", ")"); + assertTrue(serialized, normalized.contains("left and (middle or right)")); + assertTrue(serialized, normalized.contains("(total ** 2) ** 3")); + + var source = NodeModelUtils.getNode(root).getText(); + var reparsed = testHelper.parseString(source.substring(0, source.indexOf("{**") + 3) + serialized + + source.substring(source.indexOf("**}"))); + validationHelper.assertNoIssues(reparsed); + for (var index = 0; index < 5; index++) { + assertEquals(declarativeExpression(root, index), declarativeExpression(reparsed, index)); + assertEquals(strictExpression(root, index), strictExpression(reparsed, index)); + } + } + + @Test + public void anUnparenthesizedExponentiationChainIsRejected() throws Exception { + assertSyntaxError("PowerChain.aadl"); + } + + @Test + public void aRepeatedUnaryAddingOperatorIsRejected() throws Exception { + assertSyntaxError("RepeatedUnaryMinus.aadl"); + } + + @Test + public void aSignedOperandOfAbsIsRejected() throws Exception { + assertSyntaxError("AbsNegatedOperand.aadl"); + } + + @Test + public void aRepeatedNotIsRejected() throws Exception { + assertSyntaxError("RepeatedNot.aadl"); + } + + /** Keeps the fixture's assignment sequence and the indexes the expectations above use in step. */ + @Test + public void theFixtureSuppliesEveryAssertedExpression() throws Exception { + var root = parse(); + var actions = strictAssignments(root); + assertEquals( + List.of("left or middle and right", "left and (middle or right)", "-2 ** 2", "-total mod 3", + "(total ** 2) ** 3"), + actions.stream().map(action -> strict((ValueExpression) action.getValueExpression())).toList()); + } + + private AadlPackage parse() throws Exception { + var root = testHelper.parseFile(MODEL); + validationHelper.assertNoIssues(root); + return root; + } + + private void assertSyntaxError(final String model) throws Exception { + var result = testHelper.testFile(MODELS + model); + assertTrue(result.getSummary(), result.getIssues().stream().anyMatch(Issue::isSyntaxError)); + } + + private static DefaultAnnexSubclause annex(final AadlPackage root) { + return AnnexUtil.getAllDefaultAnnexSubclauses(root).getFirst(); + } + + private static String declarativeExpression(final AadlPackage root, final int index) { + var source = (BehaviorAnnex) annex(root).getParsedAnnexSubclause(); + var actions = (org.osate.xtext.aadl2.ba.behaviorAnnex.BehaviorActionSequence) source.getTransitions() + .getFirst() + .getActionBlock() + .getContent(); + var assignment = (org.osate.xtext.aadl2.ba.behaviorAnnex.AssignmentAction) actions.getActions().get(index); + return declarative(assignment.getValue()); + } + + private static String declarative(final EObject expression) { + if (expression instanceof BinaryExpression binary) { + return "(" + binary.getOperator() + " " + declarative(binary.getLeft()) + " " + + declarative(binary.getRight()) + ")"; + } + if (expression instanceof UnaryExpression unary) { + return "(" + unary.getOperator() + " " + declarative(unary.getOperand()) + ")"; + } + // Read reflectively so that this test compiles against the model that has no explicit group class yet. + if ("ParenthesizedExpression".equals(expression.eClass().getName())) { + var feature = expression.eClass().getEStructuralFeature("expression"); + assertNotNull("A group must contain its expression", feature); + return "(group " + declarative((EObject) expression.eGet(feature)) + ")"; + } + if (expression instanceof BehaviorIntegerLiteral literal) { + return literal.getValue(); + } + if (expression instanceof ReferenceExpression reference) { + return reference.getReference().getSegments().getFirst().getName(); + } + return expression.eClass().getName(); + } + + private static String strictExpression(final AadlPackage root, final int index) { + return strict((ValueExpression) strictAssignments(root).get(index).getValueExpression()); + } + + private static List strictAssignments(final AadlPackage root) { + var actions = (BehaviorActionSequence) BehaviorAnnexUtil.getStrictModel(annex(root)) + .getTransitions() + .getFirst() + .getActionBlock() + .getContent(); + return actions.getActions().stream().map(AssignmentAction.class::cast).toList(); + } + + private static String strict(final ValueExpression expression) { + var relations = expression.getRelations(); + var operators = expression.getLogicalOperators(); + assertEquals("A value expression needs one logical operator between adjacent relations", + relations.size() - 1, operators.size()); + var result = new StringBuilder(strict(relations.getFirst())); + for (var index = 0; index < operators.size(); index++) { + result.append(' ').append(operators.get(index).getLiteral()).append(' ') + .append(strict(relations.get(index + 1))); + } + return result.toString(); + } + + private static String strict(final Relation relation) { + var result = strict(relation.getFirstExpression()); + if (relation.isSetRelationalOperator()) { + result += " " + relation.getRelationalOperator().getLiteral() + " " + + strict(relation.getSecondExpression()); + } + return result; + } + + private static String strict(final SimpleExpression expression) { + var terms = expression.getTerms(); + var operators = expression.getBinaryAddingOperators(); + assertEquals("A simple expression needs one binary adding operator between adjacent terms", terms.size() - 1, + operators.size()); + var result = new StringBuilder(); + if (expression.isSetUnaryAddingOperator()) { + result.append(expression.getUnaryAddingOperator().getLiteral()); + } + result.append(strict(terms.getFirst())); + for (var index = 0; index < operators.size(); index++) { + result.append(' ').append(operators.get(index).getLiteral()).append(' ') + .append(strict(terms.get(index + 1))); + } + return result.toString(); + } + + private static String strict(final Term term) { + var factors = term.getFactors(); + var operators = term.getMultiplyingOperators(); + assertEquals("A term needs one multiplying operator between adjacent factors", factors.size() - 1, + operators.size()); + var result = new StringBuilder(strict(factors.getFirst())); + for (var index = 0; index < operators.size(); index++) { + result.append(' ').append(operators.get(index).getLiteral()).append(' ') + .append(strict(factors.get(index + 1))); + } + return result.toString(); + } + + private static String strict(final Factor factor) { + if (factor.isSetUnaryNumericOperator()) { + return "abs " + strict(factor.getFirstValue()); + } + if (factor.isSetUnaryBooleanOperator()) { + return "not " + strict(factor.getFirstValue()); + } + var result = strict(factor.getFirstValue()); + if (factor.isSetBinaryNumericOperator()) { + result += " ** " + strict(factor.getSecondValue()); + } + return result; + } + + private static String strict(final Value value) { + if (value instanceof ValueExpression nested) { + return "(" + strict(nested) + ")"; + } + if (value instanceof IntegerLiteral literal) { + return Long.toString(literal.getValue()); + } + if (value instanceof ElementHolder holder) { + return holder.getElement().getName(); + } + return value.eClass().getName(); + } +} diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateAssignmentAction_value_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateAssignmentAction_value_ParenthesizedExpression.gif new file mode 100644 index 0000000000..6d27c0fbe6 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateAssignmentAction_value_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateBinaryExpression_left_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateBinaryExpression_left_ParenthesizedExpression.gif new file mode 100644 index 0000000000..54a8425248 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateBinaryExpression_left_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateBinaryExpression_right_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateBinaryExpression_right_ParenthesizedExpression.gif new file mode 100644 index 0000000000..54a8425248 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateBinaryExpression_right_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateCommunicationAction_parameters_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateCommunicationAction_parameters_ParenthesizedExpression.gif new file mode 100644 index 0000000000..4aa68ea42a Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateCommunicationAction_parameters_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateDoUntilStatement_condition_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateDoUntilStatement_condition_ParenthesizedExpression.gif new file mode 100644 index 0000000000..4b4267d543 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateDoUntilStatement_condition_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateElseIfClause_condition_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateElseIfClause_condition_ParenthesizedExpression.gif new file mode 100644 index 0000000000..932a9f76a5 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateElseIfClause_condition_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateExecuteCondition_value_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateExecuteCondition_value_ParenthesizedExpression.gif new file mode 100644 index 0000000000..58e9c25b43 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateExecuteCondition_value_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateIfStatement_condition_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateIfStatement_condition_ParenthesizedExpression.gif new file mode 100644 index 0000000000..6ce2a47fe5 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateIfStatement_condition_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorBooleanLiteral.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorBooleanLiteral.gif new file mode 100644 index 0000000000..4a47641d8d Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorBooleanLiteral.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorIntegerLiteral.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorIntegerLiteral.gif new file mode 100644 index 0000000000..352731fa17 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorIntegerLiteral.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorRealLiteral.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorRealLiteral.gif new file mode 100644 index 0000000000..56138f044a Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorRealLiteral.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorStringLiteral.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorStringLiteral.gif new file mode 100644 index 0000000000..025f0306c7 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BehaviorStringLiteral.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BinaryExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BinaryExpression.gif new file mode 100644 index 0000000000..67d4e435fc Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_BinaryExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_HashPropertyReference.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_HashPropertyReference.gif new file mode 100644 index 0000000000..56138f044a Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_HashPropertyReference.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ParenthesizedExpression.gif new file mode 100644 index 0000000000..9a2ca8b1cd Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ReferenceExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ReferenceExpression.gif new file mode 100644 index 0000000000..092c9c611b Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ReferenceExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_UnaryExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_UnaryExpression.gif new file mode 100644 index 0000000000..12c2c6315d Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_UnaryExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ValueConstant.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ValueConstant.gif new file mode 100644 index 0000000000..831a90acee Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ValueConstant.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ValueExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ValueExpression.gif new file mode 100644 index 0000000000..967985834e Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateParenthesizedExpression_expression_ValueExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateUnaryExpression_operand_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateUnaryExpression_operand_ParenthesizedExpression.gif new file mode 100644 index 0000000000..e82a8e8c82 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateUnaryExpression_operand_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateWhileStatement_condition_ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateWhileStatement_condition_ParenthesizedExpression.gif new file mode 100644 index 0000000000..8fec2342fa Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/ctool16/CreateWhileStatement_condition_ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/icons/full/obj16/ParenthesizedExpression.gif b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/obj16/ParenthesizedExpression.gif new file mode 100644 index 0000000000..c8d381f0b3 Binary files /dev/null and b/ba/org.osate.xtext.aadl2.ba.edit/icons/full/obj16/ParenthesizedExpression.gif differ diff --git a/ba/org.osate.xtext.aadl2.ba.edit/plugin.properties b/ba/org.osate.xtext.aadl2.ba.edit/plugin.properties index 2b7ebe230a..86ade9f20d 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/plugin.properties +++ b/ba/org.osate.xtext.aadl2.ba.edit/plugin.properties @@ -207,3 +207,5 @@ _UI_ModeSwitchCondition_logicalOperators_feature = Logical Operators _UI_ModeSwitchConjunction_logicalOperators_feature = Logical Operators _UI_ModeSwitchTrigger_reference_feature = Reference _UI_ModeSwitchTrigger_expression_feature = Expression +_UI_ParenthesizedExpression_type = Parenthesized Expression +_UI_ParenthesizedExpression_expression_feature = Expression diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/AssignmentActionItemProvider.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/AssignmentActionItemProvider.java index 913835bf7d..66d7f44f21 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/AssignmentActionItemProvider.java +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/AssignmentActionItemProvider.java @@ -208,6 +208,11 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors (BehaviorAnnexPackage.Literals.ASSIGNMENT_ACTION__VALUE, BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.ASSIGNMENT_ACTION__VALUE, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + newChildDescriptors.add (createChildParameter (BehaviorAnnexPackage.Literals.ASSIGNMENT_ACTION__VALUE, diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/BehaviorAnnexItemProviderAdapterFactory.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/BehaviorAnnexItemProviderAdapterFactory.java index 4f48b8bdb9..fb16e878a4 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/BehaviorAnnexItemProviderAdapterFactory.java +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/BehaviorAnnexItemProviderAdapterFactory.java @@ -919,6 +919,31 @@ public Adapter createValueExpressionAdapter() return valueExpressionItemProvider; } + /** + * This keeps track of the one adapter used for all {@link org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression} instances. + * + * + * @generated + */ + protected ParenthesizedExpressionItemProvider parenthesizedExpressionItemProvider; + + /** + * This creates an adapter for a {@link org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression}. + * + * + * @generated + */ + @Override + public Adapter createParenthesizedExpressionAdapter() + { + if (parenthesizedExpressionItemProvider == null) + { + parenthesizedExpressionItemProvider = new ParenthesizedExpressionItemProvider(this); + } + + return parenthesizedExpressionItemProvider; + } + /** * This keeps track of the one adapter used for all {@link org.osate.xtext.aadl2.ba.behaviorAnnex.ValueConstant} instances. * @@ -1669,6 +1694,7 @@ public void dispose() if (behaviorTimeItemProvider != null) behaviorTimeItemProvider.dispose(); if (integerValueItemProvider != null) integerValueItemProvider.dispose(); if (valueExpressionItemProvider != null) valueExpressionItemProvider.dispose(); + if (parenthesizedExpressionItemProvider != null) parenthesizedExpressionItemProvider.dispose(); if (valueConstantItemProvider != null) valueConstantItemProvider.dispose(); if (behaviorIntegerLiteralItemProvider != null) behaviorIntegerLiteralItemProvider.dispose(); if (behaviorRealLiteralItemProvider != null) behaviorRealLiteralItemProvider.dispose(); diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/BinaryExpressionItemProvider.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/BinaryExpressionItemProvider.java index f091a822f0..4306e62e02 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/BinaryExpressionItemProvider.java +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/BinaryExpressionItemProvider.java @@ -205,6 +205,11 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors (BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__LEFT, BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__LEFT, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + newChildDescriptors.add (createChildParameter (BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__LEFT, @@ -255,6 +260,11 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors (BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__RIGHT, BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__RIGHT, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + newChildDescriptors.add (createChildParameter (BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__RIGHT, diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/CommunicationActionItemProvider.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/CommunicationActionItemProvider.java index dcf09c95f7..bfa5fea553 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/CommunicationActionItemProvider.java +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/CommunicationActionItemProvider.java @@ -385,6 +385,11 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors (BehaviorAnnexPackage.Literals.COMMUNICATION_ACTION__PARAMETERS, BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.COMMUNICATION_ACTION__PARAMETERS, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + newChildDescriptors.add (createChildParameter (BehaviorAnnexPackage.Literals.COMMUNICATION_ACTION__PARAMETERS, diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/DoUntilStatementItemProvider.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/DoUntilStatementItemProvider.java index 0f6d356133..9c86e70555 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/DoUntilStatementItemProvider.java +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/DoUntilStatementItemProvider.java @@ -233,6 +233,11 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors (BehaviorAnnexPackage.Literals.DO_UNTIL_STATEMENT__CONDITION, BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.DO_UNTIL_STATEMENT__CONDITION, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + newChildDescriptors.add (createChildParameter (BehaviorAnnexPackage.Literals.DO_UNTIL_STATEMENT__CONDITION, diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ElseIfClauseItemProvider.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ElseIfClauseItemProvider.java index 075aefed9e..d189b1a7b4 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ElseIfClauseItemProvider.java +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ElseIfClauseItemProvider.java @@ -188,6 +188,11 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors (BehaviorAnnexPackage.Literals.ELSE_IF_CLAUSE__CONDITION, BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.ELSE_IF_CLAUSE__CONDITION, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + newChildDescriptors.add (createChildParameter (BehaviorAnnexPackage.Literals.ELSE_IF_CLAUSE__CONDITION, diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ExecuteConditionItemProvider.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ExecuteConditionItemProvider.java index b30cce31c6..fa16dee119 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ExecuteConditionItemProvider.java +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ExecuteConditionItemProvider.java @@ -241,6 +241,11 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors (BehaviorAnnexPackage.Literals.EXECUTE_CONDITION__VALUE, BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.EXECUTE_CONDITION__VALUE, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + newChildDescriptors.add (createChildParameter (BehaviorAnnexPackage.Literals.EXECUTE_CONDITION__VALUE, diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/IfStatementItemProvider.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/IfStatementItemProvider.java index df8afb0226..70b1808dc7 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/IfStatementItemProvider.java +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/IfStatementItemProvider.java @@ -177,6 +177,11 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors (BehaviorAnnexPackage.Literals.IF_STATEMENT__CONDITION, BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.IF_STATEMENT__CONDITION, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + newChildDescriptors.add (createChildParameter (BehaviorAnnexPackage.Literals.IF_STATEMENT__CONDITION, diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ParenthesizedExpressionItemProvider.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ParenthesizedExpressionItemProvider.java new file mode 100644 index 0000000000..5f3b6753d8 --- /dev/null +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/ParenthesizedExpressionItemProvider.java @@ -0,0 +1,225 @@ +/** + * 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.xtext.aadl2.ba.behaviorAnnex.provider; + + +import java.util.Collection; +import java.util.List; + +import org.eclipse.emf.common.notify.AdapterFactory; +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EStructuralFeature; + +import org.eclipse.emf.edit.provider.IItemPropertyDescriptor; +import org.eclipse.emf.edit.provider.ViewerNotification; + +import org.osate.xtext.aadl2.ba.behaviorAnnex.BehaviorAnnexFactory; +import org.osate.xtext.aadl2.ba.behaviorAnnex.BehaviorAnnexPackage; +import org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression; + +/** + * This is the item provider adapter for a {@link org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression} object. + * + * + * @generated + */ +public class ParenthesizedExpressionItemProvider extends ValueExpressionItemProvider +{ + /** + * This constructs an instance from a factory and a notifier. + * + * + * @generated + */ + public ParenthesizedExpressionItemProvider(AdapterFactory adapterFactory) + { + super(adapterFactory); + } + + /** + * This returns the property descriptors for the adapted class. + * + * + * @generated + */ + @Override + public List getPropertyDescriptors(Object object) + { + if (itemPropertyDescriptors == null) + { + super.getPropertyDescriptors(object); + + } + return itemPropertyDescriptors; + } + + /** + * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an + * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or + * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}. + * + * + * @generated + */ + @Override + public Collection getChildrenFeatures(Object object) + { + if (childrenFeatures == null) + { + super.getChildrenFeatures(object); + childrenFeatures.add(BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION); + } + return childrenFeatures; + } + + /** + * + * + * @generated + */ + @Override + protected EStructuralFeature getChildFeature(Object object, Object child) + { + // Check the type of the specified child object and return the proper feature to use for + // adding (see {@link AddCommand}) it as a child. + + return super.getChildFeature(object, child); + } + + /** + * This returns ParenthesizedExpression.gif. + * + * + * @generated + */ + @Override + public Object getImage(Object object) + { + return overlayImage(object, getResourceLocator().getImage("full/obj16/ParenthesizedExpression")); + } + + /** + * This returns the label text for the adapted class. + * + * + * @generated + */ + @Override + public String getText(Object object) + { + return getString("_UI_ParenthesizedExpression_type"); + } + + + /** + * This handles model notifications by calling {@link #updateChildren} to update any cached + * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}. + * + * + * @generated + */ + @Override + public void notifyChanged(Notification notification) + { + updateChildren(notification); + + switch (notification.getFeatureID(ParenthesizedExpression.class)) + { + case BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION__EXPRESSION: + fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false)); + return; + } + super.notifyChanged(notification); + } + + /** + * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children + * that can be created under this object. + * + * + * @generated + */ + @Override + protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) + { + super.collectNewChildDescriptors(newChildDescriptors, object); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createValueConstant())); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createBehaviorIntegerLiteral())); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createBehaviorRealLiteral())); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createBehaviorStringLiteral())); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createBehaviorBooleanLiteral())); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createReferenceExpression())); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createHashPropertyReference())); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createBinaryExpression())); + + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION, + BehaviorAnnexFactory.eINSTANCE.createUnaryExpression())); + } + +} diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/UnaryExpressionItemProvider.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/UnaryExpressionItemProvider.java index 72bbbf84d0..9f70059964 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/UnaryExpressionItemProvider.java +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/UnaryExpressionItemProvider.java @@ -203,6 +203,11 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors (BehaviorAnnexPackage.Literals.UNARY_EXPRESSION__OPERAND, BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.UNARY_EXPRESSION__OPERAND, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + newChildDescriptors.add (createChildParameter (BehaviorAnnexPackage.Literals.UNARY_EXPRESSION__OPERAND, diff --git a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/WhileStatementItemProvider.java b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/WhileStatementItemProvider.java index ed7d973c1f..15910d5777 100644 --- a/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/WhileStatementItemProvider.java +++ b/ba/org.osate.xtext.aadl2.ba.edit/src/org/osate/xtext/aadl2/ba/behaviorAnnex/provider/WhileStatementItemProvider.java @@ -173,6 +173,11 @@ protected void collectNewChildDescriptors(Collection newChildDescriptors (BehaviorAnnexPackage.Literals.WHILE_STATEMENT__CONDITION, BehaviorAnnexFactory.eINSTANCE.createValueExpression())); + newChildDescriptors.add + (createChildParameter + (BehaviorAnnexPackage.Literals.WHILE_STATEMENT__CONDITION, + BehaviorAnnexFactory.eINSTANCE.createParenthesizedExpression())); + newChildDescriptors.add (createChildParameter (BehaviorAnnexPackage.Literals.WHILE_STATEMENT__CONDITION, 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 9ddd4d5cc7..e67659e96b 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 @@ -64,13 +64,16 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getCommunicationActionAccess().getAlternatives_1_1(), "rule__CommunicationAction__Alternatives_1_1"); builder.put(grammarAccess.getForStatementAccess().getAlternatives_0(), "rule__ForStatement__Alternatives_0"); builder.put(grammarAccess.getIntegerValueAccess().getAlternatives(), "rule__IntegerValue__Alternatives"); + builder.put(grammarAccess.getLogicalOperatorAccess().getAlternatives(), "rule__LogicalOperator__Alternatives"); builder.put(grammarAccess.getLogicalOrOperatorAccess().getAlternatives(), "rule__LogicalOrOperator__Alternatives"); - builder.put(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0(), "rule__RelationalExpression__OperatorAlternatives_1_1_0"); - builder.put(grammarAccess.getAdditiveExpressionAccess().getOperatorAlternatives_1_1_0(), "rule__AdditiveExpression__OperatorAlternatives_1_1_0"); - builder.put(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAlternatives_1_1_0(), "rule__MultiplicativeExpression__OperatorAlternatives_1_1_0"); - builder.put(grammarAccess.getUnaryExpressionAccess().getAlternatives(), "rule__UnaryExpression__Alternatives"); - builder.put(grammarAccess.getUnaryExpressionAccess().getOperatorAlternatives_0_1_0(), "rule__UnaryExpression__OperatorAlternatives_0_1_0"); - builder.put(grammarAccess.getPrimaryExpressionAccess().getAlternatives(), "rule__PrimaryExpression__Alternatives"); + builder.put(grammarAccess.getRelationalOperatorAccess().getAlternatives(), "rule__RelationalOperator__Alternatives"); + builder.put(grammarAccess.getSimpleExpressionAccess().getAlternatives_0(), "rule__SimpleExpression__Alternatives_0"); + builder.put(grammarAccess.getUnaryAddingOperatorAccess().getAlternatives(), "rule__UnaryAddingOperator__Alternatives"); + builder.put(grammarAccess.getBinaryAddingOperatorAccess().getAlternatives(), "rule__BinaryAddingOperator__Alternatives"); + builder.put(grammarAccess.getMultiplyingOperatorAccess().getAlternatives(), "rule__MultiplyingOperator__Alternatives"); + builder.put(grammarAccess.getFactorAccess().getAlternatives(), "rule__Factor__Alternatives"); + builder.put(grammarAccess.getUnaryValueOperatorAccess().getAlternatives(), "rule__UnaryValueOperator__Alternatives"); + builder.put(grammarAccess.getValueAccess().getAlternatives(), "rule__Value__Alternatives"); builder.put(grammarAccess.getValueConstantAccess().getAlternatives(), "rule__ValueConstant__Alternatives"); builder.put(grammarAccess.getBehaviorBooleanLiteralAccess().getAlternatives_1(), "rule__BehaviorBooleanLiteral__Alternatives_1"); builder.put(grammarAccess.getReferenceExpressionAccess().getAlternatives_1(), "rule__ReferenceExpression__Alternatives_1"); @@ -150,22 +153,21 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getElementValuesAccess().getGroup(), "rule__ElementValues__Group__0"); builder.put(grammarAccess.getElementValuesAccess().getGroup_1(), "rule__ElementValues__Group_1__0"); builder.put(grammarAccess.getBehaviorTimeAccess().getGroup(), "rule__BehaviorTime__Group__0"); - builder.put(grammarAccess.getLogicalOrExpressionAccess().getGroup(), "rule__LogicalOrExpression__Group__0"); - builder.put(grammarAccess.getLogicalOrExpressionAccess().getGroup_1(), "rule__LogicalOrExpression__Group_1__0"); + builder.put(grammarAccess.getValueExpressionAccess().getGroup(), "rule__ValueExpression__Group__0"); + builder.put(grammarAccess.getValueExpressionAccess().getGroup_1(), "rule__ValueExpression__Group_1__0"); builder.put(grammarAccess.getLogicalOrOperatorAccess().getGroup_0(), "rule__LogicalOrOperator__Group_0__0"); - builder.put(grammarAccess.getLogicalAndExpressionAccess().getGroup(), "rule__LogicalAndExpression__Group__0"); - builder.put(grammarAccess.getLogicalAndExpressionAccess().getGroup_1(), "rule__LogicalAndExpression__Group_1__0"); builder.put(grammarAccess.getLogicalAndOperatorAccess().getGroup(), "rule__LogicalAndOperator__Group__0"); - builder.put(grammarAccess.getRelationalExpressionAccess().getGroup(), "rule__RelationalExpression__Group__0"); - builder.put(grammarAccess.getRelationalExpressionAccess().getGroup_1(), "rule__RelationalExpression__Group_1__0"); - builder.put(grammarAccess.getAdditiveExpressionAccess().getGroup(), "rule__AdditiveExpression__Group__0"); - builder.put(grammarAccess.getAdditiveExpressionAccess().getGroup_1(), "rule__AdditiveExpression__Group_1__0"); - builder.put(grammarAccess.getMultiplicativeExpressionAccess().getGroup(), "rule__MultiplicativeExpression__Group__0"); - builder.put(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1(), "rule__MultiplicativeExpression__Group_1__0"); - builder.put(grammarAccess.getPowerExpressionAccess().getGroup(), "rule__PowerExpression__Group__0"); - builder.put(grammarAccess.getPowerExpressionAccess().getGroup_1(), "rule__PowerExpression__Group_1__0"); - builder.put(grammarAccess.getUnaryExpressionAccess().getGroup_0(), "rule__UnaryExpression__Group_0__0"); - builder.put(grammarAccess.getPrimaryExpressionAccess().getGroup_2(), "rule__PrimaryExpression__Group_2__0"); + builder.put(grammarAccess.getRelationAccess().getGroup(), "rule__Relation__Group__0"); + builder.put(grammarAccess.getRelationAccess().getGroup_1(), "rule__Relation__Group_1__0"); + builder.put(grammarAccess.getSimpleExpressionAccess().getGroup(), "rule__SimpleExpression__Group__0"); + builder.put(grammarAccess.getSimpleExpressionAccess().getGroup_0_0(), "rule__SimpleExpression__Group_0_0__0"); + builder.put(grammarAccess.getSimpleExpressionAccess().getGroup_1(), "rule__SimpleExpression__Group_1__0"); + builder.put(grammarAccess.getTermAccess().getGroup(), "rule__Term__Group__0"); + builder.put(grammarAccess.getTermAccess().getGroup_1(), "rule__Term__Group_1__0"); + builder.put(grammarAccess.getFactorAccess().getGroup_0(), "rule__Factor__Group_0__0"); + builder.put(grammarAccess.getFactorAccess().getGroup_0_1(), "rule__Factor__Group_0_1__0"); + builder.put(grammarAccess.getFactorAccess().getGroup_1(), "rule__Factor__Group_1__0"); + builder.put(grammarAccess.getParenthesizedExpressionAccess().getGroup(), "rule__ParenthesizedExpression__Group__0"); builder.put(grammarAccess.getBehaviorBooleanLiteralAccess().getGroup(), "rule__BehaviorBooleanLiteral__Group__0"); builder.put(grammarAccess.getReferenceExpressionAccess().getGroup(), "rule__ReferenceExpression__Group__0"); builder.put(grammarAccess.getReferenceExpressionAccess().getGroup_1_2(), "rule__ReferenceExpression__Group_1_2__0"); @@ -330,20 +332,21 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getElementValuesAccess().getUpperAssignment_1_1(), "rule__ElementValues__UpperAssignment_1_1"); builder.put(grammarAccess.getBehaviorTimeAccess().getValueAssignment_0(), "rule__BehaviorTime__ValueAssignment_0"); builder.put(grammarAccess.getBehaviorTimeAccess().getUnitAssignment_1(), "rule__BehaviorTime__UnitAssignment_1"); - builder.put(grammarAccess.getLogicalOrExpressionAccess().getOperatorAssignment_1_1(), "rule__LogicalOrExpression__OperatorAssignment_1_1"); - builder.put(grammarAccess.getLogicalOrExpressionAccess().getRightAssignment_1_2(), "rule__LogicalOrExpression__RightAssignment_1_2"); - builder.put(grammarAccess.getLogicalAndExpressionAccess().getOperatorAssignment_1_1(), "rule__LogicalAndExpression__OperatorAssignment_1_1"); - builder.put(grammarAccess.getLogicalAndExpressionAccess().getRightAssignment_1_2(), "rule__LogicalAndExpression__RightAssignment_1_2"); - builder.put(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1(), "rule__RelationalExpression__OperatorAssignment_1_1"); - builder.put(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2(), "rule__RelationalExpression__RightAssignment_1_2"); - builder.put(grammarAccess.getAdditiveExpressionAccess().getOperatorAssignment_1_1(), "rule__AdditiveExpression__OperatorAssignment_1_1"); - builder.put(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2(), "rule__AdditiveExpression__RightAssignment_1_2"); - builder.put(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_1(), "rule__MultiplicativeExpression__OperatorAssignment_1_1"); - builder.put(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2(), "rule__MultiplicativeExpression__RightAssignment_1_2"); - builder.put(grammarAccess.getPowerExpressionAccess().getOperatorAssignment_1_1(), "rule__PowerExpression__OperatorAssignment_1_1"); - builder.put(grammarAccess.getPowerExpressionAccess().getRightAssignment_1_2(), "rule__PowerExpression__RightAssignment_1_2"); - builder.put(grammarAccess.getUnaryExpressionAccess().getOperatorAssignment_0_1(), "rule__UnaryExpression__OperatorAssignment_0_1"); - builder.put(grammarAccess.getUnaryExpressionAccess().getOperandAssignment_0_2(), "rule__UnaryExpression__OperandAssignment_0_2"); + builder.put(grammarAccess.getValueExpressionAccess().getOperatorAssignment_1_1(), "rule__ValueExpression__OperatorAssignment_1_1"); + builder.put(grammarAccess.getValueExpressionAccess().getRightAssignment_1_2(), "rule__ValueExpression__RightAssignment_1_2"); + builder.put(grammarAccess.getRelationAccess().getOperatorAssignment_1_1(), "rule__Relation__OperatorAssignment_1_1"); + builder.put(grammarAccess.getRelationAccess().getRightAssignment_1_2(), "rule__Relation__RightAssignment_1_2"); + builder.put(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_0_0_1(), "rule__SimpleExpression__OperatorAssignment_0_0_1"); + builder.put(grammarAccess.getSimpleExpressionAccess().getOperandAssignment_0_0_2(), "rule__SimpleExpression__OperandAssignment_0_0_2"); + builder.put(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_1_1(), "rule__SimpleExpression__OperatorAssignment_1_1"); + builder.put(grammarAccess.getSimpleExpressionAccess().getRightAssignment_1_2(), "rule__SimpleExpression__RightAssignment_1_2"); + builder.put(grammarAccess.getTermAccess().getOperatorAssignment_1_1(), "rule__Term__OperatorAssignment_1_1"); + builder.put(grammarAccess.getTermAccess().getRightAssignment_1_2(), "rule__Term__RightAssignment_1_2"); + builder.put(grammarAccess.getFactorAccess().getOperatorAssignment_0_1_1(), "rule__Factor__OperatorAssignment_0_1_1"); + builder.put(grammarAccess.getFactorAccess().getRightAssignment_0_1_2(), "rule__Factor__RightAssignment_0_1_2"); + builder.put(grammarAccess.getFactorAccess().getOperatorAssignment_1_1(), "rule__Factor__OperatorAssignment_1_1"); + builder.put(grammarAccess.getFactorAccess().getOperandAssignment_1_2(), "rule__Factor__OperandAssignment_1_2"); + builder.put(grammarAccess.getParenthesizedExpressionAccess().getExpressionAssignment_1(), "rule__ParenthesizedExpression__ExpressionAssignment_1"); builder.put(grammarAccess.getBehaviorIntegerLiteralAccess().getValueAssignment(), "rule__BehaviorIntegerLiteral__ValueAssignment"); builder.put(grammarAccess.getBehaviorRealLiteralAccess().getValueAssignment(), "rule__BehaviorRealLiteral__ValueAssignment"); builder.put(grammarAccess.getBehaviorStringLiteralAccess().getValueAssignment(), "rule__BehaviorStringLiteral__ValueAssignment"); 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 3caaeb10b6..43063b5a39 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 @@ -997,34 +997,34 @@ ruleValueExpression } : ( - { before(grammarAccess.getValueExpressionAccess().getLogicalOrExpressionParserRuleCall()); } - ruleLogicalOrExpression - { after(grammarAccess.getValueExpressionAccess().getLogicalOrExpressionParserRuleCall()); } + { before(grammarAccess.getValueExpressionAccess().getGroup()); } + (rule__ValueExpression__Group__0) + { after(grammarAccess.getValueExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleLogicalOrExpression -entryRuleLogicalOrExpression +// Entry rule entryRuleLogicalOperator +entryRuleLogicalOperator : -{ before(grammarAccess.getLogicalOrExpressionRule()); } - ruleLogicalOrExpression -{ after(grammarAccess.getLogicalOrExpressionRule()); } +{ before(grammarAccess.getLogicalOperatorRule()); } + ruleLogicalOperator +{ after(grammarAccess.getLogicalOperatorRule()); } EOF ; -// Rule LogicalOrExpression -ruleLogicalOrExpression +// Rule LogicalOperator +ruleLogicalOperator @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalOrExpressionAccess().getGroup()); } - (rule__LogicalOrExpression__Group__0) - { after(grammarAccess.getLogicalOrExpressionAccess().getGroup()); } + { before(grammarAccess.getLogicalOperatorAccess().getAlternatives()); } + (rule__LogicalOperator__Alternatives) + { after(grammarAccess.getLogicalOperatorAccess().getAlternatives()); } ) ; finally { @@ -1056,200 +1056,325 @@ finally { restoreStackSize(stackSize); } -// Entry rule entryRuleLogicalAndExpression -entryRuleLogicalAndExpression +// Entry rule entryRuleLogicalAndOperator +entryRuleLogicalAndOperator : -{ before(grammarAccess.getLogicalAndExpressionRule()); } - ruleLogicalAndExpression -{ after(grammarAccess.getLogicalAndExpressionRule()); } +{ before(grammarAccess.getLogicalAndOperatorRule()); } + ruleLogicalAndOperator +{ after(grammarAccess.getLogicalAndOperatorRule()); } EOF ; -// Rule LogicalAndExpression -ruleLogicalAndExpression +// Rule LogicalAndOperator +ruleLogicalAndOperator @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndExpressionAccess().getGroup()); } - (rule__LogicalAndExpression__Group__0) - { after(grammarAccess.getLogicalAndExpressionAccess().getGroup()); } + { before(grammarAccess.getLogicalAndOperatorAccess().getGroup()); } + (rule__LogicalAndOperator__Group__0) + { after(grammarAccess.getLogicalAndOperatorAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleLogicalAndOperator -entryRuleLogicalAndOperator +// Entry rule entryRuleRelation +entryRuleRelation : -{ before(grammarAccess.getLogicalAndOperatorRule()); } - ruleLogicalAndOperator -{ after(grammarAccess.getLogicalAndOperatorRule()); } +{ before(grammarAccess.getRelationRule()); } + ruleRelation +{ after(grammarAccess.getRelationRule()); } EOF ; -// Rule LogicalAndOperator -ruleLogicalAndOperator +// Rule Relation +ruleRelation @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndOperatorAccess().getGroup()); } - (rule__LogicalAndOperator__Group__0) - { after(grammarAccess.getLogicalAndOperatorAccess().getGroup()); } + { before(grammarAccess.getRelationAccess().getGroup()); } + (rule__Relation__Group__0) + { after(grammarAccess.getRelationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleRelationalOperator +entryRuleRelationalOperator +: +{ before(grammarAccess.getRelationalOperatorRule()); } + ruleRelationalOperator +{ after(grammarAccess.getRelationalOperatorRule()); } + EOF +; + +// Rule RelationalOperator +ruleRelationalOperator + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getRelationalOperatorAccess().getAlternatives()); } + (rule__RelationalOperator__Alternatives) + { after(grammarAccess.getRelationalOperatorAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleSimpleExpression +entryRuleSimpleExpression +: +{ before(grammarAccess.getSimpleExpressionRule()); } + ruleSimpleExpression +{ after(grammarAccess.getSimpleExpressionRule()); } + EOF +; + +// Rule SimpleExpression +ruleSimpleExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getSimpleExpressionAccess().getGroup()); } + (rule__SimpleExpression__Group__0) + { after(grammarAccess.getSimpleExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleUnaryAddingOperator +entryRuleUnaryAddingOperator +: +{ before(grammarAccess.getUnaryAddingOperatorRule()); } + ruleUnaryAddingOperator +{ after(grammarAccess.getUnaryAddingOperatorRule()); } + EOF +; + +// Rule UnaryAddingOperator +ruleUnaryAddingOperator + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUnaryAddingOperatorAccess().getAlternatives()); } + (rule__UnaryAddingOperator__Alternatives) + { after(grammarAccess.getUnaryAddingOperatorAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleBinaryAddingOperator +entryRuleBinaryAddingOperator +: +{ before(grammarAccess.getBinaryAddingOperatorRule()); } + ruleBinaryAddingOperator +{ after(grammarAccess.getBinaryAddingOperatorRule()); } + EOF +; + +// Rule BinaryAddingOperator +ruleBinaryAddingOperator + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getBinaryAddingOperatorAccess().getAlternatives()); } + (rule__BinaryAddingOperator__Alternatives) + { after(grammarAccess.getBinaryAddingOperatorAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleRelationalExpression -entryRuleRelationalExpression +// Entry rule entryRuleTerm +entryRuleTerm : -{ before(grammarAccess.getRelationalExpressionRule()); } - ruleRelationalExpression -{ after(grammarAccess.getRelationalExpressionRule()); } +{ before(grammarAccess.getTermRule()); } + ruleTerm +{ after(grammarAccess.getTermRule()); } EOF ; -// Rule RelationalExpression -ruleRelationalExpression +// Rule Term +ruleTerm @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getGroup()); } - (rule__RelationalExpression__Group__0) - { after(grammarAccess.getRelationalExpressionAccess().getGroup()); } + { before(grammarAccess.getTermAccess().getGroup()); } + (rule__Term__Group__0) + { after(grammarAccess.getTermAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleAdditiveExpression -entryRuleAdditiveExpression +// Entry rule entryRuleMultiplyingOperator +entryRuleMultiplyingOperator : -{ before(grammarAccess.getAdditiveExpressionRule()); } - ruleAdditiveExpression -{ after(grammarAccess.getAdditiveExpressionRule()); } +{ before(grammarAccess.getMultiplyingOperatorRule()); } + ruleMultiplyingOperator +{ after(grammarAccess.getMultiplyingOperatorRule()); } EOF ; -// Rule AdditiveExpression -ruleAdditiveExpression +// Rule MultiplyingOperator +ruleMultiplyingOperator @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getGroup()); } - (rule__AdditiveExpression__Group__0) - { after(grammarAccess.getAdditiveExpressionAccess().getGroup()); } + { before(grammarAccess.getMultiplyingOperatorAccess().getAlternatives()); } + (rule__MultiplyingOperator__Alternatives) + { after(grammarAccess.getMultiplyingOperatorAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleMultiplicativeExpression -entryRuleMultiplicativeExpression +// Entry rule entryRuleFactor +entryRuleFactor : -{ before(grammarAccess.getMultiplicativeExpressionRule()); } - ruleMultiplicativeExpression -{ after(grammarAccess.getMultiplicativeExpressionRule()); } +{ before(grammarAccess.getFactorRule()); } + ruleFactor +{ after(grammarAccess.getFactorRule()); } EOF ; -// Rule MultiplicativeExpression -ruleMultiplicativeExpression +// Rule Factor +ruleFactor @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); } - (rule__MultiplicativeExpression__Group__0) - { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); } + { before(grammarAccess.getFactorAccess().getAlternatives()); } + (rule__Factor__Alternatives) + { after(grammarAccess.getFactorAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRulePowerExpression -entryRulePowerExpression +// Entry rule entryRuleBinaryNumericOperator +entryRuleBinaryNumericOperator : -{ before(grammarAccess.getPowerExpressionRule()); } - rulePowerExpression -{ after(grammarAccess.getPowerExpressionRule()); } +{ before(grammarAccess.getBinaryNumericOperatorRule()); } + ruleBinaryNumericOperator +{ after(grammarAccess.getBinaryNumericOperatorRule()); } EOF ; -// Rule PowerExpression -rulePowerExpression +// Rule BinaryNumericOperator +ruleBinaryNumericOperator @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPowerExpressionAccess().getGroup()); } - (rule__PowerExpression__Group__0) - { after(grammarAccess.getPowerExpressionAccess().getGroup()); } + { before(grammarAccess.getBinaryNumericOperatorAccess().getAsteriskAsteriskKeyword()); } + AsteriskAsterisk + { after(grammarAccess.getBinaryNumericOperatorAccess().getAsteriskAsteriskKeyword()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRuleUnaryExpression -entryRuleUnaryExpression +// Entry rule entryRuleUnaryValueOperator +entryRuleUnaryValueOperator : -{ before(grammarAccess.getUnaryExpressionRule()); } - ruleUnaryExpression -{ after(grammarAccess.getUnaryExpressionRule()); } +{ before(grammarAccess.getUnaryValueOperatorRule()); } + ruleUnaryValueOperator +{ after(grammarAccess.getUnaryValueOperatorRule()); } EOF ; -// Rule UnaryExpression -ruleUnaryExpression +// Rule UnaryValueOperator +ruleUnaryValueOperator @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getAlternatives()); } - (rule__UnaryExpression__Alternatives) - { after(grammarAccess.getUnaryExpressionAccess().getAlternatives()); } + { before(grammarAccess.getUnaryValueOperatorAccess().getAlternatives()); } + (rule__UnaryValueOperator__Alternatives) + { after(grammarAccess.getUnaryValueOperatorAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -// Entry rule entryRulePrimaryExpression -entryRulePrimaryExpression +// Entry rule entryRuleValue +entryRuleValue : -{ before(grammarAccess.getPrimaryExpressionRule()); } - rulePrimaryExpression -{ after(grammarAccess.getPrimaryExpressionRule()); } +{ before(grammarAccess.getValueRule()); } + ruleValue +{ after(grammarAccess.getValueRule()); } EOF ; -// Rule PrimaryExpression -rulePrimaryExpression +// Rule Value +ruleValue @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); } - (rule__PrimaryExpression__Alternatives) - { after(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); } + { before(grammarAccess.getValueAccess().getAlternatives()); } + (rule__Value__Alternatives) + { after(grammarAccess.getValueAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParenthesizedExpression +entryRuleParenthesizedExpression +: +{ before(grammarAccess.getParenthesizedExpressionRule()); } + ruleParenthesizedExpression +{ after(grammarAccess.getParenthesizedExpressionRule()); } + EOF +; + +// Rule ParenthesizedExpression +ruleParenthesizedExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParenthesizedExpressionAccess().getGroup()); } + (rule__ParenthesizedExpression__Group__0) + { after(grammarAccess.getParenthesizedExpressionAccess().getGroup()); } ) ; finally { @@ -2907,6 +3032,27 @@ finally { restoreStackSize(stackSize); } +rule__LogicalOperator__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getLogicalOperatorAccess().getLogicalAndOperatorParserRuleCall_0()); } + ruleLogicalAndOperator + { after(grammarAccess.getLogicalOperatorAccess().getLogicalAndOperatorParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getLogicalOperatorAccess().getLogicalOrOperatorParserRuleCall_1()); } + ruleLogicalOrOperator + { after(grammarAccess.getLogicalOperatorAccess().getLogicalOrOperatorParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + rule__LogicalOrOperator__Alternatives @init { int stackSize = keepStackSize(); @@ -2928,180 +3074,210 @@ finally { restoreStackSize(stackSize); } -rule__RelationalExpression__OperatorAlternatives_1_1_0 +rule__RelationalOperator__Alternatives @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignKeyword_1_1_0_0()); } + { before(grammarAccess.getRelationalOperatorAccess().getEqualsSignKeyword_0()); } EqualsSign - { after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignKeyword_1_1_0_0()); } + { after(grammarAccess.getRelationalOperatorAccess().getEqualsSignKeyword_0()); } ) | ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } + { before(grammarAccess.getRelationalOperatorAccess().getExclamationMarkEqualsSignKeyword_1()); } ExclamationMarkEqualsSign - { after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } + { after(grammarAccess.getRelationalOperatorAccess().getExclamationMarkEqualsSignKeyword_1()); } ) | ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_2()); } + { before(grammarAccess.getRelationalOperatorAccess().getLessThanSignKeyword_2()); } LessThanSign - { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_2()); } + { after(grammarAccess.getRelationalOperatorAccess().getLessThanSignKeyword_2()); } ) | ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } + { before(grammarAccess.getRelationalOperatorAccess().getLessThanSignEqualsSignKeyword_3()); } LessThanSignEqualsSign - { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } + { after(grammarAccess.getRelationalOperatorAccess().getLessThanSignEqualsSignKeyword_3()); } ) | ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } + { before(grammarAccess.getRelationalOperatorAccess().getGreaterThanSignKeyword_4()); } GreaterThanSign - { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } + { after(grammarAccess.getRelationalOperatorAccess().getGreaterThanSignKeyword_4()); } ) | ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_5()); } + { before(grammarAccess.getRelationalOperatorAccess().getGreaterThanSignEqualsSignKeyword_5()); } GreaterThanSignEqualsSign - { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_5()); } + { after(grammarAccess.getRelationalOperatorAccess().getGreaterThanSignEqualsSignKeyword_5()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleExpression__Alternatives_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getSimpleExpressionAccess().getGroup_0_0()); } + (rule__SimpleExpression__Group_0_0__0) + { after(grammarAccess.getSimpleExpressionAccess().getGroup_0_0()); } + ) + | + ( + { before(grammarAccess.getSimpleExpressionAccess().getTermParserRuleCall_0_1()); } + ruleTerm + { after(grammarAccess.getSimpleExpressionAccess().getTermParserRuleCall_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryAddingOperator__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getUnaryAddingOperatorAccess().getHyphenMinusKeyword_0()); } + HyphenMinus + { after(grammarAccess.getUnaryAddingOperatorAccess().getHyphenMinusKeyword_0()); } + ) + | + ( + { before(grammarAccess.getUnaryAddingOperatorAccess().getPlusSignKeyword_1()); } + PlusSign + { after(grammarAccess.getUnaryAddingOperatorAccess().getPlusSignKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__OperatorAlternatives_1_1_0 +rule__BinaryAddingOperator__Alternatives @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getOperatorPlusSignKeyword_1_1_0_0()); } + { before(grammarAccess.getBinaryAddingOperatorAccess().getPlusSignKeyword_0()); } PlusSign - { after(grammarAccess.getAdditiveExpressionAccess().getOperatorPlusSignKeyword_1_1_0_0()); } + { after(grammarAccess.getBinaryAddingOperatorAccess().getPlusSignKeyword_0()); } ) | ( - { before(grammarAccess.getAdditiveExpressionAccess().getOperatorHyphenMinusKeyword_1_1_0_1()); } + { before(grammarAccess.getBinaryAddingOperatorAccess().getHyphenMinusKeyword_1()); } HyphenMinus - { after(grammarAccess.getAdditiveExpressionAccess().getOperatorHyphenMinusKeyword_1_1_0_1()); } + { after(grammarAccess.getBinaryAddingOperatorAccess().getHyphenMinusKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__OperatorAlternatives_1_1_0 +rule__MultiplyingOperator__Alternatives @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskKeyword_1_1_0_0()); } + { before(grammarAccess.getMultiplyingOperatorAccess().getAsteriskKeyword_0()); } Asterisk - { after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskKeyword_1_1_0_0()); } + { after(grammarAccess.getMultiplyingOperatorAccess().getAsteriskKeyword_0()); } ) | ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorSolidusKeyword_1_1_0_1()); } + { before(grammarAccess.getMultiplyingOperatorAccess().getSolidusKeyword_1()); } Solidus - { after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorSolidusKeyword_1_1_0_1()); } + { after(grammarAccess.getMultiplyingOperatorAccess().getSolidusKeyword_1()); } ) | ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorModKeyword_1_1_0_2()); } + { before(grammarAccess.getMultiplyingOperatorAccess().getModKeyword_2()); } Mod - { after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorModKeyword_1_1_0_2()); } + { after(grammarAccess.getMultiplyingOperatorAccess().getModKeyword_2()); } ) | ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorRemKeyword_1_1_0_3()); } + { before(grammarAccess.getMultiplyingOperatorAccess().getRemKeyword_3()); } Rem - { after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorRemKeyword_1_1_0_3()); } + { after(grammarAccess.getMultiplyingOperatorAccess().getRemKeyword_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Alternatives +rule__Factor__Alternatives @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getGroup_0()); } - (rule__UnaryExpression__Group_0__0) - { after(grammarAccess.getUnaryExpressionAccess().getGroup_0()); } + { before(grammarAccess.getFactorAccess().getGroup_0()); } + (rule__Factor__Group_0__0) + { after(grammarAccess.getFactorAccess().getGroup_0()); } ) | ( - { before(grammarAccess.getUnaryExpressionAccess().getPrimaryExpressionParserRuleCall_1()); } - rulePrimaryExpression - { after(grammarAccess.getUnaryExpressionAccess().getPrimaryExpressionParserRuleCall_1()); } + { before(grammarAccess.getFactorAccess().getGroup_1()); } + (rule__Factor__Group_1__0) + { after(grammarAccess.getFactorAccess().getGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__OperatorAlternatives_0_1_0 +rule__UnaryValueOperator__Alternatives @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getOperatorPlusSignKeyword_0_1_0_0()); } - PlusSign - { after(grammarAccess.getUnaryExpressionAccess().getOperatorPlusSignKeyword_0_1_0_0()); } - ) - | - ( - { before(grammarAccess.getUnaryExpressionAccess().getOperatorHyphenMinusKeyword_0_1_0_1()); } - HyphenMinus - { after(grammarAccess.getUnaryExpressionAccess().getOperatorHyphenMinusKeyword_0_1_0_1()); } - ) - | - ( - { before(grammarAccess.getUnaryExpressionAccess().getOperatorAbsKeyword_0_1_0_2()); } + { before(grammarAccess.getUnaryValueOperatorAccess().getAbsKeyword_0()); } Abs - { after(grammarAccess.getUnaryExpressionAccess().getOperatorAbsKeyword_0_1_0_2()); } + { after(grammarAccess.getUnaryValueOperatorAccess().getAbsKeyword_0()); } ) | ( - { before(grammarAccess.getUnaryExpressionAccess().getOperatorNotKeyword_0_1_0_3()); } + { before(grammarAccess.getUnaryValueOperatorAccess().getNotKeyword_1()); } Not - { after(grammarAccess.getUnaryExpressionAccess().getOperatorNotKeyword_0_1_0_3()); } + { after(grammarAccess.getUnaryValueOperatorAccess().getNotKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrimaryExpression__Alternatives +rule__Value__Alternatives @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrimaryExpressionAccess().getValueConstantParserRuleCall_0()); } + { before(grammarAccess.getValueAccess().getValueConstantParserRuleCall_0()); } ruleValueConstant - { after(grammarAccess.getPrimaryExpressionAccess().getValueConstantParserRuleCall_0()); } + { after(grammarAccess.getValueAccess().getValueConstantParserRuleCall_0()); } ) | ( - { before(grammarAccess.getPrimaryExpressionAccess().getReferenceExpressionParserRuleCall_1()); } + { before(grammarAccess.getValueAccess().getReferenceExpressionParserRuleCall_1()); } ruleReferenceExpression - { after(grammarAccess.getPrimaryExpressionAccess().getReferenceExpressionParserRuleCall_1()); } + { after(grammarAccess.getValueAccess().getReferenceExpressionParserRuleCall_1()); } ) | ( - { before(grammarAccess.getPrimaryExpressionAccess().getGroup_2()); } - (rule__PrimaryExpression__Group_2__0) - { after(grammarAccess.getPrimaryExpressionAccess().getGroup_2()); } + { before(grammarAccess.getValueAccess().getParenthesizedExpressionParserRuleCall_2()); } + ruleParenthesizedExpression + { after(grammarAccess.getValueAccess().getParenthesizedExpressionParserRuleCall_2()); } ) ; finally { @@ -9175,53 +9351,53 @@ finally { } -rule__LogicalOrExpression__Group__0 +rule__ValueExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__LogicalOrExpression__Group__0__Impl - rule__LogicalOrExpression__Group__1 + rule__ValueExpression__Group__0__Impl + rule__ValueExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__LogicalOrExpression__Group__0__Impl +rule__ValueExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalOrExpressionAccess().getLogicalAndExpressionParserRuleCall_0()); } - ruleLogicalAndExpression - { after(grammarAccess.getLogicalOrExpressionAccess().getLogicalAndExpressionParserRuleCall_0()); } + { before(grammarAccess.getValueExpressionAccess().getRelationParserRuleCall_0()); } + ruleRelation + { after(grammarAccess.getValueExpressionAccess().getRelationParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LogicalOrExpression__Group__1 +rule__ValueExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__LogicalOrExpression__Group__1__Impl + rule__ValueExpression__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__LogicalOrExpression__Group__1__Impl +rule__ValueExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalOrExpressionAccess().getGroup_1()); } - (rule__LogicalOrExpression__Group_1__0)* - { after(grammarAccess.getLogicalOrExpressionAccess().getGroup_1()); } + { before(grammarAccess.getValueExpressionAccess().getGroup_1()); } + (rule__ValueExpression__Group_1__0)* + { after(grammarAccess.getValueExpressionAccess().getGroup_1()); } ) ; finally { @@ -9229,80 +9405,80 @@ finally { } -rule__LogicalOrExpression__Group_1__0 +rule__ValueExpression__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__LogicalOrExpression__Group_1__0__Impl - rule__LogicalOrExpression__Group_1__1 + rule__ValueExpression__Group_1__0__Impl + rule__ValueExpression__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__LogicalOrExpression__Group_1__0__Impl +rule__ValueExpression__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalOrExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { before(grammarAccess.getValueExpressionAccess().getBinaryExpressionLeftAction_1_0()); } () - { after(grammarAccess.getLogicalOrExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { after(grammarAccess.getValueExpressionAccess().getBinaryExpressionLeftAction_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LogicalOrExpression__Group_1__1 +rule__ValueExpression__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__LogicalOrExpression__Group_1__1__Impl - rule__LogicalOrExpression__Group_1__2 + rule__ValueExpression__Group_1__1__Impl + rule__ValueExpression__Group_1__2 ; finally { restoreStackSize(stackSize); } -rule__LogicalOrExpression__Group_1__1__Impl +rule__ValueExpression__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalOrExpressionAccess().getOperatorAssignment_1_1()); } - (rule__LogicalOrExpression__OperatorAssignment_1_1) - { after(grammarAccess.getLogicalOrExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getValueExpressionAccess().getOperatorAssignment_1_1()); } + (rule__ValueExpression__OperatorAssignment_1_1) + { after(grammarAccess.getValueExpressionAccess().getOperatorAssignment_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__LogicalOrExpression__Group_1__2 +rule__ValueExpression__Group_1__2 @init { int stackSize = keepStackSize(); } : - rule__LogicalOrExpression__Group_1__2__Impl + rule__ValueExpression__Group_1__2__Impl ; finally { restoreStackSize(stackSize); } -rule__LogicalOrExpression__Group_1__2__Impl +rule__ValueExpression__Group_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalOrExpressionAccess().getRightAssignment_1_2()); } - (rule__LogicalOrExpression__RightAssignment_1_2) - { after(grammarAccess.getLogicalOrExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getValueExpressionAccess().getRightAssignment_1_2()); } + (rule__ValueExpression__RightAssignment_1_2) + { after(grammarAccess.getValueExpressionAccess().getRightAssignment_1_2()); } ) ; finally { @@ -9364,53 +9540,53 @@ finally { } -rule__LogicalAndExpression__Group__0 +rule__LogicalAndOperator__Group__0 @init { int stackSize = keepStackSize(); } : - rule__LogicalAndExpression__Group__0__Impl - rule__LogicalAndExpression__Group__1 + rule__LogicalAndOperator__Group__0__Impl + rule__LogicalAndOperator__Group__1 ; finally { restoreStackSize(stackSize); } -rule__LogicalAndExpression__Group__0__Impl +rule__LogicalAndOperator__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndExpressionAccess().getRelationalExpressionParserRuleCall_0()); } - ruleRelationalExpression - { after(grammarAccess.getLogicalAndExpressionAccess().getRelationalExpressionParserRuleCall_0()); } + { before(grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); } + And + { after(grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LogicalAndExpression__Group__1 +rule__LogicalAndOperator__Group__1 @init { int stackSize = keepStackSize(); } : - rule__LogicalAndExpression__Group__1__Impl + rule__LogicalAndOperator__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__LogicalAndExpression__Group__1__Impl +rule__LogicalAndOperator__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndExpressionAccess().getGroup_1()); } - (rule__LogicalAndExpression__Group_1__0)* - { after(grammarAccess.getLogicalAndExpressionAccess().getGroup_1()); } + { before(grammarAccess.getLogicalAndOperatorAccess().getThenKeyword_1()); } + (Then)? + { after(grammarAccess.getLogicalAndOperatorAccess().getThenKeyword_1()); } ) ; finally { @@ -9418,134 +9594,134 @@ finally { } -rule__LogicalAndExpression__Group_1__0 +rule__Relation__Group__0 @init { int stackSize = keepStackSize(); } : - rule__LogicalAndExpression__Group_1__0__Impl - rule__LogicalAndExpression__Group_1__1 + rule__Relation__Group__0__Impl + rule__Relation__Group__1 ; finally { restoreStackSize(stackSize); } -rule__LogicalAndExpression__Group_1__0__Impl +rule__Relation__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndExpressionAccess().getBinaryExpressionLeftAction_1_0()); } - () - { after(grammarAccess.getLogicalAndExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { before(grammarAccess.getRelationAccess().getSimpleExpressionParserRuleCall_0()); } + ruleSimpleExpression + { after(grammarAccess.getRelationAccess().getSimpleExpressionParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LogicalAndExpression__Group_1__1 +rule__Relation__Group__1 @init { int stackSize = keepStackSize(); } : - rule__LogicalAndExpression__Group_1__1__Impl - rule__LogicalAndExpression__Group_1__2 + rule__Relation__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__LogicalAndExpression__Group_1__1__Impl +rule__Relation__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndExpressionAccess().getOperatorAssignment_1_1()); } - (rule__LogicalAndExpression__OperatorAssignment_1_1) - { after(grammarAccess.getLogicalAndExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getRelationAccess().getGroup_1()); } + (rule__Relation__Group_1__0)? + { after(grammarAccess.getRelationAccess().getGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__LogicalAndExpression__Group_1__2 + +rule__Relation__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__LogicalAndExpression__Group_1__2__Impl + rule__Relation__Group_1__0__Impl + rule__Relation__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__LogicalAndExpression__Group_1__2__Impl +rule__Relation__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndExpressionAccess().getRightAssignment_1_2()); } - (rule__LogicalAndExpression__RightAssignment_1_2) - { after(grammarAccess.getLogicalAndExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getRelationAccess().getBinaryExpressionLeftAction_1_0()); } + () + { after(grammarAccess.getRelationAccess().getBinaryExpressionLeftAction_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__LogicalAndOperator__Group__0 +rule__Relation__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__LogicalAndOperator__Group__0__Impl - rule__LogicalAndOperator__Group__1 + rule__Relation__Group_1__1__Impl + rule__Relation__Group_1__2 ; finally { restoreStackSize(stackSize); } -rule__LogicalAndOperator__Group__0__Impl +rule__Relation__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); } - And - { after(grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); } + { before(grammarAccess.getRelationAccess().getOperatorAssignment_1_1()); } + (rule__Relation__OperatorAssignment_1_1) + { after(grammarAccess.getRelationAccess().getOperatorAssignment_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__LogicalAndOperator__Group__1 +rule__Relation__Group_1__2 @init { int stackSize = keepStackSize(); } : - rule__LogicalAndOperator__Group__1__Impl + rule__Relation__Group_1__2__Impl ; finally { restoreStackSize(stackSize); } -rule__LogicalAndOperator__Group__1__Impl +rule__Relation__Group_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndOperatorAccess().getThenKeyword_1()); } - (Then)? - { after(grammarAccess.getLogicalAndOperatorAccess().getThenKeyword_1()); } + { before(grammarAccess.getRelationAccess().getRightAssignment_1_2()); } + (rule__Relation__RightAssignment_1_2) + { after(grammarAccess.getRelationAccess().getRightAssignment_1_2()); } ) ; finally { @@ -9553,53 +9729,53 @@ finally { } -rule__RelationalExpression__Group__0 +rule__SimpleExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group__0__Impl - rule__RelationalExpression__Group__1 + rule__SimpleExpression__Group__0__Impl + rule__SimpleExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__0__Impl +rule__SimpleExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } - ruleAdditiveExpression - { after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } + { before(grammarAccess.getSimpleExpressionAccess().getAlternatives_0()); } + (rule__SimpleExpression__Alternatives_0) + { after(grammarAccess.getSimpleExpressionAccess().getAlternatives_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__1 +rule__SimpleExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group__1__Impl + rule__SimpleExpression__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__1__Impl +rule__SimpleExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } - (rule__RelationalExpression__Group_1__0)? - { after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } + { before(grammarAccess.getSimpleExpressionAccess().getGroup_1()); } + (rule__SimpleExpression__Group_1__0)* + { after(grammarAccess.getSimpleExpressionAccess().getGroup_1()); } ) ; finally { @@ -9607,80 +9783,80 @@ finally { } -rule__RelationalExpression__Group_1__0 +rule__SimpleExpression__Group_0_0__0 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__0__Impl - rule__RelationalExpression__Group_1__1 + rule__SimpleExpression__Group_0_0__0__Impl + rule__SimpleExpression__Group_0_0__1 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__0__Impl +rule__SimpleExpression__Group_0_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { before(grammarAccess.getSimpleExpressionAccess().getUnaryExpressionAction_0_0_0()); } () - { after(grammarAccess.getRelationalExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { after(grammarAccess.getSimpleExpressionAccess().getUnaryExpressionAction_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__1 +rule__SimpleExpression__Group_0_0__1 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__1__Impl - rule__RelationalExpression__Group_1__2 + rule__SimpleExpression__Group_0_0__1__Impl + rule__SimpleExpression__Group_0_0__2 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__1__Impl +rule__SimpleExpression__Group_0_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } - (rule__RelationalExpression__OperatorAssignment_1_1) - { after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_0_0_1()); } + (rule__SimpleExpression__OperatorAssignment_0_0_1) + { after(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_0_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__2 +rule__SimpleExpression__Group_0_0__2 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__2__Impl + rule__SimpleExpression__Group_0_0__2__Impl ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__2__Impl +rule__SimpleExpression__Group_0_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } - (rule__RelationalExpression__RightAssignment_1_2) - { after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getSimpleExpressionAccess().getOperandAssignment_0_0_2()); } + (rule__SimpleExpression__OperandAssignment_0_0_2) + { after(grammarAccess.getSimpleExpressionAccess().getOperandAssignment_0_0_2()); } ) ; finally { @@ -9688,134 +9864,80 @@ finally { } -rule__AdditiveExpression__Group__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__AdditiveExpression__Group__0__Impl - rule__AdditiveExpression__Group__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__AdditiveExpression__Group__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } - ruleMultiplicativeExpression - { after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } -) -; -finally { - restoreStackSize(stackSize); -} - -rule__AdditiveExpression__Group__1 +rule__SimpleExpression__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group__1__Impl + rule__SimpleExpression__Group_1__0__Impl + rule__SimpleExpression__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group__1__Impl +rule__SimpleExpression__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } - (rule__AdditiveExpression__Group_1__0)* - { after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } -) -; -finally { - restoreStackSize(stackSize); -} - - -rule__AdditiveExpression__Group_1__0 - @init { - int stackSize = keepStackSize(); - } -: - rule__AdditiveExpression__Group_1__0__Impl - rule__AdditiveExpression__Group_1__1 -; -finally { - restoreStackSize(stackSize); -} - -rule__AdditiveExpression__Group_1__0__Impl - @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { before(grammarAccess.getSimpleExpressionAccess().getBinaryExpressionLeftAction_1_0()); } () - { after(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { after(grammarAccess.getSimpleExpressionAccess().getBinaryExpressionLeftAction_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__1 +rule__SimpleExpression__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__1__Impl - rule__AdditiveExpression__Group_1__2 + rule__SimpleExpression__Group_1__1__Impl + rule__SimpleExpression__Group_1__2 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__1__Impl +rule__SimpleExpression__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getOperatorAssignment_1_1()); } - (rule__AdditiveExpression__OperatorAssignment_1_1) - { after(grammarAccess.getAdditiveExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_1_1()); } + (rule__SimpleExpression__OperatorAssignment_1_1) + { after(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__2 +rule__SimpleExpression__Group_1__2 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__2__Impl + rule__SimpleExpression__Group_1__2__Impl ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__2__Impl +rule__SimpleExpression__Group_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); } - (rule__AdditiveExpression__RightAssignment_1_2) - { after(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getSimpleExpressionAccess().getRightAssignment_1_2()); } + (rule__SimpleExpression__RightAssignment_1_2) + { after(grammarAccess.getSimpleExpressionAccess().getRightAssignment_1_2()); } ) ; finally { @@ -9823,53 +9945,53 @@ finally { } -rule__MultiplicativeExpression__Group__0 +rule__Term__Group__0 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group__0__Impl - rule__MultiplicativeExpression__Group__1 + rule__Term__Group__0__Impl + rule__Term__Group__1 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__0__Impl +rule__Term__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getPowerExpressionParserRuleCall_0()); } - rulePowerExpression - { after(grammarAccess.getMultiplicativeExpressionAccess().getPowerExpressionParserRuleCall_0()); } + { before(grammarAccess.getTermAccess().getFactorParserRuleCall_0()); } + ruleFactor + { after(grammarAccess.getTermAccess().getFactorParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__1 +rule__Term__Group__1 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group__1__Impl + rule__Term__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__1__Impl +rule__Term__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } - (rule__MultiplicativeExpression__Group_1__0)* - { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } + { before(grammarAccess.getTermAccess().getGroup_1()); } + (rule__Term__Group_1__0)* + { after(grammarAccess.getTermAccess().getGroup_1()); } ) ; finally { @@ -9877,80 +9999,80 @@ finally { } -rule__MultiplicativeExpression__Group_1__0 +rule__Term__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__0__Impl - rule__MultiplicativeExpression__Group_1__1 + rule__Term__Group_1__0__Impl + rule__Term__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__0__Impl +rule__Term__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { before(grammarAccess.getTermAccess().getBinaryExpressionLeftAction_1_0()); } () - { after(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { after(grammarAccess.getTermAccess().getBinaryExpressionLeftAction_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__1 +rule__Term__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__1__Impl - rule__MultiplicativeExpression__Group_1__2 + rule__Term__Group_1__1__Impl + rule__Term__Group_1__2 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__1__Impl +rule__Term__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_1()); } - (rule__MultiplicativeExpression__OperatorAssignment_1_1) - { after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getTermAccess().getOperatorAssignment_1_1()); } + (rule__Term__OperatorAssignment_1_1) + { after(grammarAccess.getTermAccess().getOperatorAssignment_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__2 +rule__Term__Group_1__2 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__2__Impl + rule__Term__Group_1__2__Impl ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__2__Impl +rule__Term__Group_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); } - (rule__MultiplicativeExpression__RightAssignment_1_2) - { after(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getTermAccess().getRightAssignment_1_2()); } + (rule__Term__RightAssignment_1_2) + { after(grammarAccess.getTermAccess().getRightAssignment_1_2()); } ) ; finally { @@ -9958,53 +10080,53 @@ finally { } -rule__PowerExpression__Group__0 +rule__Factor__Group_0__0 @init { int stackSize = keepStackSize(); } : - rule__PowerExpression__Group__0__Impl - rule__PowerExpression__Group__1 + rule__Factor__Group_0__0__Impl + rule__Factor__Group_0__1 ; finally { restoreStackSize(stackSize); } -rule__PowerExpression__Group__0__Impl +rule__Factor__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPowerExpressionAccess().getUnaryExpressionParserRuleCall_0()); } - ruleUnaryExpression - { after(grammarAccess.getPowerExpressionAccess().getUnaryExpressionParserRuleCall_0()); } + { before(grammarAccess.getFactorAccess().getValueParserRuleCall_0_0()); } + ruleValue + { after(grammarAccess.getFactorAccess().getValueParserRuleCall_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__PowerExpression__Group__1 +rule__Factor__Group_0__1 @init { int stackSize = keepStackSize(); } : - rule__PowerExpression__Group__1__Impl + rule__Factor__Group_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__PowerExpression__Group__1__Impl +rule__Factor__Group_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPowerExpressionAccess().getGroup_1()); } - (rule__PowerExpression__Group_1__0)? - { after(grammarAccess.getPowerExpressionAccess().getGroup_1()); } + { before(grammarAccess.getFactorAccess().getGroup_0_1()); } + (rule__Factor__Group_0_1__0)? + { after(grammarAccess.getFactorAccess().getGroup_0_1()); } ) ; finally { @@ -10012,80 +10134,80 @@ finally { } -rule__PowerExpression__Group_1__0 +rule__Factor__Group_0_1__0 @init { int stackSize = keepStackSize(); } : - rule__PowerExpression__Group_1__0__Impl - rule__PowerExpression__Group_1__1 + rule__Factor__Group_0_1__0__Impl + rule__Factor__Group_0_1__1 ; finally { restoreStackSize(stackSize); } -rule__PowerExpression__Group_1__0__Impl +rule__Factor__Group_0_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPowerExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { before(grammarAccess.getFactorAccess().getBinaryExpressionLeftAction_0_1_0()); } () - { after(grammarAccess.getPowerExpressionAccess().getBinaryExpressionLeftAction_1_0()); } + { after(grammarAccess.getFactorAccess().getBinaryExpressionLeftAction_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__PowerExpression__Group_1__1 +rule__Factor__Group_0_1__1 @init { int stackSize = keepStackSize(); } : - rule__PowerExpression__Group_1__1__Impl - rule__PowerExpression__Group_1__2 + rule__Factor__Group_0_1__1__Impl + rule__Factor__Group_0_1__2 ; finally { restoreStackSize(stackSize); } -rule__PowerExpression__Group_1__1__Impl +rule__Factor__Group_0_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPowerExpressionAccess().getOperatorAssignment_1_1()); } - (rule__PowerExpression__OperatorAssignment_1_1) - { after(grammarAccess.getPowerExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getFactorAccess().getOperatorAssignment_0_1_1()); } + (rule__Factor__OperatorAssignment_0_1_1) + { after(grammarAccess.getFactorAccess().getOperatorAssignment_0_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__PowerExpression__Group_1__2 +rule__Factor__Group_0_1__2 @init { int stackSize = keepStackSize(); } : - rule__PowerExpression__Group_1__2__Impl + rule__Factor__Group_0_1__2__Impl ; finally { restoreStackSize(stackSize); } -rule__PowerExpression__Group_1__2__Impl +rule__Factor__Group_0_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPowerExpressionAccess().getRightAssignment_1_2()); } - (rule__PowerExpression__RightAssignment_1_2) - { after(grammarAccess.getPowerExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getFactorAccess().getRightAssignment_0_1_2()); } + (rule__Factor__RightAssignment_0_1_2) + { after(grammarAccess.getFactorAccess().getRightAssignment_0_1_2()); } ) ; finally { @@ -10093,80 +10215,80 @@ finally { } -rule__UnaryExpression__Group_0__0 +rule__Factor__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__UnaryExpression__Group_0__0__Impl - rule__UnaryExpression__Group_0__1 + rule__Factor__Group_1__0__Impl + rule__Factor__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group_0__0__Impl +rule__Factor__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_0_0()); } + { before(grammarAccess.getFactorAccess().getUnaryExpressionAction_1_0()); } () - { after(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_0_0()); } + { after(grammarAccess.getFactorAccess().getUnaryExpressionAction_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group_0__1 +rule__Factor__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__UnaryExpression__Group_0__1__Impl - rule__UnaryExpression__Group_0__2 + rule__Factor__Group_1__1__Impl + rule__Factor__Group_1__2 ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group_0__1__Impl +rule__Factor__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getOperatorAssignment_0_1()); } - (rule__UnaryExpression__OperatorAssignment_0_1) - { after(grammarAccess.getUnaryExpressionAccess().getOperatorAssignment_0_1()); } + { before(grammarAccess.getFactorAccess().getOperatorAssignment_1_1()); } + (rule__Factor__OperatorAssignment_1_1) + { after(grammarAccess.getFactorAccess().getOperatorAssignment_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group_0__2 +rule__Factor__Group_1__2 @init { int stackSize = keepStackSize(); } : - rule__UnaryExpression__Group_0__2__Impl + rule__Factor__Group_1__2__Impl ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group_0__2__Impl +rule__Factor__Group_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getOperandAssignment_0_2()); } - (rule__UnaryExpression__OperandAssignment_0_2) - { after(grammarAccess.getUnaryExpressionAccess().getOperandAssignment_0_2()); } + { before(grammarAccess.getFactorAccess().getOperandAssignment_1_2()); } + (rule__Factor__OperandAssignment_1_2) + { after(grammarAccess.getFactorAccess().getOperandAssignment_1_2()); } ) ; finally { @@ -10174,80 +10296,80 @@ finally { } -rule__PrimaryExpression__Group_2__0 +rule__ParenthesizedExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__PrimaryExpression__Group_2__0__Impl - rule__PrimaryExpression__Group_2__1 + rule__ParenthesizedExpression__Group__0__Impl + rule__ParenthesizedExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__PrimaryExpression__Group_2__0__Impl +rule__ParenthesizedExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_2_0()); } + { before(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } LeftParenthesis - { after(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_2_0()); } + { after(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrimaryExpression__Group_2__1 +rule__ParenthesizedExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__PrimaryExpression__Group_2__1__Impl - rule__PrimaryExpression__Group_2__2 + rule__ParenthesizedExpression__Group__1__Impl + rule__ParenthesizedExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__PrimaryExpression__Group_2__1__Impl +rule__ParenthesizedExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrimaryExpressionAccess().getValueExpressionParserRuleCall_2_1()); } - ruleValueExpression - { after(grammarAccess.getPrimaryExpressionAccess().getValueExpressionParserRuleCall_2_1()); } + { before(grammarAccess.getParenthesizedExpressionAccess().getExpressionAssignment_1()); } + (rule__ParenthesizedExpression__ExpressionAssignment_1) + { after(grammarAccess.getParenthesizedExpressionAccess().getExpressionAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrimaryExpression__Group_2__2 +rule__ParenthesizedExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__PrimaryExpression__Group_2__2__Impl + rule__ParenthesizedExpression__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__PrimaryExpression__Group_2__2__Impl +rule__ParenthesizedExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_2_2()); } + { before(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); } RightParenthesis - { after(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_2_2()); } + { after(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); } ) ; finally { @@ -15773,214 +15895,225 @@ finally { restoreStackSize(stackSize); } -rule__LogicalOrExpression__OperatorAssignment_1_1 +rule__ValueExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalOrExpressionAccess().getOperatorLogicalOrOperatorParserRuleCall_1_1_0()); } - ruleLogicalOrOperator - { after(grammarAccess.getLogicalOrExpressionAccess().getOperatorLogicalOrOperatorParserRuleCall_1_1_0()); } + { before(grammarAccess.getValueExpressionAccess().getOperatorLogicalOperatorParserRuleCall_1_1_0()); } + ruleLogicalOperator + { after(grammarAccess.getValueExpressionAccess().getOperatorLogicalOperatorParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LogicalOrExpression__RightAssignment_1_2 +rule__ValueExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalOrExpressionAccess().getRightLogicalAndExpressionParserRuleCall_1_2_0()); } - ruleLogicalAndExpression - { after(grammarAccess.getLogicalOrExpressionAccess().getRightLogicalAndExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getValueExpressionAccess().getRightRelationParserRuleCall_1_2_0()); } + ruleRelation + { after(grammarAccess.getValueExpressionAccess().getRightRelationParserRuleCall_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LogicalAndExpression__OperatorAssignment_1_1 +rule__Relation__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndExpressionAccess().getOperatorLogicalAndOperatorParserRuleCall_1_1_0()); } - ruleLogicalAndOperator - { after(grammarAccess.getLogicalAndExpressionAccess().getOperatorLogicalAndOperatorParserRuleCall_1_1_0()); } + { before(grammarAccess.getRelationAccess().getOperatorRelationalOperatorParserRuleCall_1_1_0()); } + ruleRelationalOperator + { after(grammarAccess.getRelationAccess().getOperatorRelationalOperatorParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LogicalAndExpression__RightAssignment_1_2 +rule__Relation__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLogicalAndExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } - ruleRelationalExpression - { after(grammarAccess.getLogicalAndExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getRelationAccess().getRightSimpleExpressionParserRuleCall_1_2_0()); } + ruleSimpleExpression + { after(grammarAccess.getRelationAccess().getRightSimpleExpressionParserRuleCall_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__OperatorAssignment_1_1 +rule__SimpleExpression__OperatorAssignment_0_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); } - (rule__RelationalExpression__OperatorAlternatives_1_1_0) - { after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); } + { before(grammarAccess.getSimpleExpressionAccess().getOperatorUnaryAddingOperatorParserRuleCall_0_0_1_0()); } + ruleUnaryAddingOperator + { after(grammarAccess.getSimpleExpressionAccess().getOperatorUnaryAddingOperatorParserRuleCall_0_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__RightAssignment_1_2 +rule__SimpleExpression__OperandAssignment_0_0_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } - ruleAdditiveExpression - { after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getSimpleExpressionAccess().getOperandTermParserRuleCall_0_0_2_0()); } + ruleTerm + { after(grammarAccess.getSimpleExpressionAccess().getOperandTermParserRuleCall_0_0_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__OperatorAssignment_1_1 +rule__SimpleExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getOperatorAlternatives_1_1_0()); } - (rule__AdditiveExpression__OperatorAlternatives_1_1_0) - { after(grammarAccess.getAdditiveExpressionAccess().getOperatorAlternatives_1_1_0()); } + { before(grammarAccess.getSimpleExpressionAccess().getOperatorBinaryAddingOperatorParserRuleCall_1_1_0()); } + ruleBinaryAddingOperator + { after(grammarAccess.getSimpleExpressionAccess().getOperatorBinaryAddingOperatorParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__RightAssignment_1_2 +rule__SimpleExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); } - ruleMultiplicativeExpression - { after(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getSimpleExpressionAccess().getRightTermParserRuleCall_1_2_0()); } + ruleTerm + { after(grammarAccess.getSimpleExpressionAccess().getRightTermParserRuleCall_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__OperatorAssignment_1_1 +rule__Term__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAlternatives_1_1_0()); } - (rule__MultiplicativeExpression__OperatorAlternatives_1_1_0) - { after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAlternatives_1_1_0()); } + { before(grammarAccess.getTermAccess().getOperatorMultiplyingOperatorParserRuleCall_1_1_0()); } + ruleMultiplyingOperator + { after(grammarAccess.getTermAccess().getOperatorMultiplyingOperatorParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__RightAssignment_1_2 +rule__Term__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); } - rulePowerExpression - { after(grammarAccess.getMultiplicativeExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getTermAccess().getRightFactorParserRuleCall_1_2_0()); } + ruleFactor + { after(grammarAccess.getTermAccess().getRightFactorParserRuleCall_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__PowerExpression__OperatorAssignment_1_1 +rule__Factor__OperatorAssignment_0_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPowerExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_0()); } - ( - { before(grammarAccess.getPowerExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_0()); } - AsteriskAsterisk - { after(grammarAccess.getPowerExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_0()); } - ) - { after(grammarAccess.getPowerExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_0()); } + { before(grammarAccess.getFactorAccess().getOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0()); } + ruleBinaryNumericOperator + { after(grammarAccess.getFactorAccess().getOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Factor__RightAssignment_0_1_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getFactorAccess().getRightValueParserRuleCall_0_1_2_0()); } + ruleValue + { after(grammarAccess.getFactorAccess().getRightValueParserRuleCall_0_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__PowerExpression__RightAssignment_1_2 +rule__Factor__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getPowerExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); } - rulePowerExpression - { after(grammarAccess.getPowerExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getFactorAccess().getOperatorUnaryValueOperatorParserRuleCall_1_1_0()); } + ruleUnaryValueOperator + { after(grammarAccess.getFactorAccess().getOperatorUnaryValueOperatorParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__OperatorAssignment_0_1 +rule__Factor__OperandAssignment_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getOperatorAlternatives_0_1_0()); } - (rule__UnaryExpression__OperatorAlternatives_0_1_0) - { after(grammarAccess.getUnaryExpressionAccess().getOperatorAlternatives_0_1_0()); } + { before(grammarAccess.getFactorAccess().getOperandValueParserRuleCall_1_2_0()); } + ruleValue + { after(grammarAccess.getFactorAccess().getOperandValueParserRuleCall_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__OperandAssignment_0_2 +rule__ParenthesizedExpression__ExpressionAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getOperandUnaryExpressionParserRuleCall_0_2_0()); } - ruleUnaryExpression - { after(grammarAccess.getUnaryExpressionAccess().getOperandUnaryExpressionParserRuleCall_0_2_0()); } + { before(grammarAccess.getParenthesizedExpressionAccess().getExpressionValueExpressionParserRuleCall_1_0()); } + ruleValueExpression + { after(grammarAccess.getParenthesizedExpressionAccess().getExpressionValueExpressionParserRuleCall_1_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 aaa279ee68..b07b89e27a 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 @@ -3107,28 +3107,34 @@ public final void entryRuleValueExpression() throws RecognitionException { // $ANTLR start "ruleValueExpression" - // InternalBehaviorAnnexParser.g:994:1: ruleValueExpression : ( ruleLogicalOrExpression ) ; + // InternalBehaviorAnnexParser.g:994:1: ruleValueExpression : ( ( rule__ValueExpression__Group__0 ) ) ; public final void ruleValueExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:998:2: ( ( ruleLogicalOrExpression ) ) - // InternalBehaviorAnnexParser.g:999:2: ( ruleLogicalOrExpression ) + // InternalBehaviorAnnexParser.g:998:2: ( ( ( rule__ValueExpression__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:999:2: ( ( rule__ValueExpression__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:999:2: ( ruleLogicalOrExpression ) - // InternalBehaviorAnnexParser.g:1000:3: ruleLogicalOrExpression + // InternalBehaviorAnnexParser.g:999:2: ( ( rule__ValueExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1000:3: ( rule__ValueExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getValueExpressionAccess().getLogicalOrExpressionParserRuleCall()); + before(grammarAccess.getValueExpressionAccess().getGroup()); } + // InternalBehaviorAnnexParser.g:1001:3: ( rule__ValueExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1001:4: rule__ValueExpression__Group__0 + { pushFollow(FollowSets000.FOLLOW_2); - ruleLogicalOrExpression(); + rule__ValueExpression__Group__0(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getValueExpressionAccess().getLogicalOrExpressionParserRuleCall()); + after(grammarAccess.getValueExpressionAccess().getGroup()); } } @@ -3151,23 +3157,23 @@ public final void ruleValueExpression() throws RecognitionException { // $ANTLR end "ruleValueExpression" - // $ANTLR start "entryRuleLogicalOrExpression" - // InternalBehaviorAnnexParser.g:1010:1: entryRuleLogicalOrExpression : ruleLogicalOrExpression EOF ; - public final void entryRuleLogicalOrExpression() throws RecognitionException { + // $ANTLR start "entryRuleLogicalOperator" + // InternalBehaviorAnnexParser.g:1010:1: entryRuleLogicalOperator : ruleLogicalOperator EOF ; + public final void entryRuleLogicalOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1011:1: ( ruleLogicalOrExpression EOF ) - // InternalBehaviorAnnexParser.g:1012:1: ruleLogicalOrExpression EOF + // InternalBehaviorAnnexParser.g:1011:1: ( ruleLogicalOperator EOF ) + // InternalBehaviorAnnexParser.g:1012:1: ruleLogicalOperator EOF { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrExpressionRule()); + before(grammarAccess.getLogicalOperatorRule()); } pushFollow(FollowSets000.FOLLOW_1); - ruleLogicalOrExpression(); + ruleLogicalOperator(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrExpressionRule()); + after(grammarAccess.getLogicalOperatorRule()); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -3182,30 +3188,30 @@ public final void entryRuleLogicalOrExpression() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleLogicalOrExpression" + // $ANTLR end "entryRuleLogicalOperator" - // $ANTLR start "ruleLogicalOrExpression" - // InternalBehaviorAnnexParser.g:1019:1: ruleLogicalOrExpression : ( ( rule__LogicalOrExpression__Group__0 ) ) ; - public final void ruleLogicalOrExpression() throws RecognitionException { + // $ANTLR start "ruleLogicalOperator" + // InternalBehaviorAnnexParser.g:1019:1: ruleLogicalOperator : ( ( rule__LogicalOperator__Alternatives ) ) ; + public final void ruleLogicalOperator() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1023:2: ( ( ( rule__LogicalOrExpression__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1024:2: ( ( rule__LogicalOrExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1023:2: ( ( ( rule__LogicalOperator__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1024:2: ( ( rule__LogicalOperator__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:1024:2: ( ( rule__LogicalOrExpression__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1025:3: ( rule__LogicalOrExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1024:2: ( ( rule__LogicalOperator__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1025:3: ( rule__LogicalOperator__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrExpressionAccess().getGroup()); + before(grammarAccess.getLogicalOperatorAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:1026:3: ( rule__LogicalOrExpression__Group__0 ) - // InternalBehaviorAnnexParser.g:1026:4: rule__LogicalOrExpression__Group__0 + // InternalBehaviorAnnexParser.g:1026:3: ( rule__LogicalOperator__Alternatives ) + // InternalBehaviorAnnexParser.g:1026:4: rule__LogicalOperator__Alternatives { pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalOrExpression__Group__0(); + rule__LogicalOperator__Alternatives(); state._fsp--; if (state.failed) return ; @@ -3213,7 +3219,7 @@ public final void ruleLogicalOrExpression() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrExpressionAccess().getGroup()); + after(grammarAccess.getLogicalOperatorAccess().getAlternatives()); } } @@ -3233,7 +3239,7 @@ public final void ruleLogicalOrExpression() throws RecognitionException { } return ; } - // $ANTLR end "ruleLogicalOrExpression" + // $ANTLR end "ruleLogicalOperator" // $ANTLR start "entryRuleLogicalOrOperator" @@ -3321,23 +3327,23 @@ public final void ruleLogicalOrOperator() throws RecognitionException { // $ANTLR end "ruleLogicalOrOperator" - // $ANTLR start "entryRuleLogicalAndExpression" - // InternalBehaviorAnnexParser.g:1060:1: entryRuleLogicalAndExpression : ruleLogicalAndExpression EOF ; - public final void entryRuleLogicalAndExpression() throws RecognitionException { + // $ANTLR start "entryRuleLogicalAndOperator" + // InternalBehaviorAnnexParser.g:1060:1: entryRuleLogicalAndOperator : ruleLogicalAndOperator EOF ; + public final void entryRuleLogicalAndOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1061:1: ( ruleLogicalAndExpression EOF ) - // InternalBehaviorAnnexParser.g:1062:1: ruleLogicalAndExpression EOF + // InternalBehaviorAnnexParser.g:1061:1: ( ruleLogicalAndOperator EOF ) + // InternalBehaviorAnnexParser.g:1062:1: ruleLogicalAndOperator EOF { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndExpressionRule()); + before(grammarAccess.getLogicalAndOperatorRule()); } pushFollow(FollowSets000.FOLLOW_1); - ruleLogicalAndExpression(); + ruleLogicalAndOperator(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndExpressionRule()); + after(grammarAccess.getLogicalAndOperatorRule()); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -3352,30 +3358,30 @@ public final void entryRuleLogicalAndExpression() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleLogicalAndExpression" + // $ANTLR end "entryRuleLogicalAndOperator" - // $ANTLR start "ruleLogicalAndExpression" - // InternalBehaviorAnnexParser.g:1069:1: ruleLogicalAndExpression : ( ( rule__LogicalAndExpression__Group__0 ) ) ; - public final void ruleLogicalAndExpression() throws RecognitionException { + // $ANTLR start "ruleLogicalAndOperator" + // InternalBehaviorAnnexParser.g:1069:1: ruleLogicalAndOperator : ( ( rule__LogicalAndOperator__Group__0 ) ) ; + public final void ruleLogicalAndOperator() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1073:2: ( ( ( rule__LogicalAndExpression__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1074:2: ( ( rule__LogicalAndExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1073:2: ( ( ( rule__LogicalAndOperator__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1074:2: ( ( rule__LogicalAndOperator__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1074:2: ( ( rule__LogicalAndExpression__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1075:3: ( rule__LogicalAndExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1074:2: ( ( rule__LogicalAndOperator__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1075:3: ( rule__LogicalAndOperator__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndExpressionAccess().getGroup()); + before(grammarAccess.getLogicalAndOperatorAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1076:3: ( rule__LogicalAndExpression__Group__0 ) - // InternalBehaviorAnnexParser.g:1076:4: rule__LogicalAndExpression__Group__0 + // InternalBehaviorAnnexParser.g:1076:3: ( rule__LogicalAndOperator__Group__0 ) + // InternalBehaviorAnnexParser.g:1076:4: rule__LogicalAndOperator__Group__0 { pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalAndExpression__Group__0(); + rule__LogicalAndOperator__Group__0(); state._fsp--; if (state.failed) return ; @@ -3383,7 +3389,7 @@ public final void ruleLogicalAndExpression() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndExpressionAccess().getGroup()); + after(grammarAccess.getLogicalAndOperatorAccess().getGroup()); } } @@ -3403,26 +3409,26 @@ public final void ruleLogicalAndExpression() throws RecognitionException { } return ; } - // $ANTLR end "ruleLogicalAndExpression" + // $ANTLR end "ruleLogicalAndOperator" - // $ANTLR start "entryRuleLogicalAndOperator" - // InternalBehaviorAnnexParser.g:1085:1: entryRuleLogicalAndOperator : ruleLogicalAndOperator EOF ; - public final void entryRuleLogicalAndOperator() throws RecognitionException { + // $ANTLR start "entryRuleRelation" + // InternalBehaviorAnnexParser.g:1085:1: entryRuleRelation : ruleRelation EOF ; + public final void entryRuleRelation() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1086:1: ( ruleLogicalAndOperator EOF ) - // InternalBehaviorAnnexParser.g:1087:1: ruleLogicalAndOperator EOF + // InternalBehaviorAnnexParser.g:1086:1: ( ruleRelation EOF ) + // InternalBehaviorAnnexParser.g:1087:1: ruleRelation EOF { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndOperatorRule()); + before(grammarAccess.getRelationRule()); } pushFollow(FollowSets000.FOLLOW_1); - ruleLogicalAndOperator(); + ruleRelation(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndOperatorRule()); + after(grammarAccess.getRelationRule()); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -3437,30 +3443,30 @@ public final void entryRuleLogicalAndOperator() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleLogicalAndOperator" + // $ANTLR end "entryRuleRelation" - // $ANTLR start "ruleLogicalAndOperator" - // InternalBehaviorAnnexParser.g:1094:1: ruleLogicalAndOperator : ( ( rule__LogicalAndOperator__Group__0 ) ) ; - public final void ruleLogicalAndOperator() throws RecognitionException { + // $ANTLR start "ruleRelation" + // InternalBehaviorAnnexParser.g:1094:1: ruleRelation : ( ( rule__Relation__Group__0 ) ) ; + public final void ruleRelation() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1098:2: ( ( ( rule__LogicalAndOperator__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1099:2: ( ( rule__LogicalAndOperator__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1098:2: ( ( ( rule__Relation__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1099:2: ( ( rule__Relation__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1099:2: ( ( rule__LogicalAndOperator__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1100:3: ( rule__LogicalAndOperator__Group__0 ) + // InternalBehaviorAnnexParser.g:1099:2: ( ( rule__Relation__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1100:3: ( rule__Relation__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndOperatorAccess().getGroup()); + before(grammarAccess.getRelationAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1101:3: ( rule__LogicalAndOperator__Group__0 ) - // InternalBehaviorAnnexParser.g:1101:4: rule__LogicalAndOperator__Group__0 + // InternalBehaviorAnnexParser.g:1101:3: ( rule__Relation__Group__0 ) + // InternalBehaviorAnnexParser.g:1101:4: rule__Relation__Group__0 { pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalAndOperator__Group__0(); + rule__Relation__Group__0(); state._fsp--; if (state.failed) return ; @@ -3468,7 +3474,7 @@ public final void ruleLogicalAndOperator() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndOperatorAccess().getGroup()); + after(grammarAccess.getRelationAccess().getGroup()); } } @@ -3488,26 +3494,366 @@ public final void ruleLogicalAndOperator() throws RecognitionException { } return ; } - // $ANTLR end "ruleLogicalAndOperator" + // $ANTLR end "ruleRelation" + + + // $ANTLR start "entryRuleRelationalOperator" + // InternalBehaviorAnnexParser.g:1110:1: entryRuleRelationalOperator : ruleRelationalOperator EOF ; + public final void entryRuleRelationalOperator() throws RecognitionException { + try { + // InternalBehaviorAnnexParser.g:1111:1: ( ruleRelationalOperator EOF ) + // InternalBehaviorAnnexParser.g:1112:1: ruleRelationalOperator EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalOperatorRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + ruleRelationalOperator(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalOperatorRule()); + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleRelationalOperator" + + + // $ANTLR start "ruleRelationalOperator" + // InternalBehaviorAnnexParser.g:1119:1: ruleRelationalOperator : ( ( rule__RelationalOperator__Alternatives ) ) ; + public final void ruleRelationalOperator() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalBehaviorAnnexParser.g:1123:2: ( ( ( rule__RelationalOperator__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1124:2: ( ( rule__RelationalOperator__Alternatives ) ) + { + // InternalBehaviorAnnexParser.g:1124:2: ( ( rule__RelationalOperator__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1125:3: ( rule__RelationalOperator__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalOperatorAccess().getAlternatives()); + } + // InternalBehaviorAnnexParser.g:1126:3: ( rule__RelationalOperator__Alternatives ) + // InternalBehaviorAnnexParser.g:1126:4: rule__RelationalOperator__Alternatives + { + pushFollow(FollowSets000.FOLLOW_2); + rule__RelationalOperator__Alternatives(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalOperatorAccess().getAlternatives()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleRelationalOperator" + + + // $ANTLR start "entryRuleSimpleExpression" + // InternalBehaviorAnnexParser.g:1135:1: entryRuleSimpleExpression : ruleSimpleExpression EOF ; + public final void entryRuleSimpleExpression() throws RecognitionException { + try { + // InternalBehaviorAnnexParser.g:1136:1: ( ruleSimpleExpression EOF ) + // InternalBehaviorAnnexParser.g:1137:1: ruleSimpleExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleExpressionRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + ruleSimpleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleExpressionRule()); + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleSimpleExpression" + + + // $ANTLR start "ruleSimpleExpression" + // InternalBehaviorAnnexParser.g:1144:1: ruleSimpleExpression : ( ( rule__SimpleExpression__Group__0 ) ) ; + public final void ruleSimpleExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalBehaviorAnnexParser.g:1148:2: ( ( ( rule__SimpleExpression__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1149:2: ( ( rule__SimpleExpression__Group__0 ) ) + { + // InternalBehaviorAnnexParser.g:1149:2: ( ( rule__SimpleExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1150:3: ( rule__SimpleExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleExpressionAccess().getGroup()); + } + // InternalBehaviorAnnexParser.g:1151:3: ( rule__SimpleExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1151:4: rule__SimpleExpression__Group__0 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__SimpleExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleExpressionAccess().getGroup()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleSimpleExpression" + + + // $ANTLR start "entryRuleUnaryAddingOperator" + // InternalBehaviorAnnexParser.g:1160:1: entryRuleUnaryAddingOperator : ruleUnaryAddingOperator EOF ; + public final void entryRuleUnaryAddingOperator() throws RecognitionException { + try { + // InternalBehaviorAnnexParser.g:1161:1: ( ruleUnaryAddingOperator EOF ) + // InternalBehaviorAnnexParser.g:1162:1: ruleUnaryAddingOperator EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryAddingOperatorRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + ruleUnaryAddingOperator(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryAddingOperatorRule()); + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleUnaryAddingOperator" + + + // $ANTLR start "ruleUnaryAddingOperator" + // InternalBehaviorAnnexParser.g:1169:1: ruleUnaryAddingOperator : ( ( rule__UnaryAddingOperator__Alternatives ) ) ; + public final void ruleUnaryAddingOperator() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalBehaviorAnnexParser.g:1173:2: ( ( ( rule__UnaryAddingOperator__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1174:2: ( ( rule__UnaryAddingOperator__Alternatives ) ) + { + // InternalBehaviorAnnexParser.g:1174:2: ( ( rule__UnaryAddingOperator__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1175:3: ( rule__UnaryAddingOperator__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryAddingOperatorAccess().getAlternatives()); + } + // InternalBehaviorAnnexParser.g:1176:3: ( rule__UnaryAddingOperator__Alternatives ) + // InternalBehaviorAnnexParser.g:1176:4: rule__UnaryAddingOperator__Alternatives + { + pushFollow(FollowSets000.FOLLOW_2); + rule__UnaryAddingOperator__Alternatives(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryAddingOperatorAccess().getAlternatives()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleUnaryAddingOperator" + + + // $ANTLR start "entryRuleBinaryAddingOperator" + // InternalBehaviorAnnexParser.g:1185:1: entryRuleBinaryAddingOperator : ruleBinaryAddingOperator EOF ; + public final void entryRuleBinaryAddingOperator() throws RecognitionException { + try { + // InternalBehaviorAnnexParser.g:1186:1: ( ruleBinaryAddingOperator EOF ) + // InternalBehaviorAnnexParser.g:1187:1: ruleBinaryAddingOperator EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBinaryAddingOperatorRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + ruleBinaryAddingOperator(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getBinaryAddingOperatorRule()); + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleBinaryAddingOperator" + + + // $ANTLR start "ruleBinaryAddingOperator" + // InternalBehaviorAnnexParser.g:1194:1: ruleBinaryAddingOperator : ( ( rule__BinaryAddingOperator__Alternatives ) ) ; + public final void ruleBinaryAddingOperator() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalBehaviorAnnexParser.g:1198:2: ( ( ( rule__BinaryAddingOperator__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1199:2: ( ( rule__BinaryAddingOperator__Alternatives ) ) + { + // InternalBehaviorAnnexParser.g:1199:2: ( ( rule__BinaryAddingOperator__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1200:3: ( rule__BinaryAddingOperator__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBinaryAddingOperatorAccess().getAlternatives()); + } + // InternalBehaviorAnnexParser.g:1201:3: ( rule__BinaryAddingOperator__Alternatives ) + // InternalBehaviorAnnexParser.g:1201:4: rule__BinaryAddingOperator__Alternatives + { + pushFollow(FollowSets000.FOLLOW_2); + rule__BinaryAddingOperator__Alternatives(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getBinaryAddingOperatorAccess().getAlternatives()); + } + + } + + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); - // $ANTLR start "entryRuleRelationalExpression" - // InternalBehaviorAnnexParser.g:1110:1: entryRuleRelationalExpression : ruleRelationalExpression EOF ; - public final void entryRuleRelationalExpression() throws RecognitionException { + } + return ; + } + // $ANTLR end "ruleBinaryAddingOperator" + + + // $ANTLR start "entryRuleTerm" + // InternalBehaviorAnnexParser.g:1210:1: entryRuleTerm : ruleTerm EOF ; + public final void entryRuleTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1111:1: ( ruleRelationalExpression EOF ) - // InternalBehaviorAnnexParser.g:1112:1: ruleRelationalExpression EOF + // InternalBehaviorAnnexParser.g:1211:1: ( ruleTerm EOF ) + // InternalBehaviorAnnexParser.g:1212:1: ruleTerm EOF { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionRule()); + before(grammarAccess.getTermRule()); } pushFollow(FollowSets000.FOLLOW_1); - ruleRelationalExpression(); + ruleTerm(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionRule()); + after(grammarAccess.getTermRule()); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -3522,30 +3868,30 @@ public final void entryRuleRelationalExpression() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleRelationalExpression" + // $ANTLR end "entryRuleTerm" - // $ANTLR start "ruleRelationalExpression" - // InternalBehaviorAnnexParser.g:1119:1: ruleRelationalExpression : ( ( rule__RelationalExpression__Group__0 ) ) ; - public final void ruleRelationalExpression() throws RecognitionException { + // $ANTLR start "ruleTerm" + // InternalBehaviorAnnexParser.g:1219:1: ruleTerm : ( ( rule__Term__Group__0 ) ) ; + public final void ruleTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1123:2: ( ( ( rule__RelationalExpression__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1124:2: ( ( rule__RelationalExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1223:2: ( ( ( rule__Term__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1224:2: ( ( rule__Term__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1124:2: ( ( rule__RelationalExpression__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1125:3: ( rule__RelationalExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1224:2: ( ( rule__Term__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1225:3: ( rule__Term__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getGroup()); + before(grammarAccess.getTermAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1126:3: ( rule__RelationalExpression__Group__0 ) - // InternalBehaviorAnnexParser.g:1126:4: rule__RelationalExpression__Group__0 + // InternalBehaviorAnnexParser.g:1226:3: ( rule__Term__Group__0 ) + // InternalBehaviorAnnexParser.g:1226:4: rule__Term__Group__0 { pushFollow(FollowSets000.FOLLOW_2); - rule__RelationalExpression__Group__0(); + rule__Term__Group__0(); state._fsp--; if (state.failed) return ; @@ -3553,7 +3899,7 @@ public final void ruleRelationalExpression() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getGroup()); + after(grammarAccess.getTermAccess().getGroup()); } } @@ -3573,26 +3919,26 @@ public final void ruleRelationalExpression() throws RecognitionException { } return ; } - // $ANTLR end "ruleRelationalExpression" + // $ANTLR end "ruleTerm" - // $ANTLR start "entryRuleAdditiveExpression" - // InternalBehaviorAnnexParser.g:1135:1: entryRuleAdditiveExpression : ruleAdditiveExpression EOF ; - public final void entryRuleAdditiveExpression() throws RecognitionException { + // $ANTLR start "entryRuleMultiplyingOperator" + // InternalBehaviorAnnexParser.g:1235:1: entryRuleMultiplyingOperator : ruleMultiplyingOperator EOF ; + public final void entryRuleMultiplyingOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1136:1: ( ruleAdditiveExpression EOF ) - // InternalBehaviorAnnexParser.g:1137:1: ruleAdditiveExpression EOF + // InternalBehaviorAnnexParser.g:1236:1: ( ruleMultiplyingOperator EOF ) + // InternalBehaviorAnnexParser.g:1237:1: ruleMultiplyingOperator EOF { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionRule()); + before(grammarAccess.getMultiplyingOperatorRule()); } pushFollow(FollowSets000.FOLLOW_1); - ruleAdditiveExpression(); + ruleMultiplyingOperator(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionRule()); + after(grammarAccess.getMultiplyingOperatorRule()); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -3607,30 +3953,30 @@ public final void entryRuleAdditiveExpression() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleAdditiveExpression" + // $ANTLR end "entryRuleMultiplyingOperator" - // $ANTLR start "ruleAdditiveExpression" - // InternalBehaviorAnnexParser.g:1144:1: ruleAdditiveExpression : ( ( rule__AdditiveExpression__Group__0 ) ) ; - public final void ruleAdditiveExpression() throws RecognitionException { + // $ANTLR start "ruleMultiplyingOperator" + // InternalBehaviorAnnexParser.g:1244:1: ruleMultiplyingOperator : ( ( rule__MultiplyingOperator__Alternatives ) ) ; + public final void ruleMultiplyingOperator() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1148:2: ( ( ( rule__AdditiveExpression__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1149:2: ( ( rule__AdditiveExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1248:2: ( ( ( rule__MultiplyingOperator__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1249:2: ( ( rule__MultiplyingOperator__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:1149:2: ( ( rule__AdditiveExpression__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1150:3: ( rule__AdditiveExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1249:2: ( ( rule__MultiplyingOperator__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1250:3: ( rule__MultiplyingOperator__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getGroup()); + before(grammarAccess.getMultiplyingOperatorAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:1151:3: ( rule__AdditiveExpression__Group__0 ) - // InternalBehaviorAnnexParser.g:1151:4: rule__AdditiveExpression__Group__0 + // InternalBehaviorAnnexParser.g:1251:3: ( rule__MultiplyingOperator__Alternatives ) + // InternalBehaviorAnnexParser.g:1251:4: rule__MultiplyingOperator__Alternatives { pushFollow(FollowSets000.FOLLOW_2); - rule__AdditiveExpression__Group__0(); + rule__MultiplyingOperator__Alternatives(); state._fsp--; if (state.failed) return ; @@ -3638,7 +3984,7 @@ public final void ruleAdditiveExpression() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getGroup()); + after(grammarAccess.getMultiplyingOperatorAccess().getAlternatives()); } } @@ -3658,26 +4004,26 @@ public final void ruleAdditiveExpression() throws RecognitionException { } return ; } - // $ANTLR end "ruleAdditiveExpression" + // $ANTLR end "ruleMultiplyingOperator" - // $ANTLR start "entryRuleMultiplicativeExpression" - // InternalBehaviorAnnexParser.g:1160:1: entryRuleMultiplicativeExpression : ruleMultiplicativeExpression EOF ; - public final void entryRuleMultiplicativeExpression() throws RecognitionException { + // $ANTLR start "entryRuleFactor" + // InternalBehaviorAnnexParser.g:1260:1: entryRuleFactor : ruleFactor EOF ; + public final void entryRuleFactor() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1161:1: ( ruleMultiplicativeExpression EOF ) - // InternalBehaviorAnnexParser.g:1162:1: ruleMultiplicativeExpression EOF + // InternalBehaviorAnnexParser.g:1261:1: ( ruleFactor EOF ) + // InternalBehaviorAnnexParser.g:1262:1: ruleFactor EOF { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionRule()); + before(grammarAccess.getFactorRule()); } pushFollow(FollowSets000.FOLLOW_1); - ruleMultiplicativeExpression(); + ruleFactor(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionRule()); + after(grammarAccess.getFactorRule()); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -3692,30 +4038,30 @@ public final void entryRuleMultiplicativeExpression() throws RecognitionExceptio } return ; } - // $ANTLR end "entryRuleMultiplicativeExpression" + // $ANTLR end "entryRuleFactor" - // $ANTLR start "ruleMultiplicativeExpression" - // InternalBehaviorAnnexParser.g:1169:1: ruleMultiplicativeExpression : ( ( rule__MultiplicativeExpression__Group__0 ) ) ; - public final void ruleMultiplicativeExpression() throws RecognitionException { + // $ANTLR start "ruleFactor" + // InternalBehaviorAnnexParser.g:1269:1: ruleFactor : ( ( rule__Factor__Alternatives ) ) ; + public final void ruleFactor() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1173:2: ( ( ( rule__MultiplicativeExpression__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1174:2: ( ( rule__MultiplicativeExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1273:2: ( ( ( rule__Factor__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1274:2: ( ( rule__Factor__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:1174:2: ( ( rule__MultiplicativeExpression__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1175:3: ( rule__MultiplicativeExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1274:2: ( ( rule__Factor__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1275:3: ( rule__Factor__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); + before(grammarAccess.getFactorAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:1176:3: ( rule__MultiplicativeExpression__Group__0 ) - // InternalBehaviorAnnexParser.g:1176:4: rule__MultiplicativeExpression__Group__0 + // InternalBehaviorAnnexParser.g:1276:3: ( rule__Factor__Alternatives ) + // InternalBehaviorAnnexParser.g:1276:4: rule__Factor__Alternatives { pushFollow(FollowSets000.FOLLOW_2); - rule__MultiplicativeExpression__Group__0(); + rule__Factor__Alternatives(); state._fsp--; if (state.failed) return ; @@ -3723,7 +4069,82 @@ public final void ruleMultiplicativeExpression() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); + after(grammarAccess.getFactorAccess().getAlternatives()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleFactor" + + + // $ANTLR start "entryRuleBinaryNumericOperator" + // InternalBehaviorAnnexParser.g:1285:1: entryRuleBinaryNumericOperator : ruleBinaryNumericOperator EOF ; + public final void entryRuleBinaryNumericOperator() throws RecognitionException { + try { + // InternalBehaviorAnnexParser.g:1286:1: ( ruleBinaryNumericOperator EOF ) + // InternalBehaviorAnnexParser.g:1287:1: ruleBinaryNumericOperator EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBinaryNumericOperatorRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + ruleBinaryNumericOperator(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getBinaryNumericOperatorRule()); + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleBinaryNumericOperator" + + + // $ANTLR start "ruleBinaryNumericOperator" + // InternalBehaviorAnnexParser.g:1294:1: ruleBinaryNumericOperator : ( AsteriskAsterisk ) ; + public final void ruleBinaryNumericOperator() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalBehaviorAnnexParser.g:1298:2: ( ( AsteriskAsterisk ) ) + // InternalBehaviorAnnexParser.g:1299:2: ( AsteriskAsterisk ) + { + // InternalBehaviorAnnexParser.g:1299:2: ( AsteriskAsterisk ) + // InternalBehaviorAnnexParser.g:1300:3: AsteriskAsterisk + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBinaryNumericOperatorAccess().getAsteriskAsteriskKeyword()); + } + match(input,AsteriskAsterisk,FollowSets000.FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getBinaryNumericOperatorAccess().getAsteriskAsteriskKeyword()); } } @@ -3743,26 +4164,26 @@ public final void ruleMultiplicativeExpression() throws RecognitionException { } return ; } - // $ANTLR end "ruleMultiplicativeExpression" + // $ANTLR end "ruleBinaryNumericOperator" - // $ANTLR start "entryRulePowerExpression" - // InternalBehaviorAnnexParser.g:1185:1: entryRulePowerExpression : rulePowerExpression EOF ; - public final void entryRulePowerExpression() throws RecognitionException { + // $ANTLR start "entryRuleUnaryValueOperator" + // InternalBehaviorAnnexParser.g:1310:1: entryRuleUnaryValueOperator : ruleUnaryValueOperator EOF ; + public final void entryRuleUnaryValueOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1186:1: ( rulePowerExpression EOF ) - // InternalBehaviorAnnexParser.g:1187:1: rulePowerExpression EOF + // InternalBehaviorAnnexParser.g:1311:1: ( ruleUnaryValueOperator EOF ) + // InternalBehaviorAnnexParser.g:1312:1: ruleUnaryValueOperator EOF { if ( state.backtracking==0 ) { - before(grammarAccess.getPowerExpressionRule()); + before(grammarAccess.getUnaryValueOperatorRule()); } pushFollow(FollowSets000.FOLLOW_1); - rulePowerExpression(); + ruleUnaryValueOperator(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getPowerExpressionRule()); + after(grammarAccess.getUnaryValueOperatorRule()); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -3777,30 +4198,30 @@ public final void entryRulePowerExpression() throws RecognitionException { } return ; } - // $ANTLR end "entryRulePowerExpression" + // $ANTLR end "entryRuleUnaryValueOperator" - // $ANTLR start "rulePowerExpression" - // InternalBehaviorAnnexParser.g:1194:1: rulePowerExpression : ( ( rule__PowerExpression__Group__0 ) ) ; - public final void rulePowerExpression() throws RecognitionException { + // $ANTLR start "ruleUnaryValueOperator" + // InternalBehaviorAnnexParser.g:1319:1: ruleUnaryValueOperator : ( ( rule__UnaryValueOperator__Alternatives ) ) ; + public final void ruleUnaryValueOperator() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1198:2: ( ( ( rule__PowerExpression__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1199:2: ( ( rule__PowerExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1323:2: ( ( ( rule__UnaryValueOperator__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1324:2: ( ( rule__UnaryValueOperator__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:1199:2: ( ( rule__PowerExpression__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1200:3: ( rule__PowerExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1324:2: ( ( rule__UnaryValueOperator__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1325:3: ( rule__UnaryValueOperator__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getPowerExpressionAccess().getGroup()); + before(grammarAccess.getUnaryValueOperatorAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:1201:3: ( rule__PowerExpression__Group__0 ) - // InternalBehaviorAnnexParser.g:1201:4: rule__PowerExpression__Group__0 + // InternalBehaviorAnnexParser.g:1326:3: ( rule__UnaryValueOperator__Alternatives ) + // InternalBehaviorAnnexParser.g:1326:4: rule__UnaryValueOperator__Alternatives { pushFollow(FollowSets000.FOLLOW_2); - rule__PowerExpression__Group__0(); + rule__UnaryValueOperator__Alternatives(); state._fsp--; if (state.failed) return ; @@ -3808,7 +4229,7 @@ public final void rulePowerExpression() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getPowerExpressionAccess().getGroup()); + after(grammarAccess.getUnaryValueOperatorAccess().getAlternatives()); } } @@ -3828,26 +4249,26 @@ public final void rulePowerExpression() throws RecognitionException { } return ; } - // $ANTLR end "rulePowerExpression" + // $ANTLR end "ruleUnaryValueOperator" - // $ANTLR start "entryRuleUnaryExpression" - // InternalBehaviorAnnexParser.g:1210:1: entryRuleUnaryExpression : ruleUnaryExpression EOF ; - public final void entryRuleUnaryExpression() throws RecognitionException { + // $ANTLR start "entryRuleValue" + // InternalBehaviorAnnexParser.g:1335:1: entryRuleValue : ruleValue EOF ; + public final void entryRuleValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1211:1: ( ruleUnaryExpression EOF ) - // InternalBehaviorAnnexParser.g:1212:1: ruleUnaryExpression EOF + // InternalBehaviorAnnexParser.g:1336:1: ( ruleValue EOF ) + // InternalBehaviorAnnexParser.g:1337:1: ruleValue EOF { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionRule()); + before(grammarAccess.getValueRule()); } pushFollow(FollowSets000.FOLLOW_1); - ruleUnaryExpression(); + ruleValue(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionRule()); + after(grammarAccess.getValueRule()); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -3862,30 +4283,30 @@ public final void entryRuleUnaryExpression() throws RecognitionException { } return ; } - // $ANTLR end "entryRuleUnaryExpression" + // $ANTLR end "entryRuleValue" - // $ANTLR start "ruleUnaryExpression" - // InternalBehaviorAnnexParser.g:1219:1: ruleUnaryExpression : ( ( rule__UnaryExpression__Alternatives ) ) ; - public final void ruleUnaryExpression() throws RecognitionException { + // $ANTLR start "ruleValue" + // InternalBehaviorAnnexParser.g:1344:1: ruleValue : ( ( rule__Value__Alternatives ) ) ; + public final void ruleValue() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1223:2: ( ( ( rule__UnaryExpression__Alternatives ) ) ) - // InternalBehaviorAnnexParser.g:1224:2: ( ( rule__UnaryExpression__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1348:2: ( ( ( rule__Value__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1349:2: ( ( rule__Value__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:1224:2: ( ( rule__UnaryExpression__Alternatives ) ) - // InternalBehaviorAnnexParser.g:1225:3: ( rule__UnaryExpression__Alternatives ) + // InternalBehaviorAnnexParser.g:1349:2: ( ( rule__Value__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1350:3: ( rule__Value__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getAlternatives()); + before(grammarAccess.getValueAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:1226:3: ( rule__UnaryExpression__Alternatives ) - // InternalBehaviorAnnexParser.g:1226:4: rule__UnaryExpression__Alternatives + // InternalBehaviorAnnexParser.g:1351:3: ( rule__Value__Alternatives ) + // InternalBehaviorAnnexParser.g:1351:4: rule__Value__Alternatives { pushFollow(FollowSets000.FOLLOW_2); - rule__UnaryExpression__Alternatives(); + rule__Value__Alternatives(); state._fsp--; if (state.failed) return ; @@ -3893,7 +4314,7 @@ public final void ruleUnaryExpression() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getAlternatives()); + after(grammarAccess.getValueAccess().getAlternatives()); } } @@ -3913,26 +4334,26 @@ public final void ruleUnaryExpression() throws RecognitionException { } return ; } - // $ANTLR end "ruleUnaryExpression" + // $ANTLR end "ruleValue" - // $ANTLR start "entryRulePrimaryExpression" - // InternalBehaviorAnnexParser.g:1235:1: entryRulePrimaryExpression : rulePrimaryExpression EOF ; - public final void entryRulePrimaryExpression() throws RecognitionException { + // $ANTLR start "entryRuleParenthesizedExpression" + // InternalBehaviorAnnexParser.g:1360:1: entryRuleParenthesizedExpression : ruleParenthesizedExpression EOF ; + public final void entryRuleParenthesizedExpression() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1236:1: ( rulePrimaryExpression EOF ) - // InternalBehaviorAnnexParser.g:1237:1: rulePrimaryExpression EOF + // InternalBehaviorAnnexParser.g:1361:1: ( ruleParenthesizedExpression EOF ) + // InternalBehaviorAnnexParser.g:1362:1: ruleParenthesizedExpression EOF { if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionRule()); + before(grammarAccess.getParenthesizedExpressionRule()); } pushFollow(FollowSets000.FOLLOW_1); - rulePrimaryExpression(); + ruleParenthesizedExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionRule()); + after(grammarAccess.getParenthesizedExpressionRule()); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -3947,30 +4368,30 @@ public final void entryRulePrimaryExpression() throws RecognitionException { } return ; } - // $ANTLR end "entryRulePrimaryExpression" + // $ANTLR end "entryRuleParenthesizedExpression" - // $ANTLR start "rulePrimaryExpression" - // InternalBehaviorAnnexParser.g:1244:1: rulePrimaryExpression : ( ( rule__PrimaryExpression__Alternatives ) ) ; - public final void rulePrimaryExpression() throws RecognitionException { + // $ANTLR start "ruleParenthesizedExpression" + // InternalBehaviorAnnexParser.g:1369:1: ruleParenthesizedExpression : ( ( rule__ParenthesizedExpression__Group__0 ) ) ; + public final void ruleParenthesizedExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1248:2: ( ( ( rule__PrimaryExpression__Alternatives ) ) ) - // InternalBehaviorAnnexParser.g:1249:2: ( ( rule__PrimaryExpression__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1373:2: ( ( ( rule__ParenthesizedExpression__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1374:2: ( ( rule__ParenthesizedExpression__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1249:2: ( ( rule__PrimaryExpression__Alternatives ) ) - // InternalBehaviorAnnexParser.g:1250:3: ( rule__PrimaryExpression__Alternatives ) + // InternalBehaviorAnnexParser.g:1374:2: ( ( rule__ParenthesizedExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1375:3: ( rule__ParenthesizedExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); + before(grammarAccess.getParenthesizedExpressionAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1251:3: ( rule__PrimaryExpression__Alternatives ) - // InternalBehaviorAnnexParser.g:1251:4: rule__PrimaryExpression__Alternatives + // InternalBehaviorAnnexParser.g:1376:3: ( rule__ParenthesizedExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1376:4: rule__ParenthesizedExpression__Group__0 { pushFollow(FollowSets000.FOLLOW_2); - rule__PrimaryExpression__Alternatives(); + rule__ParenthesizedExpression__Group__0(); state._fsp--; if (state.failed) return ; @@ -3978,7 +4399,7 @@ public final void rulePrimaryExpression() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); + after(grammarAccess.getParenthesizedExpressionAccess().getGroup()); } } @@ -3998,15 +4419,15 @@ public final void rulePrimaryExpression() throws RecognitionException { } return ; } - // $ANTLR end "rulePrimaryExpression" + // $ANTLR end "ruleParenthesizedExpression" // $ANTLR start "entryRuleValueConstant" - // InternalBehaviorAnnexParser.g:1260:1: entryRuleValueConstant : ruleValueConstant EOF ; + // InternalBehaviorAnnexParser.g:1385:1: entryRuleValueConstant : ruleValueConstant EOF ; public final void entryRuleValueConstant() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1261:1: ( ruleValueConstant EOF ) - // InternalBehaviorAnnexParser.g:1262:1: ruleValueConstant EOF + // InternalBehaviorAnnexParser.g:1386:1: ( ruleValueConstant EOF ) + // InternalBehaviorAnnexParser.g:1387:1: ruleValueConstant EOF { if ( state.backtracking==0 ) { before(grammarAccess.getValueConstantRule()); @@ -4036,23 +4457,23 @@ public final void entryRuleValueConstant() throws RecognitionException { // $ANTLR start "ruleValueConstant" - // InternalBehaviorAnnexParser.g:1269:1: ruleValueConstant : ( ( rule__ValueConstant__Alternatives ) ) ; + // InternalBehaviorAnnexParser.g:1394:1: ruleValueConstant : ( ( rule__ValueConstant__Alternatives ) ) ; public final void ruleValueConstant() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1273:2: ( ( ( rule__ValueConstant__Alternatives ) ) ) - // InternalBehaviorAnnexParser.g:1274:2: ( ( rule__ValueConstant__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1398:2: ( ( ( rule__ValueConstant__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1399:2: ( ( rule__ValueConstant__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:1274:2: ( ( rule__ValueConstant__Alternatives ) ) - // InternalBehaviorAnnexParser.g:1275:3: ( rule__ValueConstant__Alternatives ) + // InternalBehaviorAnnexParser.g:1399:2: ( ( rule__ValueConstant__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1400:3: ( rule__ValueConstant__Alternatives ) { if ( state.backtracking==0 ) { before(grammarAccess.getValueConstantAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:1276:3: ( rule__ValueConstant__Alternatives ) - // InternalBehaviorAnnexParser.g:1276:4: rule__ValueConstant__Alternatives + // InternalBehaviorAnnexParser.g:1401:3: ( rule__ValueConstant__Alternatives ) + // InternalBehaviorAnnexParser.g:1401:4: rule__ValueConstant__Alternatives { pushFollow(FollowSets000.FOLLOW_2); rule__ValueConstant__Alternatives(); @@ -4087,11 +4508,11 @@ public final void ruleValueConstant() throws RecognitionException { // $ANTLR start "entryRuleBehaviorIntegerLiteral" - // InternalBehaviorAnnexParser.g:1285:1: entryRuleBehaviorIntegerLiteral : ruleBehaviorIntegerLiteral EOF ; + // InternalBehaviorAnnexParser.g:1410:1: entryRuleBehaviorIntegerLiteral : ruleBehaviorIntegerLiteral EOF ; public final void entryRuleBehaviorIntegerLiteral() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1286:1: ( ruleBehaviorIntegerLiteral EOF ) - // InternalBehaviorAnnexParser.g:1287:1: ruleBehaviorIntegerLiteral EOF + // InternalBehaviorAnnexParser.g:1411:1: ( ruleBehaviorIntegerLiteral EOF ) + // InternalBehaviorAnnexParser.g:1412:1: ruleBehaviorIntegerLiteral EOF { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorIntegerLiteralRule()); @@ -4121,23 +4542,23 @@ public final void entryRuleBehaviorIntegerLiteral() throws RecognitionException // $ANTLR start "ruleBehaviorIntegerLiteral" - // InternalBehaviorAnnexParser.g:1294:1: ruleBehaviorIntegerLiteral : ( ( rule__BehaviorIntegerLiteral__ValueAssignment ) ) ; + // InternalBehaviorAnnexParser.g:1419:1: ruleBehaviorIntegerLiteral : ( ( rule__BehaviorIntegerLiteral__ValueAssignment ) ) ; public final void ruleBehaviorIntegerLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1298:2: ( ( ( rule__BehaviorIntegerLiteral__ValueAssignment ) ) ) - // InternalBehaviorAnnexParser.g:1299:2: ( ( rule__BehaviorIntegerLiteral__ValueAssignment ) ) + // InternalBehaviorAnnexParser.g:1423:2: ( ( ( rule__BehaviorIntegerLiteral__ValueAssignment ) ) ) + // InternalBehaviorAnnexParser.g:1424:2: ( ( rule__BehaviorIntegerLiteral__ValueAssignment ) ) { - // InternalBehaviorAnnexParser.g:1299:2: ( ( rule__BehaviorIntegerLiteral__ValueAssignment ) ) - // InternalBehaviorAnnexParser.g:1300:3: ( rule__BehaviorIntegerLiteral__ValueAssignment ) + // InternalBehaviorAnnexParser.g:1424:2: ( ( rule__BehaviorIntegerLiteral__ValueAssignment ) ) + // InternalBehaviorAnnexParser.g:1425:3: ( rule__BehaviorIntegerLiteral__ValueAssignment ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorIntegerLiteralAccess().getValueAssignment()); } - // InternalBehaviorAnnexParser.g:1301:3: ( rule__BehaviorIntegerLiteral__ValueAssignment ) - // InternalBehaviorAnnexParser.g:1301:4: rule__BehaviorIntegerLiteral__ValueAssignment + // InternalBehaviorAnnexParser.g:1426:3: ( rule__BehaviorIntegerLiteral__ValueAssignment ) + // InternalBehaviorAnnexParser.g:1426:4: rule__BehaviorIntegerLiteral__ValueAssignment { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorIntegerLiteral__ValueAssignment(); @@ -4172,11 +4593,11 @@ public final void ruleBehaviorIntegerLiteral() throws RecognitionException { // $ANTLR start "entryRuleBehaviorRealLiteral" - // InternalBehaviorAnnexParser.g:1310:1: entryRuleBehaviorRealLiteral : ruleBehaviorRealLiteral EOF ; + // InternalBehaviorAnnexParser.g:1435:1: entryRuleBehaviorRealLiteral : ruleBehaviorRealLiteral EOF ; public final void entryRuleBehaviorRealLiteral() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1311:1: ( ruleBehaviorRealLiteral EOF ) - // InternalBehaviorAnnexParser.g:1312:1: ruleBehaviorRealLiteral EOF + // InternalBehaviorAnnexParser.g:1436:1: ( ruleBehaviorRealLiteral EOF ) + // InternalBehaviorAnnexParser.g:1437:1: ruleBehaviorRealLiteral EOF { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorRealLiteralRule()); @@ -4206,23 +4627,23 @@ public final void entryRuleBehaviorRealLiteral() throws RecognitionException { // $ANTLR start "ruleBehaviorRealLiteral" - // InternalBehaviorAnnexParser.g:1319:1: ruleBehaviorRealLiteral : ( ( rule__BehaviorRealLiteral__ValueAssignment ) ) ; + // InternalBehaviorAnnexParser.g:1444:1: ruleBehaviorRealLiteral : ( ( rule__BehaviorRealLiteral__ValueAssignment ) ) ; public final void ruleBehaviorRealLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1323:2: ( ( ( rule__BehaviorRealLiteral__ValueAssignment ) ) ) - // InternalBehaviorAnnexParser.g:1324:2: ( ( rule__BehaviorRealLiteral__ValueAssignment ) ) + // InternalBehaviorAnnexParser.g:1448:2: ( ( ( rule__BehaviorRealLiteral__ValueAssignment ) ) ) + // InternalBehaviorAnnexParser.g:1449:2: ( ( rule__BehaviorRealLiteral__ValueAssignment ) ) { - // InternalBehaviorAnnexParser.g:1324:2: ( ( rule__BehaviorRealLiteral__ValueAssignment ) ) - // InternalBehaviorAnnexParser.g:1325:3: ( rule__BehaviorRealLiteral__ValueAssignment ) + // InternalBehaviorAnnexParser.g:1449:2: ( ( rule__BehaviorRealLiteral__ValueAssignment ) ) + // InternalBehaviorAnnexParser.g:1450:3: ( rule__BehaviorRealLiteral__ValueAssignment ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorRealLiteralAccess().getValueAssignment()); } - // InternalBehaviorAnnexParser.g:1326:3: ( rule__BehaviorRealLiteral__ValueAssignment ) - // InternalBehaviorAnnexParser.g:1326:4: rule__BehaviorRealLiteral__ValueAssignment + // InternalBehaviorAnnexParser.g:1451:3: ( rule__BehaviorRealLiteral__ValueAssignment ) + // InternalBehaviorAnnexParser.g:1451:4: rule__BehaviorRealLiteral__ValueAssignment { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorRealLiteral__ValueAssignment(); @@ -4257,11 +4678,11 @@ public final void ruleBehaviorRealLiteral() throws RecognitionException { // $ANTLR start "entryRuleBehaviorStringLiteral" - // InternalBehaviorAnnexParser.g:1335:1: entryRuleBehaviorStringLiteral : ruleBehaviorStringLiteral EOF ; + // InternalBehaviorAnnexParser.g:1460:1: entryRuleBehaviorStringLiteral : ruleBehaviorStringLiteral EOF ; public final void entryRuleBehaviorStringLiteral() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1336:1: ( ruleBehaviorStringLiteral EOF ) - // InternalBehaviorAnnexParser.g:1337:1: ruleBehaviorStringLiteral EOF + // InternalBehaviorAnnexParser.g:1461:1: ( ruleBehaviorStringLiteral EOF ) + // InternalBehaviorAnnexParser.g:1462:1: ruleBehaviorStringLiteral EOF { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStringLiteralRule()); @@ -4291,23 +4712,23 @@ public final void entryRuleBehaviorStringLiteral() throws RecognitionException { // $ANTLR start "ruleBehaviorStringLiteral" - // InternalBehaviorAnnexParser.g:1344:1: ruleBehaviorStringLiteral : ( ( rule__BehaviorStringLiteral__ValueAssignment ) ) ; + // InternalBehaviorAnnexParser.g:1469:1: ruleBehaviorStringLiteral : ( ( rule__BehaviorStringLiteral__ValueAssignment ) ) ; public final void ruleBehaviorStringLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1348:2: ( ( ( rule__BehaviorStringLiteral__ValueAssignment ) ) ) - // InternalBehaviorAnnexParser.g:1349:2: ( ( rule__BehaviorStringLiteral__ValueAssignment ) ) + // InternalBehaviorAnnexParser.g:1473:2: ( ( ( rule__BehaviorStringLiteral__ValueAssignment ) ) ) + // InternalBehaviorAnnexParser.g:1474:2: ( ( rule__BehaviorStringLiteral__ValueAssignment ) ) { - // InternalBehaviorAnnexParser.g:1349:2: ( ( rule__BehaviorStringLiteral__ValueAssignment ) ) - // InternalBehaviorAnnexParser.g:1350:3: ( rule__BehaviorStringLiteral__ValueAssignment ) + // InternalBehaviorAnnexParser.g:1474:2: ( ( rule__BehaviorStringLiteral__ValueAssignment ) ) + // InternalBehaviorAnnexParser.g:1475:3: ( rule__BehaviorStringLiteral__ValueAssignment ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStringLiteralAccess().getValueAssignment()); } - // InternalBehaviorAnnexParser.g:1351:3: ( rule__BehaviorStringLiteral__ValueAssignment ) - // InternalBehaviorAnnexParser.g:1351:4: rule__BehaviorStringLiteral__ValueAssignment + // InternalBehaviorAnnexParser.g:1476:3: ( rule__BehaviorStringLiteral__ValueAssignment ) + // InternalBehaviorAnnexParser.g:1476:4: rule__BehaviorStringLiteral__ValueAssignment { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorStringLiteral__ValueAssignment(); @@ -4342,11 +4763,11 @@ public final void ruleBehaviorStringLiteral() throws RecognitionException { // $ANTLR start "entryRuleBehaviorBooleanLiteral" - // InternalBehaviorAnnexParser.g:1360:1: entryRuleBehaviorBooleanLiteral : ruleBehaviorBooleanLiteral EOF ; + // InternalBehaviorAnnexParser.g:1485:1: entryRuleBehaviorBooleanLiteral : ruleBehaviorBooleanLiteral EOF ; public final void entryRuleBehaviorBooleanLiteral() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1361:1: ( ruleBehaviorBooleanLiteral EOF ) - // InternalBehaviorAnnexParser.g:1362:1: ruleBehaviorBooleanLiteral EOF + // InternalBehaviorAnnexParser.g:1486:1: ( ruleBehaviorBooleanLiteral EOF ) + // InternalBehaviorAnnexParser.g:1487:1: ruleBehaviorBooleanLiteral EOF { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralRule()); @@ -4376,23 +4797,23 @@ public final void entryRuleBehaviorBooleanLiteral() throws RecognitionException // $ANTLR start "ruleBehaviorBooleanLiteral" - // InternalBehaviorAnnexParser.g:1369:1: ruleBehaviorBooleanLiteral : ( ( rule__BehaviorBooleanLiteral__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1494:1: ruleBehaviorBooleanLiteral : ( ( rule__BehaviorBooleanLiteral__Group__0 ) ) ; public final void ruleBehaviorBooleanLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1373:2: ( ( ( rule__BehaviorBooleanLiteral__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1374:2: ( ( rule__BehaviorBooleanLiteral__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1498:2: ( ( ( rule__BehaviorBooleanLiteral__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1499:2: ( ( rule__BehaviorBooleanLiteral__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1374:2: ( ( rule__BehaviorBooleanLiteral__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1375:3: ( rule__BehaviorBooleanLiteral__Group__0 ) + // InternalBehaviorAnnexParser.g:1499:2: ( ( rule__BehaviorBooleanLiteral__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1500:3: ( rule__BehaviorBooleanLiteral__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1376:3: ( rule__BehaviorBooleanLiteral__Group__0 ) - // InternalBehaviorAnnexParser.g:1376:4: rule__BehaviorBooleanLiteral__Group__0 + // InternalBehaviorAnnexParser.g:1501:3: ( rule__BehaviorBooleanLiteral__Group__0 ) + // InternalBehaviorAnnexParser.g:1501:4: rule__BehaviorBooleanLiteral__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorBooleanLiteral__Group__0(); @@ -4427,11 +4848,11 @@ public final void ruleBehaviorBooleanLiteral() throws RecognitionException { // $ANTLR start "entryRuleReferenceExpression" - // InternalBehaviorAnnexParser.g:1385:1: entryRuleReferenceExpression : ruleReferenceExpression EOF ; + // InternalBehaviorAnnexParser.g:1510:1: entryRuleReferenceExpression : ruleReferenceExpression EOF ; public final void entryRuleReferenceExpression() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1386:1: ( ruleReferenceExpression EOF ) - // InternalBehaviorAnnexParser.g:1387:1: ruleReferenceExpression EOF + // InternalBehaviorAnnexParser.g:1511:1: ( ruleReferenceExpression EOF ) + // InternalBehaviorAnnexParser.g:1512:1: ruleReferenceExpression EOF { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionRule()); @@ -4461,23 +4882,23 @@ public final void entryRuleReferenceExpression() throws RecognitionException { // $ANTLR start "ruleReferenceExpression" - // InternalBehaviorAnnexParser.g:1394:1: ruleReferenceExpression : ( ( rule__ReferenceExpression__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1519:1: ruleReferenceExpression : ( ( rule__ReferenceExpression__Group__0 ) ) ; public final void ruleReferenceExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1398:2: ( ( ( rule__ReferenceExpression__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1399:2: ( ( rule__ReferenceExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1523:2: ( ( ( rule__ReferenceExpression__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1524:2: ( ( rule__ReferenceExpression__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1399:2: ( ( rule__ReferenceExpression__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1400:3: ( rule__ReferenceExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1524:2: ( ( rule__ReferenceExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1525:3: ( rule__ReferenceExpression__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1401:3: ( rule__ReferenceExpression__Group__0 ) - // InternalBehaviorAnnexParser.g:1401:4: rule__ReferenceExpression__Group__0 + // InternalBehaviorAnnexParser.g:1526:3: ( rule__ReferenceExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1526:4: rule__ReferenceExpression__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__Group__0(); @@ -4512,11 +4933,11 @@ public final void ruleReferenceExpression() throws RecognitionException { // $ANTLR start "entryRuleHashPropertyReference" - // InternalBehaviorAnnexParser.g:1410:1: entryRuleHashPropertyReference : ruleHashPropertyReference EOF ; + // InternalBehaviorAnnexParser.g:1535:1: entryRuleHashPropertyReference : ruleHashPropertyReference EOF ; public final void entryRuleHashPropertyReference() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1411:1: ( ruleHashPropertyReference EOF ) - // InternalBehaviorAnnexParser.g:1412:1: ruleHashPropertyReference EOF + // InternalBehaviorAnnexParser.g:1536:1: ( ruleHashPropertyReference EOF ) + // InternalBehaviorAnnexParser.g:1537:1: ruleHashPropertyReference EOF { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceRule()); @@ -4546,23 +4967,23 @@ public final void entryRuleHashPropertyReference() throws RecognitionException { // $ANTLR start "ruleHashPropertyReference" - // InternalBehaviorAnnexParser.g:1419:1: ruleHashPropertyReference : ( ( rule__HashPropertyReference__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1544:1: ruleHashPropertyReference : ( ( rule__HashPropertyReference__Group__0 ) ) ; public final void ruleHashPropertyReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1423:2: ( ( ( rule__HashPropertyReference__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1424:2: ( ( rule__HashPropertyReference__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1548:2: ( ( ( rule__HashPropertyReference__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1549:2: ( ( rule__HashPropertyReference__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1424:2: ( ( rule__HashPropertyReference__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1425:3: ( rule__HashPropertyReference__Group__0 ) + // InternalBehaviorAnnexParser.g:1549:2: ( ( rule__HashPropertyReference__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1550:3: ( rule__HashPropertyReference__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1426:3: ( rule__HashPropertyReference__Group__0 ) - // InternalBehaviorAnnexParser.g:1426:4: rule__HashPropertyReference__Group__0 + // InternalBehaviorAnnexParser.g:1551:3: ( rule__HashPropertyReference__Group__0 ) + // InternalBehaviorAnnexParser.g:1551:4: rule__HashPropertyReference__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__HashPropertyReference__Group__0(); @@ -4597,11 +5018,11 @@ public final void ruleHashPropertyReference() throws RecognitionException { // $ANTLR start "entryRulePropertyReferenceTail" - // InternalBehaviorAnnexParser.g:1435:1: entryRulePropertyReferenceTail : rulePropertyReferenceTail EOF ; + // InternalBehaviorAnnexParser.g:1560:1: entryRulePropertyReferenceTail : rulePropertyReferenceTail EOF ; public final void entryRulePropertyReferenceTail() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1436:1: ( rulePropertyReferenceTail EOF ) - // InternalBehaviorAnnexParser.g:1437:1: rulePropertyReferenceTail EOF + // InternalBehaviorAnnexParser.g:1561:1: ( rulePropertyReferenceTail EOF ) + // InternalBehaviorAnnexParser.g:1562:1: rulePropertyReferenceTail EOF { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailRule()); @@ -4631,23 +5052,23 @@ public final void entryRulePropertyReferenceTail() throws RecognitionException { // $ANTLR start "rulePropertyReferenceTail" - // InternalBehaviorAnnexParser.g:1444:1: rulePropertyReferenceTail : ( ( rule__PropertyReferenceTail__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1569:1: rulePropertyReferenceTail : ( ( rule__PropertyReferenceTail__Group__0 ) ) ; public final void rulePropertyReferenceTail() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1448:2: ( ( ( rule__PropertyReferenceTail__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1449:2: ( ( rule__PropertyReferenceTail__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1573:2: ( ( ( rule__PropertyReferenceTail__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1574:2: ( ( rule__PropertyReferenceTail__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1449:2: ( ( rule__PropertyReferenceTail__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1450:3: ( rule__PropertyReferenceTail__Group__0 ) + // InternalBehaviorAnnexParser.g:1574:2: ( ( rule__PropertyReferenceTail__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1575:3: ( rule__PropertyReferenceTail__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1451:3: ( rule__PropertyReferenceTail__Group__0 ) - // InternalBehaviorAnnexParser.g:1451:4: rule__PropertyReferenceTail__Group__0 + // InternalBehaviorAnnexParser.g:1576:3: ( rule__PropertyReferenceTail__Group__0 ) + // InternalBehaviorAnnexParser.g:1576:4: rule__PropertyReferenceTail__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyReferenceTail__Group__0(); @@ -4682,11 +5103,11 @@ public final void rulePropertyReferenceTail() throws RecognitionException { // $ANTLR start "entryRuleNamedPropertyField" - // InternalBehaviorAnnexParser.g:1460:1: entryRuleNamedPropertyField : ruleNamedPropertyField EOF ; + // InternalBehaviorAnnexParser.g:1585:1: entryRuleNamedPropertyField : ruleNamedPropertyField EOF ; public final void entryRuleNamedPropertyField() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1461:1: ( ruleNamedPropertyField EOF ) - // InternalBehaviorAnnexParser.g:1462:1: ruleNamedPropertyField EOF + // InternalBehaviorAnnexParser.g:1586:1: ( ruleNamedPropertyField EOF ) + // InternalBehaviorAnnexParser.g:1587:1: ruleNamedPropertyField EOF { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldRule()); @@ -4716,23 +5137,23 @@ public final void entryRuleNamedPropertyField() throws RecognitionException { // $ANTLR start "ruleNamedPropertyField" - // InternalBehaviorAnnexParser.g:1469:1: ruleNamedPropertyField : ( ( rule__NamedPropertyField__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1594:1: ruleNamedPropertyField : ( ( rule__NamedPropertyField__Group__0 ) ) ; public final void ruleNamedPropertyField() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1473:2: ( ( ( rule__NamedPropertyField__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1474:2: ( ( rule__NamedPropertyField__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1598:2: ( ( ( rule__NamedPropertyField__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1599:2: ( ( rule__NamedPropertyField__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1474:2: ( ( rule__NamedPropertyField__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1475:3: ( rule__NamedPropertyField__Group__0 ) + // InternalBehaviorAnnexParser.g:1599:2: ( ( rule__NamedPropertyField__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1600:3: ( rule__NamedPropertyField__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1476:3: ( rule__NamedPropertyField__Group__0 ) - // InternalBehaviorAnnexParser.g:1476:4: rule__NamedPropertyField__Group__0 + // InternalBehaviorAnnexParser.g:1601:3: ( rule__NamedPropertyField__Group__0 ) + // InternalBehaviorAnnexParser.g:1601:4: rule__NamedPropertyField__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__NamedPropertyField__Group__0(); @@ -4767,11 +5188,11 @@ public final void ruleNamedPropertyField() throws RecognitionException { // $ANTLR start "entryRulePropertyArrayIndex" - // InternalBehaviorAnnexParser.g:1485:1: entryRulePropertyArrayIndex : rulePropertyArrayIndex EOF ; + // InternalBehaviorAnnexParser.g:1610:1: entryRulePropertyArrayIndex : rulePropertyArrayIndex EOF ; public final void entryRulePropertyArrayIndex() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1486:1: ( rulePropertyArrayIndex EOF ) - // InternalBehaviorAnnexParser.g:1487:1: rulePropertyArrayIndex EOF + // InternalBehaviorAnnexParser.g:1611:1: ( rulePropertyArrayIndex EOF ) + // InternalBehaviorAnnexParser.g:1612:1: rulePropertyArrayIndex EOF { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyArrayIndexRule()); @@ -4801,23 +5222,23 @@ public final void entryRulePropertyArrayIndex() throws RecognitionException { // $ANTLR start "rulePropertyArrayIndex" - // InternalBehaviorAnnexParser.g:1494:1: rulePropertyArrayIndex : ( ( rule__PropertyArrayIndex__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1619:1: rulePropertyArrayIndex : ( ( rule__PropertyArrayIndex__Group__0 ) ) ; public final void rulePropertyArrayIndex() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1498:2: ( ( ( rule__PropertyArrayIndex__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1499:2: ( ( rule__PropertyArrayIndex__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1623:2: ( ( ( rule__PropertyArrayIndex__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1624:2: ( ( rule__PropertyArrayIndex__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1499:2: ( ( rule__PropertyArrayIndex__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1500:3: ( rule__PropertyArrayIndex__Group__0 ) + // InternalBehaviorAnnexParser.g:1624:2: ( ( rule__PropertyArrayIndex__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1625:3: ( rule__PropertyArrayIndex__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyArrayIndexAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1501:3: ( rule__PropertyArrayIndex__Group__0 ) - // InternalBehaviorAnnexParser.g:1501:4: rule__PropertyArrayIndex__Group__0 + // InternalBehaviorAnnexParser.g:1626:3: ( rule__PropertyArrayIndex__Group__0 ) + // InternalBehaviorAnnexParser.g:1626:4: rule__PropertyArrayIndex__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyArrayIndex__Group__0(); @@ -4852,11 +5273,11 @@ public final void rulePropertyArrayIndex() throws RecognitionException { // $ANTLR start "entryRulePropertyIndexValue" - // InternalBehaviorAnnexParser.g:1510:1: entryRulePropertyIndexValue : rulePropertyIndexValue EOF ; + // InternalBehaviorAnnexParser.g:1635:1: entryRulePropertyIndexValue : rulePropertyIndexValue EOF ; public final void entryRulePropertyIndexValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1511:1: ( rulePropertyIndexValue EOF ) - // InternalBehaviorAnnexParser.g:1512:1: rulePropertyIndexValue EOF + // InternalBehaviorAnnexParser.g:1636:1: ( rulePropertyIndexValue EOF ) + // InternalBehaviorAnnexParser.g:1637:1: rulePropertyIndexValue EOF { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexValueRule()); @@ -4886,23 +5307,23 @@ public final void entryRulePropertyIndexValue() throws RecognitionException { // $ANTLR start "rulePropertyIndexValue" - // InternalBehaviorAnnexParser.g:1519:1: rulePropertyIndexValue : ( ( rule__PropertyIndexValue__Alternatives ) ) ; + // InternalBehaviorAnnexParser.g:1644:1: rulePropertyIndexValue : ( ( rule__PropertyIndexValue__Alternatives ) ) ; public final void rulePropertyIndexValue() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1523:2: ( ( ( rule__PropertyIndexValue__Alternatives ) ) ) - // InternalBehaviorAnnexParser.g:1524:2: ( ( rule__PropertyIndexValue__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1648:2: ( ( ( rule__PropertyIndexValue__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1649:2: ( ( rule__PropertyIndexValue__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:1524:2: ( ( rule__PropertyIndexValue__Alternatives ) ) - // InternalBehaviorAnnexParser.g:1525:3: ( rule__PropertyIndexValue__Alternatives ) + // InternalBehaviorAnnexParser.g:1649:2: ( ( rule__PropertyIndexValue__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1650:3: ( rule__PropertyIndexValue__Alternatives ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexValueAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:1526:3: ( rule__PropertyIndexValue__Alternatives ) - // InternalBehaviorAnnexParser.g:1526:4: rule__PropertyIndexValue__Alternatives + // InternalBehaviorAnnexParser.g:1651:3: ( rule__PropertyIndexValue__Alternatives ) + // InternalBehaviorAnnexParser.g:1651:4: rule__PropertyIndexValue__Alternatives { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyIndexValue__Alternatives(); @@ -4937,11 +5358,11 @@ public final void rulePropertyIndexValue() throws RecognitionException { // $ANTLR start "entryRulePropertyIndexPropertyReference" - // InternalBehaviorAnnexParser.g:1535:1: entryRulePropertyIndexPropertyReference : rulePropertyIndexPropertyReference EOF ; + // InternalBehaviorAnnexParser.g:1660:1: entryRulePropertyIndexPropertyReference : rulePropertyIndexPropertyReference EOF ; public final void entryRulePropertyIndexPropertyReference() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1536:1: ( rulePropertyIndexPropertyReference EOF ) - // InternalBehaviorAnnexParser.g:1537:1: rulePropertyIndexPropertyReference EOF + // InternalBehaviorAnnexParser.g:1661:1: ( rulePropertyIndexPropertyReference EOF ) + // InternalBehaviorAnnexParser.g:1662:1: rulePropertyIndexPropertyReference EOF { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexPropertyReferenceRule()); @@ -4971,23 +5392,23 @@ public final void entryRulePropertyIndexPropertyReference() throws RecognitionEx // $ANTLR start "rulePropertyIndexPropertyReference" - // InternalBehaviorAnnexParser.g:1544:1: rulePropertyIndexPropertyReference : ( ( rule__PropertyIndexPropertyReference__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1669:1: rulePropertyIndexPropertyReference : ( ( rule__PropertyIndexPropertyReference__Group__0 ) ) ; public final void rulePropertyIndexPropertyReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1548:2: ( ( ( rule__PropertyIndexPropertyReference__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1549:2: ( ( rule__PropertyIndexPropertyReference__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1673:2: ( ( ( rule__PropertyIndexPropertyReference__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1674:2: ( ( rule__PropertyIndexPropertyReference__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1549:2: ( ( rule__PropertyIndexPropertyReference__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1550:3: ( rule__PropertyIndexPropertyReference__Group__0 ) + // InternalBehaviorAnnexParser.g:1674:2: ( ( rule__PropertyIndexPropertyReference__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1675:3: ( rule__PropertyIndexPropertyReference__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexPropertyReferenceAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1551:3: ( rule__PropertyIndexPropertyReference__Group__0 ) - // InternalBehaviorAnnexParser.g:1551:4: rule__PropertyIndexPropertyReference__Group__0 + // InternalBehaviorAnnexParser.g:1676:3: ( rule__PropertyIndexPropertyReference__Group__0 ) + // InternalBehaviorAnnexParser.g:1676:4: rule__PropertyIndexPropertyReference__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyIndexPropertyReference__Group__0(); @@ -5022,11 +5443,11 @@ public final void rulePropertyIndexPropertyReference() throws RecognitionExcepti // $ANTLR start "entryRuleUnindexedReferenceExpression" - // InternalBehaviorAnnexParser.g:1560:1: entryRuleUnindexedReferenceExpression : ruleUnindexedReferenceExpression EOF ; + // InternalBehaviorAnnexParser.g:1685:1: entryRuleUnindexedReferenceExpression : ruleUnindexedReferenceExpression EOF ; public final void entryRuleUnindexedReferenceExpression() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1561:1: ( ruleUnindexedReferenceExpression EOF ) - // InternalBehaviorAnnexParser.g:1562:1: ruleUnindexedReferenceExpression EOF + // InternalBehaviorAnnexParser.g:1686:1: ( ruleUnindexedReferenceExpression EOF ) + // InternalBehaviorAnnexParser.g:1687:1: ruleUnindexedReferenceExpression EOF { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionRule()); @@ -5056,23 +5477,23 @@ public final void entryRuleUnindexedReferenceExpression() throws RecognitionExce // $ANTLR start "ruleUnindexedReferenceExpression" - // InternalBehaviorAnnexParser.g:1569:1: ruleUnindexedReferenceExpression : ( ( rule__UnindexedReferenceExpression__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1694:1: ruleUnindexedReferenceExpression : ( ( rule__UnindexedReferenceExpression__Group__0 ) ) ; public final void ruleUnindexedReferenceExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1573:2: ( ( ( rule__UnindexedReferenceExpression__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1574:2: ( ( rule__UnindexedReferenceExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1698:2: ( ( ( rule__UnindexedReferenceExpression__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1699:2: ( ( rule__UnindexedReferenceExpression__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1574:2: ( ( rule__UnindexedReferenceExpression__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1575:3: ( rule__UnindexedReferenceExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1699:2: ( ( rule__UnindexedReferenceExpression__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1700:3: ( rule__UnindexedReferenceExpression__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1576:3: ( rule__UnindexedReferenceExpression__Group__0 ) - // InternalBehaviorAnnexParser.g:1576:4: rule__UnindexedReferenceExpression__Group__0 + // InternalBehaviorAnnexParser.g:1701:3: ( rule__UnindexedReferenceExpression__Group__0 ) + // InternalBehaviorAnnexParser.g:1701:4: rule__UnindexedReferenceExpression__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__Group__0(); @@ -5107,11 +5528,11 @@ public final void ruleUnindexedReferenceExpression() throws RecognitionException // $ANTLR start "entryRuleUnindexedReference" - // InternalBehaviorAnnexParser.g:1585:1: entryRuleUnindexedReference : ruleUnindexedReference EOF ; + // InternalBehaviorAnnexParser.g:1710:1: entryRuleUnindexedReference : ruleUnindexedReference EOF ; public final void entryRuleUnindexedReference() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1586:1: ( ruleUnindexedReference EOF ) - // InternalBehaviorAnnexParser.g:1587:1: ruleUnindexedReference EOF + // InternalBehaviorAnnexParser.g:1711:1: ( ruleUnindexedReference EOF ) + // InternalBehaviorAnnexParser.g:1712:1: ruleUnindexedReference EOF { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceRule()); @@ -5141,23 +5562,23 @@ public final void entryRuleUnindexedReference() throws RecognitionException { // $ANTLR start "ruleUnindexedReference" - // InternalBehaviorAnnexParser.g:1594:1: ruleUnindexedReference : ( ( rule__UnindexedReference__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1719:1: ruleUnindexedReference : ( ( rule__UnindexedReference__Group__0 ) ) ; public final void ruleUnindexedReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1598:2: ( ( ( rule__UnindexedReference__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1599:2: ( ( rule__UnindexedReference__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1723:2: ( ( ( rule__UnindexedReference__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1724:2: ( ( rule__UnindexedReference__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1599:2: ( ( rule__UnindexedReference__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1600:3: ( rule__UnindexedReference__Group__0 ) + // InternalBehaviorAnnexParser.g:1724:2: ( ( rule__UnindexedReference__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1725:3: ( rule__UnindexedReference__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1601:3: ( rule__UnindexedReference__Group__0 ) - // InternalBehaviorAnnexParser.g:1601:4: rule__UnindexedReference__Group__0 + // InternalBehaviorAnnexParser.g:1726:3: ( rule__UnindexedReference__Group__0 ) + // InternalBehaviorAnnexParser.g:1726:4: rule__UnindexedReference__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReference__Group__0(); @@ -5192,11 +5613,11 @@ public final void ruleUnindexedReference() throws RecognitionException { // $ANTLR start "entryRuleUnindexedReferenceTail" - // InternalBehaviorAnnexParser.g:1610:1: entryRuleUnindexedReferenceTail : ruleUnindexedReferenceTail EOF ; + // InternalBehaviorAnnexParser.g:1735:1: entryRuleUnindexedReferenceTail : ruleUnindexedReferenceTail EOF ; public final void entryRuleUnindexedReferenceTail() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1611:1: ( ruleUnindexedReferenceTail EOF ) - // InternalBehaviorAnnexParser.g:1612:1: ruleUnindexedReferenceTail EOF + // InternalBehaviorAnnexParser.g:1736:1: ( ruleUnindexedReferenceTail EOF ) + // InternalBehaviorAnnexParser.g:1737:1: ruleUnindexedReferenceTail EOF { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceTailRule()); @@ -5226,23 +5647,23 @@ public final void entryRuleUnindexedReferenceTail() throws RecognitionException // $ANTLR start "ruleUnindexedReferenceTail" - // InternalBehaviorAnnexParser.g:1619:1: ruleUnindexedReferenceTail : ( ( rule__UnindexedReferenceTail__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1744:1: ruleUnindexedReferenceTail : ( ( rule__UnindexedReferenceTail__Group__0 ) ) ; public final void ruleUnindexedReferenceTail() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1623:2: ( ( ( rule__UnindexedReferenceTail__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1624:2: ( ( rule__UnindexedReferenceTail__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1748:2: ( ( ( rule__UnindexedReferenceTail__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1749:2: ( ( rule__UnindexedReferenceTail__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1624:2: ( ( rule__UnindexedReferenceTail__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1625:3: ( rule__UnindexedReferenceTail__Group__0 ) + // InternalBehaviorAnnexParser.g:1749:2: ( ( rule__UnindexedReferenceTail__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1750:3: ( rule__UnindexedReferenceTail__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceTailAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1626:3: ( rule__UnindexedReferenceTail__Group__0 ) - // InternalBehaviorAnnexParser.g:1626:4: rule__UnindexedReferenceTail__Group__0 + // InternalBehaviorAnnexParser.g:1751:3: ( rule__UnindexedReferenceTail__Group__0 ) + // InternalBehaviorAnnexParser.g:1751:4: rule__UnindexedReferenceTail__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceTail__Group__0(); @@ -5277,11 +5698,11 @@ public final void ruleUnindexedReferenceTail() throws RecognitionException { // $ANTLR start "entryRuleUnindexedReferenceSegment" - // InternalBehaviorAnnexParser.g:1635:1: entryRuleUnindexedReferenceSegment : ruleUnindexedReferenceSegment EOF ; + // InternalBehaviorAnnexParser.g:1760:1: entryRuleUnindexedReferenceSegment : ruleUnindexedReferenceSegment EOF ; public final void entryRuleUnindexedReferenceSegment() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1636:1: ( ruleUnindexedReferenceSegment EOF ) - // InternalBehaviorAnnexParser.g:1637:1: ruleUnindexedReferenceSegment EOF + // InternalBehaviorAnnexParser.g:1761:1: ( ruleUnindexedReferenceSegment EOF ) + // InternalBehaviorAnnexParser.g:1762:1: ruleUnindexedReferenceSegment EOF { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceSegmentRule()); @@ -5311,23 +5732,23 @@ public final void entryRuleUnindexedReferenceSegment() throws RecognitionExcepti // $ANTLR start "ruleUnindexedReferenceSegment" - // InternalBehaviorAnnexParser.g:1644:1: ruleUnindexedReferenceSegment : ( ( rule__UnindexedReferenceSegment__NameAssignment ) ) ; + // InternalBehaviorAnnexParser.g:1769:1: ruleUnindexedReferenceSegment : ( ( rule__UnindexedReferenceSegment__NameAssignment ) ) ; public final void ruleUnindexedReferenceSegment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1648:2: ( ( ( rule__UnindexedReferenceSegment__NameAssignment ) ) ) - // InternalBehaviorAnnexParser.g:1649:2: ( ( rule__UnindexedReferenceSegment__NameAssignment ) ) + // InternalBehaviorAnnexParser.g:1773:2: ( ( ( rule__UnindexedReferenceSegment__NameAssignment ) ) ) + // InternalBehaviorAnnexParser.g:1774:2: ( ( rule__UnindexedReferenceSegment__NameAssignment ) ) { - // InternalBehaviorAnnexParser.g:1649:2: ( ( rule__UnindexedReferenceSegment__NameAssignment ) ) - // InternalBehaviorAnnexParser.g:1650:3: ( rule__UnindexedReferenceSegment__NameAssignment ) + // InternalBehaviorAnnexParser.g:1774:2: ( ( rule__UnindexedReferenceSegment__NameAssignment ) ) + // InternalBehaviorAnnexParser.g:1775:3: ( rule__UnindexedReferenceSegment__NameAssignment ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceSegmentAccess().getNameAssignment()); } - // InternalBehaviorAnnexParser.g:1651:3: ( rule__UnindexedReferenceSegment__NameAssignment ) - // InternalBehaviorAnnexParser.g:1651:4: rule__UnindexedReferenceSegment__NameAssignment + // InternalBehaviorAnnexParser.g:1776:3: ( rule__UnindexedReferenceSegment__NameAssignment ) + // InternalBehaviorAnnexParser.g:1776:4: rule__UnindexedReferenceSegment__NameAssignment { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceSegment__NameAssignment(); @@ -5362,11 +5783,11 @@ public final void ruleUnindexedReferenceSegment() throws RecognitionException { // $ANTLR start "entryRuleQualifiedName" - // InternalBehaviorAnnexParser.g:1660:1: entryRuleQualifiedName : ruleQualifiedName EOF ; + // InternalBehaviorAnnexParser.g:1785:1: entryRuleQualifiedName : ruleQualifiedName EOF ; public final void entryRuleQualifiedName() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1661:1: ( ruleQualifiedName EOF ) - // InternalBehaviorAnnexParser.g:1662:1: ruleQualifiedName EOF + // InternalBehaviorAnnexParser.g:1786:1: ( ruleQualifiedName EOF ) + // InternalBehaviorAnnexParser.g:1787:1: ruleQualifiedName EOF { if ( state.backtracking==0 ) { before(grammarAccess.getQualifiedNameRule()); @@ -5396,23 +5817,23 @@ public final void entryRuleQualifiedName() throws RecognitionException { // $ANTLR start "ruleQualifiedName" - // InternalBehaviorAnnexParser.g:1669:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1794:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ; public final void ruleQualifiedName() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1673:2: ( ( ( rule__QualifiedName__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1674:2: ( ( rule__QualifiedName__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1798:2: ( ( ( rule__QualifiedName__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1799:2: ( ( rule__QualifiedName__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1674:2: ( ( rule__QualifiedName__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1675:3: ( rule__QualifiedName__Group__0 ) + // InternalBehaviorAnnexParser.g:1799:2: ( ( rule__QualifiedName__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1800:3: ( rule__QualifiedName__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getQualifiedNameAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1676:3: ( rule__QualifiedName__Group__0 ) - // InternalBehaviorAnnexParser.g:1676:4: rule__QualifiedName__Group__0 + // InternalBehaviorAnnexParser.g:1801:3: ( rule__QualifiedName__Group__0 ) + // InternalBehaviorAnnexParser.g:1801:4: rule__QualifiedName__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__QualifiedName__Group__0(); @@ -5447,11 +5868,11 @@ public final void ruleQualifiedName() throws RecognitionException { // $ANTLR start "entryRuleReference" - // InternalBehaviorAnnexParser.g:1685:1: entryRuleReference : ruleReference EOF ; + // InternalBehaviorAnnexParser.g:1810:1: entryRuleReference : ruleReference EOF ; public final void entryRuleReference() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1686:1: ( ruleReference EOF ) - // InternalBehaviorAnnexParser.g:1687:1: ruleReference EOF + // InternalBehaviorAnnexParser.g:1811:1: ( ruleReference EOF ) + // InternalBehaviorAnnexParser.g:1812:1: ruleReference EOF { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceRule()); @@ -5481,23 +5902,23 @@ public final void entryRuleReference() throws RecognitionException { // $ANTLR start "ruleReference" - // InternalBehaviorAnnexParser.g:1694:1: ruleReference : ( ( rule__Reference__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1819:1: ruleReference : ( ( rule__Reference__Group__0 ) ) ; public final void ruleReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1698:2: ( ( ( rule__Reference__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1699:2: ( ( rule__Reference__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1823:2: ( ( ( rule__Reference__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1824:2: ( ( rule__Reference__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1699:2: ( ( rule__Reference__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1700:3: ( rule__Reference__Group__0 ) + // InternalBehaviorAnnexParser.g:1824:2: ( ( rule__Reference__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1825:3: ( rule__Reference__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1701:3: ( rule__Reference__Group__0 ) - // InternalBehaviorAnnexParser.g:1701:4: rule__Reference__Group__0 + // InternalBehaviorAnnexParser.g:1826:3: ( rule__Reference__Group__0 ) + // InternalBehaviorAnnexParser.g:1826:4: rule__Reference__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__Reference__Group__0(); @@ -5532,11 +5953,11 @@ public final void ruleReference() throws RecognitionException { // $ANTLR start "entryRuleReferenceTail" - // InternalBehaviorAnnexParser.g:1710:1: entryRuleReferenceTail : ruleReferenceTail EOF ; + // InternalBehaviorAnnexParser.g:1835:1: entryRuleReferenceTail : ruleReferenceTail EOF ; public final void entryRuleReferenceTail() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1711:1: ( ruleReferenceTail EOF ) - // InternalBehaviorAnnexParser.g:1712:1: ruleReferenceTail EOF + // InternalBehaviorAnnexParser.g:1836:1: ( ruleReferenceTail EOF ) + // InternalBehaviorAnnexParser.g:1837:1: ruleReferenceTail EOF { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTailRule()); @@ -5566,23 +5987,23 @@ public final void entryRuleReferenceTail() throws RecognitionException { // $ANTLR start "ruleReferenceTail" - // InternalBehaviorAnnexParser.g:1719:1: ruleReferenceTail : ( ( rule__ReferenceTail__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1844:1: ruleReferenceTail : ( ( rule__ReferenceTail__Group__0 ) ) ; public final void ruleReferenceTail() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1723:2: ( ( ( rule__ReferenceTail__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1724:2: ( ( rule__ReferenceTail__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1848:2: ( ( ( rule__ReferenceTail__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1849:2: ( ( rule__ReferenceTail__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1724:2: ( ( rule__ReferenceTail__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1725:3: ( rule__ReferenceTail__Group__0 ) + // InternalBehaviorAnnexParser.g:1849:2: ( ( rule__ReferenceTail__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1850:3: ( rule__ReferenceTail__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTailAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1726:3: ( rule__ReferenceTail__Group__0 ) - // InternalBehaviorAnnexParser.g:1726:4: rule__ReferenceTail__Group__0 + // InternalBehaviorAnnexParser.g:1851:3: ( rule__ReferenceTail__Group__0 ) + // InternalBehaviorAnnexParser.g:1851:4: rule__ReferenceTail__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTail__Group__0(); @@ -5617,11 +6038,11 @@ public final void ruleReferenceTail() throws RecognitionException { // $ANTLR start "entryRuleReferenceSeparator" - // InternalBehaviorAnnexParser.g:1735:1: entryRuleReferenceSeparator : ruleReferenceSeparator EOF ; + // InternalBehaviorAnnexParser.g:1860:1: entryRuleReferenceSeparator : ruleReferenceSeparator EOF ; public final void entryRuleReferenceSeparator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1736:1: ( ruleReferenceSeparator EOF ) - // InternalBehaviorAnnexParser.g:1737:1: ruleReferenceSeparator EOF + // InternalBehaviorAnnexParser.g:1861:1: ( ruleReferenceSeparator EOF ) + // InternalBehaviorAnnexParser.g:1862:1: ruleReferenceSeparator EOF { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSeparatorRule()); @@ -5651,23 +6072,23 @@ public final void entryRuleReferenceSeparator() throws RecognitionException { // $ANTLR start "ruleReferenceSeparator" - // InternalBehaviorAnnexParser.g:1744:1: ruleReferenceSeparator : ( ( rule__ReferenceSeparator__Alternatives ) ) ; + // InternalBehaviorAnnexParser.g:1869:1: ruleReferenceSeparator : ( ( rule__ReferenceSeparator__Alternatives ) ) ; public final void ruleReferenceSeparator() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1748:2: ( ( ( rule__ReferenceSeparator__Alternatives ) ) ) - // InternalBehaviorAnnexParser.g:1749:2: ( ( rule__ReferenceSeparator__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1873:2: ( ( ( rule__ReferenceSeparator__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:1874:2: ( ( rule__ReferenceSeparator__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:1749:2: ( ( rule__ReferenceSeparator__Alternatives ) ) - // InternalBehaviorAnnexParser.g:1750:3: ( rule__ReferenceSeparator__Alternatives ) + // InternalBehaviorAnnexParser.g:1874:2: ( ( rule__ReferenceSeparator__Alternatives ) ) + // InternalBehaviorAnnexParser.g:1875:3: ( rule__ReferenceSeparator__Alternatives ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSeparatorAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:1751:3: ( rule__ReferenceSeparator__Alternatives ) - // InternalBehaviorAnnexParser.g:1751:4: rule__ReferenceSeparator__Alternatives + // InternalBehaviorAnnexParser.g:1876:3: ( rule__ReferenceSeparator__Alternatives ) + // InternalBehaviorAnnexParser.g:1876:4: rule__ReferenceSeparator__Alternatives { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceSeparator__Alternatives(); @@ -5702,11 +6123,11 @@ public final void ruleReferenceSeparator() throws RecognitionException { // $ANTLR start "entryRuleReferenceSegment" - // InternalBehaviorAnnexParser.g:1760:1: entryRuleReferenceSegment : ruleReferenceSegment EOF ; + // InternalBehaviorAnnexParser.g:1885:1: entryRuleReferenceSegment : ruleReferenceSegment EOF ; public final void entryRuleReferenceSegment() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1761:1: ( ruleReferenceSegment EOF ) - // InternalBehaviorAnnexParser.g:1762:1: ruleReferenceSegment EOF + // InternalBehaviorAnnexParser.g:1886:1: ( ruleReferenceSegment EOF ) + // InternalBehaviorAnnexParser.g:1887:1: ruleReferenceSegment EOF { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSegmentRule()); @@ -5736,23 +6157,23 @@ public final void entryRuleReferenceSegment() throws RecognitionException { // $ANTLR start "ruleReferenceSegment" - // InternalBehaviorAnnexParser.g:1769:1: ruleReferenceSegment : ( ( rule__ReferenceSegment__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1894:1: ruleReferenceSegment : ( ( rule__ReferenceSegment__Group__0 ) ) ; public final void ruleReferenceSegment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1773:2: ( ( ( rule__ReferenceSegment__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1774:2: ( ( rule__ReferenceSegment__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1898:2: ( ( ( rule__ReferenceSegment__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1899:2: ( ( rule__ReferenceSegment__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1774:2: ( ( rule__ReferenceSegment__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1775:3: ( rule__ReferenceSegment__Group__0 ) + // InternalBehaviorAnnexParser.g:1899:2: ( ( rule__ReferenceSegment__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1900:3: ( rule__ReferenceSegment__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSegmentAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1776:3: ( rule__ReferenceSegment__Group__0 ) - // InternalBehaviorAnnexParser.g:1776:4: rule__ReferenceSegment__Group__0 + // InternalBehaviorAnnexParser.g:1901:3: ( rule__ReferenceSegment__Group__0 ) + // InternalBehaviorAnnexParser.g:1901:4: rule__ReferenceSegment__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceSegment__Group__0(); @@ -5787,11 +6208,11 @@ public final void ruleReferenceSegment() throws RecognitionException { // $ANTLR start "entryRuleArrayIndex" - // InternalBehaviorAnnexParser.g:1785:1: entryRuleArrayIndex : ruleArrayIndex EOF ; + // InternalBehaviorAnnexParser.g:1910:1: entryRuleArrayIndex : ruleArrayIndex EOF ; public final void entryRuleArrayIndex() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1786:1: ( ruleArrayIndex EOF ) - // InternalBehaviorAnnexParser.g:1787:1: ruleArrayIndex EOF + // InternalBehaviorAnnexParser.g:1911:1: ( ruleArrayIndex EOF ) + // InternalBehaviorAnnexParser.g:1912:1: ruleArrayIndex EOF { if ( state.backtracking==0 ) { before(grammarAccess.getArrayIndexRule()); @@ -5821,23 +6242,23 @@ public final void entryRuleArrayIndex() throws RecognitionException { // $ANTLR start "ruleArrayIndex" - // InternalBehaviorAnnexParser.g:1794:1: ruleArrayIndex : ( ( rule__ArrayIndex__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1919:1: ruleArrayIndex : ( ( rule__ArrayIndex__Group__0 ) ) ; public final void ruleArrayIndex() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1798:2: ( ( ( rule__ArrayIndex__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1799:2: ( ( rule__ArrayIndex__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1923:2: ( ( ( rule__ArrayIndex__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1924:2: ( ( rule__ArrayIndex__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1799:2: ( ( rule__ArrayIndex__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1800:3: ( rule__ArrayIndex__Group__0 ) + // InternalBehaviorAnnexParser.g:1924:2: ( ( rule__ArrayIndex__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1925:3: ( rule__ArrayIndex__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getArrayIndexAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1801:3: ( rule__ArrayIndex__Group__0 ) - // InternalBehaviorAnnexParser.g:1801:4: rule__ArrayIndex__Group__0 + // InternalBehaviorAnnexParser.g:1926:3: ( rule__ArrayIndex__Group__0 ) + // InternalBehaviorAnnexParser.g:1926:4: rule__ArrayIndex__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayIndex__Group__0(); @@ -5872,11 +6293,11 @@ public final void ruleArrayIndex() throws RecognitionException { // $ANTLR start "entryRuleContainedPropertyAssociation" - // InternalBehaviorAnnexParser.g:1810:1: entryRuleContainedPropertyAssociation : ruleContainedPropertyAssociation EOF ; + // InternalBehaviorAnnexParser.g:1935:1: entryRuleContainedPropertyAssociation : ruleContainedPropertyAssociation EOF ; public final void entryRuleContainedPropertyAssociation() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1811:1: ( ruleContainedPropertyAssociation EOF ) - // InternalBehaviorAnnexParser.g:1812:1: ruleContainedPropertyAssociation EOF + // InternalBehaviorAnnexParser.g:1936:1: ( ruleContainedPropertyAssociation EOF ) + // InternalBehaviorAnnexParser.g:1937:1: ruleContainedPropertyAssociation EOF { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationRule()); @@ -5906,23 +6327,23 @@ public final void entryRuleContainedPropertyAssociation() throws RecognitionExce // $ANTLR start "ruleContainedPropertyAssociation" - // InternalBehaviorAnnexParser.g:1819:1: ruleContainedPropertyAssociation : ( ( rule__ContainedPropertyAssociation__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1944:1: ruleContainedPropertyAssociation : ( ( rule__ContainedPropertyAssociation__Group__0 ) ) ; public final void ruleContainedPropertyAssociation() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1823:2: ( ( ( rule__ContainedPropertyAssociation__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1824:2: ( ( rule__ContainedPropertyAssociation__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1948:2: ( ( ( rule__ContainedPropertyAssociation__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1949:2: ( ( rule__ContainedPropertyAssociation__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1824:2: ( ( rule__ContainedPropertyAssociation__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1825:3: ( rule__ContainedPropertyAssociation__Group__0 ) + // InternalBehaviorAnnexParser.g:1949:2: ( ( rule__ContainedPropertyAssociation__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1950:3: ( rule__ContainedPropertyAssociation__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1826:3: ( rule__ContainedPropertyAssociation__Group__0 ) - // InternalBehaviorAnnexParser.g:1826:4: rule__ContainedPropertyAssociation__Group__0 + // InternalBehaviorAnnexParser.g:1951:3: ( rule__ContainedPropertyAssociation__Group__0 ) + // InternalBehaviorAnnexParser.g:1951:4: rule__ContainedPropertyAssociation__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group__0(); @@ -5957,11 +6378,11 @@ public final void ruleContainedPropertyAssociation() throws RecognitionException // $ANTLR start "entryRuleContainmentPath" - // InternalBehaviorAnnexParser.g:1835:1: entryRuleContainmentPath : ruleContainmentPath EOF ; + // InternalBehaviorAnnexParser.g:1960:1: entryRuleContainmentPath : ruleContainmentPath EOF ; public final void entryRuleContainmentPath() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1836:1: ( ruleContainmentPath EOF ) - // InternalBehaviorAnnexParser.g:1837:1: ruleContainmentPath EOF + // InternalBehaviorAnnexParser.g:1961:1: ( ruleContainmentPath EOF ) + // InternalBehaviorAnnexParser.g:1962:1: ruleContainmentPath EOF { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathRule()); @@ -5991,23 +6412,23 @@ public final void entryRuleContainmentPath() throws RecognitionException { // $ANTLR start "ruleContainmentPath" - // InternalBehaviorAnnexParser.g:1844:1: ruleContainmentPath : ( ( rule__ContainmentPath__PathAssignment ) ) ; + // InternalBehaviorAnnexParser.g:1969:1: ruleContainmentPath : ( ( rule__ContainmentPath__PathAssignment ) ) ; public final void ruleContainmentPath() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1848:2: ( ( ( rule__ContainmentPath__PathAssignment ) ) ) - // InternalBehaviorAnnexParser.g:1849:2: ( ( rule__ContainmentPath__PathAssignment ) ) + // InternalBehaviorAnnexParser.g:1973:2: ( ( ( rule__ContainmentPath__PathAssignment ) ) ) + // InternalBehaviorAnnexParser.g:1974:2: ( ( rule__ContainmentPath__PathAssignment ) ) { - // InternalBehaviorAnnexParser.g:1849:2: ( ( rule__ContainmentPath__PathAssignment ) ) - // InternalBehaviorAnnexParser.g:1850:3: ( rule__ContainmentPath__PathAssignment ) + // InternalBehaviorAnnexParser.g:1974:2: ( ( rule__ContainmentPath__PathAssignment ) ) + // InternalBehaviorAnnexParser.g:1975:3: ( rule__ContainmentPath__PathAssignment ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathAccess().getPathAssignment()); } - // InternalBehaviorAnnexParser.g:1851:3: ( rule__ContainmentPath__PathAssignment ) - // InternalBehaviorAnnexParser.g:1851:4: rule__ContainmentPath__PathAssignment + // InternalBehaviorAnnexParser.g:1976:3: ( rule__ContainmentPath__PathAssignment ) + // InternalBehaviorAnnexParser.g:1976:4: rule__ContainmentPath__PathAssignment { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPath__PathAssignment(); @@ -6042,11 +6463,11 @@ public final void ruleContainmentPath() throws RecognitionException { // $ANTLR start "entryRuleOptionalModalPropertyValue" - // InternalBehaviorAnnexParser.g:1860:1: entryRuleOptionalModalPropertyValue : ruleOptionalModalPropertyValue EOF ; + // InternalBehaviorAnnexParser.g:1985:1: entryRuleOptionalModalPropertyValue : ruleOptionalModalPropertyValue EOF ; public final void entryRuleOptionalModalPropertyValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1861:1: ( ruleOptionalModalPropertyValue EOF ) - // InternalBehaviorAnnexParser.g:1862:1: ruleOptionalModalPropertyValue EOF + // InternalBehaviorAnnexParser.g:1986:1: ( ruleOptionalModalPropertyValue EOF ) + // InternalBehaviorAnnexParser.g:1987:1: ruleOptionalModalPropertyValue EOF { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueRule()); @@ -6076,23 +6497,23 @@ public final void entryRuleOptionalModalPropertyValue() throws RecognitionExcept // $ANTLR start "ruleOptionalModalPropertyValue" - // InternalBehaviorAnnexParser.g:1869:1: ruleOptionalModalPropertyValue : ( ( rule__OptionalModalPropertyValue__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:1994:1: ruleOptionalModalPropertyValue : ( ( rule__OptionalModalPropertyValue__Group__0 ) ) ; public final void ruleOptionalModalPropertyValue() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1873:2: ( ( ( rule__OptionalModalPropertyValue__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1874:2: ( ( rule__OptionalModalPropertyValue__Group__0 ) ) + // InternalBehaviorAnnexParser.g:1998:2: ( ( ( rule__OptionalModalPropertyValue__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:1999:2: ( ( rule__OptionalModalPropertyValue__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1874:2: ( ( rule__OptionalModalPropertyValue__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1875:3: ( rule__OptionalModalPropertyValue__Group__0 ) + // InternalBehaviorAnnexParser.g:1999:2: ( ( rule__OptionalModalPropertyValue__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2000:3: ( rule__OptionalModalPropertyValue__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1876:3: ( rule__OptionalModalPropertyValue__Group__0 ) - // InternalBehaviorAnnexParser.g:1876:4: rule__OptionalModalPropertyValue__Group__0 + // InternalBehaviorAnnexParser.g:2001:3: ( rule__OptionalModalPropertyValue__Group__0 ) + // InternalBehaviorAnnexParser.g:2001:4: rule__OptionalModalPropertyValue__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__Group__0(); @@ -6127,11 +6548,11 @@ public final void ruleOptionalModalPropertyValue() throws RecognitionException { // $ANTLR start "entryRulePropertyValue" - // InternalBehaviorAnnexParser.g:1885:1: entryRulePropertyValue : rulePropertyValue EOF ; + // InternalBehaviorAnnexParser.g:2010:1: entryRulePropertyValue : rulePropertyValue EOF ; public final void entryRulePropertyValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1886:1: ( rulePropertyValue EOF ) - // InternalBehaviorAnnexParser.g:1887:1: rulePropertyValue EOF + // InternalBehaviorAnnexParser.g:2011:1: ( rulePropertyValue EOF ) + // InternalBehaviorAnnexParser.g:2012:1: rulePropertyValue EOF { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyValueRule()); @@ -6161,23 +6582,23 @@ public final void entryRulePropertyValue() throws RecognitionException { // $ANTLR start "rulePropertyValue" - // InternalBehaviorAnnexParser.g:1894:1: rulePropertyValue : ( ( rule__PropertyValue__OwnedValueAssignment ) ) ; + // InternalBehaviorAnnexParser.g:2019:1: rulePropertyValue : ( ( rule__PropertyValue__OwnedValueAssignment ) ) ; public final void rulePropertyValue() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1898:2: ( ( ( rule__PropertyValue__OwnedValueAssignment ) ) ) - // InternalBehaviorAnnexParser.g:1899:2: ( ( rule__PropertyValue__OwnedValueAssignment ) ) + // InternalBehaviorAnnexParser.g:2023:2: ( ( ( rule__PropertyValue__OwnedValueAssignment ) ) ) + // InternalBehaviorAnnexParser.g:2024:2: ( ( rule__PropertyValue__OwnedValueAssignment ) ) { - // InternalBehaviorAnnexParser.g:1899:2: ( ( rule__PropertyValue__OwnedValueAssignment ) ) - // InternalBehaviorAnnexParser.g:1900:3: ( rule__PropertyValue__OwnedValueAssignment ) + // InternalBehaviorAnnexParser.g:2024:2: ( ( rule__PropertyValue__OwnedValueAssignment ) ) + // InternalBehaviorAnnexParser.g:2025:3: ( rule__PropertyValue__OwnedValueAssignment ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyValueAccess().getOwnedValueAssignment()); } - // InternalBehaviorAnnexParser.g:1901:3: ( rule__PropertyValue__OwnedValueAssignment ) - // InternalBehaviorAnnexParser.g:1901:4: rule__PropertyValue__OwnedValueAssignment + // InternalBehaviorAnnexParser.g:2026:3: ( rule__PropertyValue__OwnedValueAssignment ) + // InternalBehaviorAnnexParser.g:2026:4: rule__PropertyValue__OwnedValueAssignment { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyValue__OwnedValueAssignment(); @@ -6212,11 +6633,11 @@ public final void rulePropertyValue() throws RecognitionException { // $ANTLR start "entryRulePropertyExpression" - // InternalBehaviorAnnexParser.g:1910:1: entryRulePropertyExpression : rulePropertyExpression EOF ; + // InternalBehaviorAnnexParser.g:2035:1: entryRulePropertyExpression : rulePropertyExpression EOF ; public final void entryRulePropertyExpression() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1911:1: ( rulePropertyExpression EOF ) - // InternalBehaviorAnnexParser.g:1912:1: rulePropertyExpression EOF + // InternalBehaviorAnnexParser.g:2036:1: ( rulePropertyExpression EOF ) + // InternalBehaviorAnnexParser.g:2037:1: rulePropertyExpression EOF { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionRule()); @@ -6246,23 +6667,23 @@ public final void entryRulePropertyExpression() throws RecognitionException { // $ANTLR start "rulePropertyExpression" - // InternalBehaviorAnnexParser.g:1919:1: rulePropertyExpression : ( ( rule__PropertyExpression__Alternatives ) ) ; + // InternalBehaviorAnnexParser.g:2044:1: rulePropertyExpression : ( ( rule__PropertyExpression__Alternatives ) ) ; public final void rulePropertyExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1923:2: ( ( ( rule__PropertyExpression__Alternatives ) ) ) - // InternalBehaviorAnnexParser.g:1924:2: ( ( rule__PropertyExpression__Alternatives ) ) + // InternalBehaviorAnnexParser.g:2048:2: ( ( ( rule__PropertyExpression__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:2049:2: ( ( rule__PropertyExpression__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:1924:2: ( ( rule__PropertyExpression__Alternatives ) ) - // InternalBehaviorAnnexParser.g:1925:3: ( rule__PropertyExpression__Alternatives ) + // InternalBehaviorAnnexParser.g:2049:2: ( ( rule__PropertyExpression__Alternatives ) ) + // InternalBehaviorAnnexParser.g:2050:3: ( rule__PropertyExpression__Alternatives ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:1926:3: ( rule__PropertyExpression__Alternatives ) - // InternalBehaviorAnnexParser.g:1926:4: rule__PropertyExpression__Alternatives + // InternalBehaviorAnnexParser.g:2051:3: ( rule__PropertyExpression__Alternatives ) + // InternalBehaviorAnnexParser.g:2051:4: rule__PropertyExpression__Alternatives { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyExpression__Alternatives(); @@ -6297,11 +6718,11 @@ public final void rulePropertyExpression() throws RecognitionException { // $ANTLR start "entryRuleLiteralorReferenceTerm" - // InternalBehaviorAnnexParser.g:1935:1: entryRuleLiteralorReferenceTerm : ruleLiteralorReferenceTerm EOF ; + // InternalBehaviorAnnexParser.g:2060:1: entryRuleLiteralorReferenceTerm : ruleLiteralorReferenceTerm EOF ; public final void entryRuleLiteralorReferenceTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1936:1: ( ruleLiteralorReferenceTerm EOF ) - // InternalBehaviorAnnexParser.g:1937:1: ruleLiteralorReferenceTerm EOF + // InternalBehaviorAnnexParser.g:2061:1: ( ruleLiteralorReferenceTerm EOF ) + // InternalBehaviorAnnexParser.g:2062:1: ruleLiteralorReferenceTerm EOF { if ( state.backtracking==0 ) { before(grammarAccess.getLiteralorReferenceTermRule()); @@ -6331,23 +6752,23 @@ public final void entryRuleLiteralorReferenceTerm() throws RecognitionException // $ANTLR start "ruleLiteralorReferenceTerm" - // InternalBehaviorAnnexParser.g:1944:1: ruleLiteralorReferenceTerm : ( ( rule__LiteralorReferenceTerm__NamedValueAssignment ) ) ; + // InternalBehaviorAnnexParser.g:2069:1: ruleLiteralorReferenceTerm : ( ( rule__LiteralorReferenceTerm__NamedValueAssignment ) ) ; public final void ruleLiteralorReferenceTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1948:2: ( ( ( rule__LiteralorReferenceTerm__NamedValueAssignment ) ) ) - // InternalBehaviorAnnexParser.g:1949:2: ( ( rule__LiteralorReferenceTerm__NamedValueAssignment ) ) + // InternalBehaviorAnnexParser.g:2073:2: ( ( ( rule__LiteralorReferenceTerm__NamedValueAssignment ) ) ) + // InternalBehaviorAnnexParser.g:2074:2: ( ( rule__LiteralorReferenceTerm__NamedValueAssignment ) ) { - // InternalBehaviorAnnexParser.g:1949:2: ( ( rule__LiteralorReferenceTerm__NamedValueAssignment ) ) - // InternalBehaviorAnnexParser.g:1950:3: ( rule__LiteralorReferenceTerm__NamedValueAssignment ) + // InternalBehaviorAnnexParser.g:2074:2: ( ( rule__LiteralorReferenceTerm__NamedValueAssignment ) ) + // InternalBehaviorAnnexParser.g:2075:3: ( rule__LiteralorReferenceTerm__NamedValueAssignment ) { if ( state.backtracking==0 ) { before(grammarAccess.getLiteralorReferenceTermAccess().getNamedValueAssignment()); } - // InternalBehaviorAnnexParser.g:1951:3: ( rule__LiteralorReferenceTerm__NamedValueAssignment ) - // InternalBehaviorAnnexParser.g:1951:4: rule__LiteralorReferenceTerm__NamedValueAssignment + // InternalBehaviorAnnexParser.g:2076:3: ( rule__LiteralorReferenceTerm__NamedValueAssignment ) + // InternalBehaviorAnnexParser.g:2076:4: rule__LiteralorReferenceTerm__NamedValueAssignment { pushFollow(FollowSets000.FOLLOW_2); rule__LiteralorReferenceTerm__NamedValueAssignment(); @@ -6382,11 +6803,11 @@ public final void ruleLiteralorReferenceTerm() throws RecognitionException { // $ANTLR start "entryRuleBooleanLiteral" - // InternalBehaviorAnnexParser.g:1960:1: entryRuleBooleanLiteral : ruleBooleanLiteral EOF ; + // InternalBehaviorAnnexParser.g:2085:1: entryRuleBooleanLiteral : ruleBooleanLiteral EOF ; public final void entryRuleBooleanLiteral() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1961:1: ( ruleBooleanLiteral EOF ) - // InternalBehaviorAnnexParser.g:1962:1: ruleBooleanLiteral EOF + // InternalBehaviorAnnexParser.g:2086:1: ( ruleBooleanLiteral EOF ) + // InternalBehaviorAnnexParser.g:2087:1: ruleBooleanLiteral EOF { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralRule()); @@ -6416,23 +6837,23 @@ public final void entryRuleBooleanLiteral() throws RecognitionException { // $ANTLR start "ruleBooleanLiteral" - // InternalBehaviorAnnexParser.g:1969:1: ruleBooleanLiteral : ( ( rule__BooleanLiteral__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2094:1: ruleBooleanLiteral : ( ( rule__BooleanLiteral__Group__0 ) ) ; public final void ruleBooleanLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1973:2: ( ( ( rule__BooleanLiteral__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:1974:2: ( ( rule__BooleanLiteral__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2098:2: ( ( ( rule__BooleanLiteral__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2099:2: ( ( rule__BooleanLiteral__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:1974:2: ( ( rule__BooleanLiteral__Group__0 ) ) - // InternalBehaviorAnnexParser.g:1975:3: ( rule__BooleanLiteral__Group__0 ) + // InternalBehaviorAnnexParser.g:2099:2: ( ( rule__BooleanLiteral__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2100:3: ( rule__BooleanLiteral__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:1976:3: ( rule__BooleanLiteral__Group__0 ) - // InternalBehaviorAnnexParser.g:1976:4: rule__BooleanLiteral__Group__0 + // InternalBehaviorAnnexParser.g:2101:3: ( rule__BooleanLiteral__Group__0 ) + // InternalBehaviorAnnexParser.g:2101:4: rule__BooleanLiteral__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BooleanLiteral__Group__0(); @@ -6467,11 +6888,11 @@ public final void ruleBooleanLiteral() throws RecognitionException { // $ANTLR start "entryRuleConstantValue" - // InternalBehaviorAnnexParser.g:1985:1: entryRuleConstantValue : ruleConstantValue EOF ; + // InternalBehaviorAnnexParser.g:2110:1: entryRuleConstantValue : ruleConstantValue EOF ; public final void entryRuleConstantValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:1986:1: ( ruleConstantValue EOF ) - // InternalBehaviorAnnexParser.g:1987:1: ruleConstantValue EOF + // InternalBehaviorAnnexParser.g:2111:1: ( ruleConstantValue EOF ) + // InternalBehaviorAnnexParser.g:2112:1: ruleConstantValue EOF { if ( state.backtracking==0 ) { before(grammarAccess.getConstantValueRule()); @@ -6501,23 +6922,23 @@ public final void entryRuleConstantValue() throws RecognitionException { // $ANTLR start "ruleConstantValue" - // InternalBehaviorAnnexParser.g:1994:1: ruleConstantValue : ( ( rule__ConstantValue__NamedValueAssignment ) ) ; + // InternalBehaviorAnnexParser.g:2119:1: ruleConstantValue : ( ( rule__ConstantValue__NamedValueAssignment ) ) ; public final void ruleConstantValue() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:1998:2: ( ( ( rule__ConstantValue__NamedValueAssignment ) ) ) - // InternalBehaviorAnnexParser.g:1999:2: ( ( rule__ConstantValue__NamedValueAssignment ) ) + // InternalBehaviorAnnexParser.g:2123:2: ( ( ( rule__ConstantValue__NamedValueAssignment ) ) ) + // InternalBehaviorAnnexParser.g:2124:2: ( ( rule__ConstantValue__NamedValueAssignment ) ) { - // InternalBehaviorAnnexParser.g:1999:2: ( ( rule__ConstantValue__NamedValueAssignment ) ) - // InternalBehaviorAnnexParser.g:2000:3: ( rule__ConstantValue__NamedValueAssignment ) + // InternalBehaviorAnnexParser.g:2124:2: ( ( rule__ConstantValue__NamedValueAssignment ) ) + // InternalBehaviorAnnexParser.g:2125:3: ( rule__ConstantValue__NamedValueAssignment ) { if ( state.backtracking==0 ) { before(grammarAccess.getConstantValueAccess().getNamedValueAssignment()); } - // InternalBehaviorAnnexParser.g:2001:3: ( rule__ConstantValue__NamedValueAssignment ) - // InternalBehaviorAnnexParser.g:2001:4: rule__ConstantValue__NamedValueAssignment + // InternalBehaviorAnnexParser.g:2126:3: ( rule__ConstantValue__NamedValueAssignment ) + // InternalBehaviorAnnexParser.g:2126:4: rule__ConstantValue__NamedValueAssignment { pushFollow(FollowSets000.FOLLOW_2); rule__ConstantValue__NamedValueAssignment(); @@ -6552,11 +6973,11 @@ public final void ruleConstantValue() throws RecognitionException { // $ANTLR start "entryRuleReferenceTerm" - // InternalBehaviorAnnexParser.g:2010:1: entryRuleReferenceTerm : ruleReferenceTerm EOF ; + // InternalBehaviorAnnexParser.g:2135:1: entryRuleReferenceTerm : ruleReferenceTerm EOF ; public final void entryRuleReferenceTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2011:1: ( ruleReferenceTerm EOF ) - // InternalBehaviorAnnexParser.g:2012:1: ruleReferenceTerm EOF + // InternalBehaviorAnnexParser.g:2136:1: ( ruleReferenceTerm EOF ) + // InternalBehaviorAnnexParser.g:2137:1: ruleReferenceTerm EOF { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermRule()); @@ -6586,23 +7007,23 @@ public final void entryRuleReferenceTerm() throws RecognitionException { // $ANTLR start "ruleReferenceTerm" - // InternalBehaviorAnnexParser.g:2019:1: ruleReferenceTerm : ( ( rule__ReferenceTerm__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2144:1: ruleReferenceTerm : ( ( rule__ReferenceTerm__Group__0 ) ) ; public final void ruleReferenceTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2023:2: ( ( ( rule__ReferenceTerm__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2024:2: ( ( rule__ReferenceTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2148:2: ( ( ( rule__ReferenceTerm__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2149:2: ( ( rule__ReferenceTerm__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2024:2: ( ( rule__ReferenceTerm__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2025:3: ( rule__ReferenceTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2149:2: ( ( rule__ReferenceTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2150:3: ( rule__ReferenceTerm__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2026:3: ( rule__ReferenceTerm__Group__0 ) - // InternalBehaviorAnnexParser.g:2026:4: rule__ReferenceTerm__Group__0 + // InternalBehaviorAnnexParser.g:2151:3: ( rule__ReferenceTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2151:4: rule__ReferenceTerm__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTerm__Group__0(); @@ -6637,11 +7058,11 @@ public final void ruleReferenceTerm() throws RecognitionException { // $ANTLR start "entryRuleRecordTerm" - // InternalBehaviorAnnexParser.g:2035:1: entryRuleRecordTerm : ruleRecordTerm EOF ; + // InternalBehaviorAnnexParser.g:2160:1: entryRuleRecordTerm : ruleRecordTerm EOF ; public final void entryRuleRecordTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2036:1: ( ruleRecordTerm EOF ) - // InternalBehaviorAnnexParser.g:2037:1: ruleRecordTerm EOF + // InternalBehaviorAnnexParser.g:2161:1: ( ruleRecordTerm EOF ) + // InternalBehaviorAnnexParser.g:2162:1: ruleRecordTerm EOF { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermRule()); @@ -6671,23 +7092,23 @@ public final void entryRuleRecordTerm() throws RecognitionException { // $ANTLR start "ruleRecordTerm" - // InternalBehaviorAnnexParser.g:2044:1: ruleRecordTerm : ( ( rule__RecordTerm__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2169:1: ruleRecordTerm : ( ( rule__RecordTerm__Group__0 ) ) ; public final void ruleRecordTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2048:2: ( ( ( rule__RecordTerm__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2049:2: ( ( rule__RecordTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2173:2: ( ( ( rule__RecordTerm__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2174:2: ( ( rule__RecordTerm__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2049:2: ( ( rule__RecordTerm__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2050:3: ( rule__RecordTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2174:2: ( ( rule__RecordTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2175:3: ( rule__RecordTerm__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2051:3: ( rule__RecordTerm__Group__0 ) - // InternalBehaviorAnnexParser.g:2051:4: rule__RecordTerm__Group__0 + // InternalBehaviorAnnexParser.g:2176:3: ( rule__RecordTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2176:4: rule__RecordTerm__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__RecordTerm__Group__0(); @@ -6722,11 +7143,11 @@ public final void ruleRecordTerm() throws RecognitionException { // $ANTLR start "entryRuleComputedTerm" - // InternalBehaviorAnnexParser.g:2060:1: entryRuleComputedTerm : ruleComputedTerm EOF ; + // InternalBehaviorAnnexParser.g:2185:1: entryRuleComputedTerm : ruleComputedTerm EOF ; public final void entryRuleComputedTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2061:1: ( ruleComputedTerm EOF ) - // InternalBehaviorAnnexParser.g:2062:1: ruleComputedTerm EOF + // InternalBehaviorAnnexParser.g:2186:1: ( ruleComputedTerm EOF ) + // InternalBehaviorAnnexParser.g:2187:1: ruleComputedTerm EOF { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermRule()); @@ -6756,23 +7177,23 @@ public final void entryRuleComputedTerm() throws RecognitionException { // $ANTLR start "ruleComputedTerm" - // InternalBehaviorAnnexParser.g:2069:1: ruleComputedTerm : ( ( rule__ComputedTerm__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2194:1: ruleComputedTerm : ( ( rule__ComputedTerm__Group__0 ) ) ; public final void ruleComputedTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2073:2: ( ( ( rule__ComputedTerm__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2074:2: ( ( rule__ComputedTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2198:2: ( ( ( rule__ComputedTerm__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2199:2: ( ( rule__ComputedTerm__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2074:2: ( ( rule__ComputedTerm__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2075:3: ( rule__ComputedTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2199:2: ( ( rule__ComputedTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2200:3: ( rule__ComputedTerm__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2076:3: ( rule__ComputedTerm__Group__0 ) - // InternalBehaviorAnnexParser.g:2076:4: rule__ComputedTerm__Group__0 + // InternalBehaviorAnnexParser.g:2201:3: ( rule__ComputedTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2201:4: rule__ComputedTerm__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ComputedTerm__Group__0(); @@ -6807,11 +7228,11 @@ public final void ruleComputedTerm() throws RecognitionException { // $ANTLR start "entryRuleComponentClassifierTerm" - // InternalBehaviorAnnexParser.g:2085:1: entryRuleComponentClassifierTerm : ruleComponentClassifierTerm EOF ; + // InternalBehaviorAnnexParser.g:2210:1: entryRuleComponentClassifierTerm : ruleComponentClassifierTerm EOF ; public final void entryRuleComponentClassifierTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2086:1: ( ruleComponentClassifierTerm EOF ) - // InternalBehaviorAnnexParser.g:2087:1: ruleComponentClassifierTerm EOF + // InternalBehaviorAnnexParser.g:2211:1: ( ruleComponentClassifierTerm EOF ) + // InternalBehaviorAnnexParser.g:2212:1: ruleComponentClassifierTerm EOF { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermRule()); @@ -6841,23 +7262,23 @@ public final void entryRuleComponentClassifierTerm() throws RecognitionException // $ANTLR start "ruleComponentClassifierTerm" - // InternalBehaviorAnnexParser.g:2094:1: ruleComponentClassifierTerm : ( ( rule__ComponentClassifierTerm__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2219:1: ruleComponentClassifierTerm : ( ( rule__ComponentClassifierTerm__Group__0 ) ) ; public final void ruleComponentClassifierTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2098:2: ( ( ( rule__ComponentClassifierTerm__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2099:2: ( ( rule__ComponentClassifierTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2223:2: ( ( ( rule__ComponentClassifierTerm__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2224:2: ( ( rule__ComponentClassifierTerm__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2099:2: ( ( rule__ComponentClassifierTerm__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2100:3: ( rule__ComponentClassifierTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2224:2: ( ( rule__ComponentClassifierTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2225:3: ( rule__ComponentClassifierTerm__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2101:3: ( rule__ComponentClassifierTerm__Group__0 ) - // InternalBehaviorAnnexParser.g:2101:4: rule__ComponentClassifierTerm__Group__0 + // InternalBehaviorAnnexParser.g:2226:3: ( rule__ComponentClassifierTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2226:4: rule__ComponentClassifierTerm__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ComponentClassifierTerm__Group__0(); @@ -6892,11 +7313,11 @@ public final void ruleComponentClassifierTerm() throws RecognitionException { // $ANTLR start "entryRuleListTerm" - // InternalBehaviorAnnexParser.g:2110:1: entryRuleListTerm : ruleListTerm EOF ; + // InternalBehaviorAnnexParser.g:2235:1: entryRuleListTerm : ruleListTerm EOF ; public final void entryRuleListTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2111:1: ( ruleListTerm EOF ) - // InternalBehaviorAnnexParser.g:2112:1: ruleListTerm EOF + // InternalBehaviorAnnexParser.g:2236:1: ( ruleListTerm EOF ) + // InternalBehaviorAnnexParser.g:2237:1: ruleListTerm EOF { if ( state.backtracking==0 ) { before(grammarAccess.getListTermRule()); @@ -6926,23 +7347,23 @@ public final void entryRuleListTerm() throws RecognitionException { // $ANTLR start "ruleListTerm" - // InternalBehaviorAnnexParser.g:2119:1: ruleListTerm : ( ( rule__ListTerm__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2244:1: ruleListTerm : ( ( rule__ListTerm__Group__0 ) ) ; public final void ruleListTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2123:2: ( ( ( rule__ListTerm__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2124:2: ( ( rule__ListTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2248:2: ( ( ( rule__ListTerm__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2249:2: ( ( rule__ListTerm__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2124:2: ( ( rule__ListTerm__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2125:3: ( rule__ListTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2249:2: ( ( rule__ListTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2250:3: ( rule__ListTerm__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2126:3: ( rule__ListTerm__Group__0 ) - // InternalBehaviorAnnexParser.g:2126:4: rule__ListTerm__Group__0 + // InternalBehaviorAnnexParser.g:2251:3: ( rule__ListTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2251:4: rule__ListTerm__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__Group__0(); @@ -6977,11 +7398,11 @@ public final void ruleListTerm() throws RecognitionException { // $ANTLR start "entryRuleFieldPropertyAssociation" - // InternalBehaviorAnnexParser.g:2135:1: entryRuleFieldPropertyAssociation : ruleFieldPropertyAssociation EOF ; + // InternalBehaviorAnnexParser.g:2260:1: entryRuleFieldPropertyAssociation : ruleFieldPropertyAssociation EOF ; public final void entryRuleFieldPropertyAssociation() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2136:1: ( ruleFieldPropertyAssociation EOF ) - // InternalBehaviorAnnexParser.g:2137:1: ruleFieldPropertyAssociation EOF + // InternalBehaviorAnnexParser.g:2261:1: ( ruleFieldPropertyAssociation EOF ) + // InternalBehaviorAnnexParser.g:2262:1: ruleFieldPropertyAssociation EOF { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationRule()); @@ -7011,23 +7432,23 @@ public final void entryRuleFieldPropertyAssociation() throws RecognitionExceptio // $ANTLR start "ruleFieldPropertyAssociation" - // InternalBehaviorAnnexParser.g:2144:1: ruleFieldPropertyAssociation : ( ( rule__FieldPropertyAssociation__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2269:1: ruleFieldPropertyAssociation : ( ( rule__FieldPropertyAssociation__Group__0 ) ) ; public final void ruleFieldPropertyAssociation() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2148:2: ( ( ( rule__FieldPropertyAssociation__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2149:2: ( ( rule__FieldPropertyAssociation__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2273:2: ( ( ( rule__FieldPropertyAssociation__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2274:2: ( ( rule__FieldPropertyAssociation__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2149:2: ( ( rule__FieldPropertyAssociation__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2150:3: ( rule__FieldPropertyAssociation__Group__0 ) + // InternalBehaviorAnnexParser.g:2274:2: ( ( rule__FieldPropertyAssociation__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2275:3: ( rule__FieldPropertyAssociation__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2151:3: ( rule__FieldPropertyAssociation__Group__0 ) - // InternalBehaviorAnnexParser.g:2151:4: rule__FieldPropertyAssociation__Group__0 + // InternalBehaviorAnnexParser.g:2276:3: ( rule__FieldPropertyAssociation__Group__0 ) + // InternalBehaviorAnnexParser.g:2276:4: rule__FieldPropertyAssociation__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__FieldPropertyAssociation__Group__0(); @@ -7062,11 +7483,11 @@ public final void ruleFieldPropertyAssociation() throws RecognitionException { // $ANTLR start "entryRuleContainmentPathElement" - // InternalBehaviorAnnexParser.g:2160:1: entryRuleContainmentPathElement : ruleContainmentPathElement EOF ; + // InternalBehaviorAnnexParser.g:2285:1: entryRuleContainmentPathElement : ruleContainmentPathElement EOF ; public final void entryRuleContainmentPathElement() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2161:1: ( ruleContainmentPathElement EOF ) - // InternalBehaviorAnnexParser.g:2162:1: ruleContainmentPathElement EOF + // InternalBehaviorAnnexParser.g:2286:1: ( ruleContainmentPathElement EOF ) + // InternalBehaviorAnnexParser.g:2287:1: ruleContainmentPathElement EOF { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementRule()); @@ -7096,23 +7517,23 @@ public final void entryRuleContainmentPathElement() throws RecognitionException // $ANTLR start "ruleContainmentPathElement" - // InternalBehaviorAnnexParser.g:2169:1: ruleContainmentPathElement : ( ( rule__ContainmentPathElement__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2294:1: ruleContainmentPathElement : ( ( rule__ContainmentPathElement__Group__0 ) ) ; public final void ruleContainmentPathElement() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2173:2: ( ( ( rule__ContainmentPathElement__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2174:2: ( ( rule__ContainmentPathElement__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2298:2: ( ( ( rule__ContainmentPathElement__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2299:2: ( ( rule__ContainmentPathElement__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2174:2: ( ( rule__ContainmentPathElement__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2175:3: ( rule__ContainmentPathElement__Group__0 ) + // InternalBehaviorAnnexParser.g:2299:2: ( ( rule__ContainmentPathElement__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2300:3: ( rule__ContainmentPathElement__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2176:3: ( rule__ContainmentPathElement__Group__0 ) - // InternalBehaviorAnnexParser.g:2176:4: rule__ContainmentPathElement__Group__0 + // InternalBehaviorAnnexParser.g:2301:3: ( rule__ContainmentPathElement__Group__0 ) + // InternalBehaviorAnnexParser.g:2301:4: rule__ContainmentPathElement__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group__0(); @@ -7147,11 +7568,11 @@ public final void ruleContainmentPathElement() throws RecognitionException { // $ANTLR start "entryRulePlusMinus" - // InternalBehaviorAnnexParser.g:2185:1: entryRulePlusMinus : rulePlusMinus EOF ; + // InternalBehaviorAnnexParser.g:2310:1: entryRulePlusMinus : rulePlusMinus EOF ; public final void entryRulePlusMinus() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2186:1: ( rulePlusMinus EOF ) - // InternalBehaviorAnnexParser.g:2187:1: rulePlusMinus EOF + // InternalBehaviorAnnexParser.g:2311:1: ( rulePlusMinus EOF ) + // InternalBehaviorAnnexParser.g:2312:1: rulePlusMinus EOF { if ( state.backtracking==0 ) { before(grammarAccess.getPlusMinusRule()); @@ -7181,23 +7602,23 @@ public final void entryRulePlusMinus() throws RecognitionException { // $ANTLR start "rulePlusMinus" - // InternalBehaviorAnnexParser.g:2194:1: rulePlusMinus : ( ( rule__PlusMinus__Alternatives ) ) ; + // InternalBehaviorAnnexParser.g:2319:1: rulePlusMinus : ( ( rule__PlusMinus__Alternatives ) ) ; public final void rulePlusMinus() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2198:2: ( ( ( rule__PlusMinus__Alternatives ) ) ) - // InternalBehaviorAnnexParser.g:2199:2: ( ( rule__PlusMinus__Alternatives ) ) + // InternalBehaviorAnnexParser.g:2323:2: ( ( ( rule__PlusMinus__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:2324:2: ( ( rule__PlusMinus__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:2199:2: ( ( rule__PlusMinus__Alternatives ) ) - // InternalBehaviorAnnexParser.g:2200:3: ( rule__PlusMinus__Alternatives ) + // InternalBehaviorAnnexParser.g:2324:2: ( ( rule__PlusMinus__Alternatives ) ) + // InternalBehaviorAnnexParser.g:2325:3: ( rule__PlusMinus__Alternatives ) { if ( state.backtracking==0 ) { before(grammarAccess.getPlusMinusAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:2201:3: ( rule__PlusMinus__Alternatives ) - // InternalBehaviorAnnexParser.g:2201:4: rule__PlusMinus__Alternatives + // InternalBehaviorAnnexParser.g:2326:3: ( rule__PlusMinus__Alternatives ) + // InternalBehaviorAnnexParser.g:2326:4: rule__PlusMinus__Alternatives { pushFollow(FollowSets000.FOLLOW_2); rule__PlusMinus__Alternatives(); @@ -7232,11 +7653,11 @@ public final void rulePlusMinus() throws RecognitionException { // $ANTLR start "entryRuleStringTerm" - // InternalBehaviorAnnexParser.g:2210:1: entryRuleStringTerm : ruleStringTerm EOF ; + // InternalBehaviorAnnexParser.g:2335:1: entryRuleStringTerm : ruleStringTerm EOF ; public final void entryRuleStringTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2211:1: ( ruleStringTerm EOF ) - // InternalBehaviorAnnexParser.g:2212:1: ruleStringTerm EOF + // InternalBehaviorAnnexParser.g:2336:1: ( ruleStringTerm EOF ) + // InternalBehaviorAnnexParser.g:2337:1: ruleStringTerm EOF { if ( state.backtracking==0 ) { before(grammarAccess.getStringTermRule()); @@ -7266,23 +7687,23 @@ public final void entryRuleStringTerm() throws RecognitionException { // $ANTLR start "ruleStringTerm" - // InternalBehaviorAnnexParser.g:2219:1: ruleStringTerm : ( ( rule__StringTerm__ValueAssignment ) ) ; + // InternalBehaviorAnnexParser.g:2344:1: ruleStringTerm : ( ( rule__StringTerm__ValueAssignment ) ) ; public final void ruleStringTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2223:2: ( ( ( rule__StringTerm__ValueAssignment ) ) ) - // InternalBehaviorAnnexParser.g:2224:2: ( ( rule__StringTerm__ValueAssignment ) ) + // InternalBehaviorAnnexParser.g:2348:2: ( ( ( rule__StringTerm__ValueAssignment ) ) ) + // InternalBehaviorAnnexParser.g:2349:2: ( ( rule__StringTerm__ValueAssignment ) ) { - // InternalBehaviorAnnexParser.g:2224:2: ( ( rule__StringTerm__ValueAssignment ) ) - // InternalBehaviorAnnexParser.g:2225:3: ( rule__StringTerm__ValueAssignment ) + // InternalBehaviorAnnexParser.g:2349:2: ( ( rule__StringTerm__ValueAssignment ) ) + // InternalBehaviorAnnexParser.g:2350:3: ( rule__StringTerm__ValueAssignment ) { if ( state.backtracking==0 ) { before(grammarAccess.getStringTermAccess().getValueAssignment()); } - // InternalBehaviorAnnexParser.g:2226:3: ( rule__StringTerm__ValueAssignment ) - // InternalBehaviorAnnexParser.g:2226:4: rule__StringTerm__ValueAssignment + // InternalBehaviorAnnexParser.g:2351:3: ( rule__StringTerm__ValueAssignment ) + // InternalBehaviorAnnexParser.g:2351:4: rule__StringTerm__ValueAssignment { pushFollow(FollowSets000.FOLLOW_2); rule__StringTerm__ValueAssignment(); @@ -7317,11 +7738,11 @@ public final void ruleStringTerm() throws RecognitionException { // $ANTLR start "entryRuleNoQuoteString" - // InternalBehaviorAnnexParser.g:2235:1: entryRuleNoQuoteString : ruleNoQuoteString EOF ; + // InternalBehaviorAnnexParser.g:2360:1: entryRuleNoQuoteString : ruleNoQuoteString EOF ; public final void entryRuleNoQuoteString() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2236:1: ( ruleNoQuoteString EOF ) - // InternalBehaviorAnnexParser.g:2237:1: ruleNoQuoteString EOF + // InternalBehaviorAnnexParser.g:2361:1: ( ruleNoQuoteString EOF ) + // InternalBehaviorAnnexParser.g:2362:1: ruleNoQuoteString EOF { if ( state.backtracking==0 ) { before(grammarAccess.getNoQuoteStringRule()); @@ -7351,17 +7772,17 @@ public final void entryRuleNoQuoteString() throws RecognitionException { // $ANTLR start "ruleNoQuoteString" - // InternalBehaviorAnnexParser.g:2244:1: ruleNoQuoteString : ( RULE_STRING ) ; + // InternalBehaviorAnnexParser.g:2369:1: ruleNoQuoteString : ( RULE_STRING ) ; public final void ruleNoQuoteString() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2248:2: ( ( RULE_STRING ) ) - // InternalBehaviorAnnexParser.g:2249:2: ( RULE_STRING ) + // InternalBehaviorAnnexParser.g:2373:2: ( ( RULE_STRING ) ) + // InternalBehaviorAnnexParser.g:2374:2: ( RULE_STRING ) { - // InternalBehaviorAnnexParser.g:2249:2: ( RULE_STRING ) - // InternalBehaviorAnnexParser.g:2250:3: RULE_STRING + // InternalBehaviorAnnexParser.g:2374:2: ( RULE_STRING ) + // InternalBehaviorAnnexParser.g:2375:3: RULE_STRING { if ( state.backtracking==0 ) { before(grammarAccess.getNoQuoteStringAccess().getSTRINGTerminalRuleCall()); @@ -7392,11 +7813,11 @@ public final void ruleNoQuoteString() throws RecognitionException { // $ANTLR start "entryRuleArrayRange" - // InternalBehaviorAnnexParser.g:2260:1: entryRuleArrayRange : ruleArrayRange EOF ; + // InternalBehaviorAnnexParser.g:2385:1: entryRuleArrayRange : ruleArrayRange EOF ; public final void entryRuleArrayRange() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2261:1: ( ruleArrayRange EOF ) - // InternalBehaviorAnnexParser.g:2262:1: ruleArrayRange EOF + // InternalBehaviorAnnexParser.g:2386:1: ( ruleArrayRange EOF ) + // InternalBehaviorAnnexParser.g:2387:1: ruleArrayRange EOF { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeRule()); @@ -7426,23 +7847,23 @@ public final void entryRuleArrayRange() throws RecognitionException { // $ANTLR start "ruleArrayRange" - // InternalBehaviorAnnexParser.g:2269:1: ruleArrayRange : ( ( rule__ArrayRange__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2394:1: ruleArrayRange : ( ( rule__ArrayRange__Group__0 ) ) ; public final void ruleArrayRange() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2273:2: ( ( ( rule__ArrayRange__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2274:2: ( ( rule__ArrayRange__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2398:2: ( ( ( rule__ArrayRange__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2399:2: ( ( rule__ArrayRange__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2274:2: ( ( rule__ArrayRange__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2275:3: ( rule__ArrayRange__Group__0 ) + // InternalBehaviorAnnexParser.g:2399:2: ( ( rule__ArrayRange__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2400:3: ( rule__ArrayRange__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2276:3: ( rule__ArrayRange__Group__0 ) - // InternalBehaviorAnnexParser.g:2276:4: rule__ArrayRange__Group__0 + // InternalBehaviorAnnexParser.g:2401:3: ( rule__ArrayRange__Group__0 ) + // InternalBehaviorAnnexParser.g:2401:4: rule__ArrayRange__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__Group__0(); @@ -7477,11 +7898,11 @@ public final void ruleArrayRange() throws RecognitionException { // $ANTLR start "entryRuleSignedConstant" - // InternalBehaviorAnnexParser.g:2285:1: entryRuleSignedConstant : ruleSignedConstant EOF ; + // InternalBehaviorAnnexParser.g:2410:1: entryRuleSignedConstant : ruleSignedConstant EOF ; public final void entryRuleSignedConstant() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2286:1: ( ruleSignedConstant EOF ) - // InternalBehaviorAnnexParser.g:2287:1: ruleSignedConstant EOF + // InternalBehaviorAnnexParser.g:2411:1: ( ruleSignedConstant EOF ) + // InternalBehaviorAnnexParser.g:2412:1: ruleSignedConstant EOF { if ( state.backtracking==0 ) { before(grammarAccess.getSignedConstantRule()); @@ -7511,23 +7932,23 @@ public final void entryRuleSignedConstant() throws RecognitionException { // $ANTLR start "ruleSignedConstant" - // InternalBehaviorAnnexParser.g:2294:1: ruleSignedConstant : ( ( rule__SignedConstant__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2419:1: ruleSignedConstant : ( ( rule__SignedConstant__Group__0 ) ) ; public final void ruleSignedConstant() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2298:2: ( ( ( rule__SignedConstant__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2299:2: ( ( rule__SignedConstant__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2423:2: ( ( ( rule__SignedConstant__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2424:2: ( ( rule__SignedConstant__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2299:2: ( ( rule__SignedConstant__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2300:3: ( rule__SignedConstant__Group__0 ) + // InternalBehaviorAnnexParser.g:2424:2: ( ( rule__SignedConstant__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2425:3: ( rule__SignedConstant__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSignedConstantAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2301:3: ( rule__SignedConstant__Group__0 ) - // InternalBehaviorAnnexParser.g:2301:4: rule__SignedConstant__Group__0 + // InternalBehaviorAnnexParser.g:2426:3: ( rule__SignedConstant__Group__0 ) + // InternalBehaviorAnnexParser.g:2426:4: rule__SignedConstant__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedConstant__Group__0(); @@ -7562,11 +7983,11 @@ public final void ruleSignedConstant() throws RecognitionException { // $ANTLR start "entryRuleIntegerTerm" - // InternalBehaviorAnnexParser.g:2310:1: entryRuleIntegerTerm : ruleIntegerTerm EOF ; + // InternalBehaviorAnnexParser.g:2435:1: entryRuleIntegerTerm : ruleIntegerTerm EOF ; public final void entryRuleIntegerTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2311:1: ( ruleIntegerTerm EOF ) - // InternalBehaviorAnnexParser.g:2312:1: ruleIntegerTerm EOF + // InternalBehaviorAnnexParser.g:2436:1: ( ruleIntegerTerm EOF ) + // InternalBehaviorAnnexParser.g:2437:1: ruleIntegerTerm EOF { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermRule()); @@ -7596,23 +8017,23 @@ public final void entryRuleIntegerTerm() throws RecognitionException { // $ANTLR start "ruleIntegerTerm" - // InternalBehaviorAnnexParser.g:2319:1: ruleIntegerTerm : ( ( rule__IntegerTerm__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2444:1: ruleIntegerTerm : ( ( rule__IntegerTerm__Group__0 ) ) ; public final void ruleIntegerTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2323:2: ( ( ( rule__IntegerTerm__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2324:2: ( ( rule__IntegerTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2448:2: ( ( ( rule__IntegerTerm__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2449:2: ( ( rule__IntegerTerm__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2324:2: ( ( rule__IntegerTerm__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2325:3: ( rule__IntegerTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2449:2: ( ( rule__IntegerTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2450:3: ( rule__IntegerTerm__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2326:3: ( rule__IntegerTerm__Group__0 ) - // InternalBehaviorAnnexParser.g:2326:4: rule__IntegerTerm__Group__0 + // InternalBehaviorAnnexParser.g:2451:3: ( rule__IntegerTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2451:4: rule__IntegerTerm__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__IntegerTerm__Group__0(); @@ -7647,11 +8068,11 @@ public final void ruleIntegerTerm() throws RecognitionException { // $ANTLR start "entryRuleSignedInt" - // InternalBehaviorAnnexParser.g:2335:1: entryRuleSignedInt : ruleSignedInt EOF ; + // InternalBehaviorAnnexParser.g:2460:1: entryRuleSignedInt : ruleSignedInt EOF ; public final void entryRuleSignedInt() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2336:1: ( ruleSignedInt EOF ) - // InternalBehaviorAnnexParser.g:2337:1: ruleSignedInt EOF + // InternalBehaviorAnnexParser.g:2461:1: ( ruleSignedInt EOF ) + // InternalBehaviorAnnexParser.g:2462:1: ruleSignedInt EOF { if ( state.backtracking==0 ) { before(grammarAccess.getSignedIntRule()); @@ -7681,23 +8102,23 @@ public final void entryRuleSignedInt() throws RecognitionException { // $ANTLR start "ruleSignedInt" - // InternalBehaviorAnnexParser.g:2344:1: ruleSignedInt : ( ( rule__SignedInt__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2469:1: ruleSignedInt : ( ( rule__SignedInt__Group__0 ) ) ; public final void ruleSignedInt() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2348:2: ( ( ( rule__SignedInt__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2349:2: ( ( rule__SignedInt__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2473:2: ( ( ( rule__SignedInt__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2474:2: ( ( rule__SignedInt__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2349:2: ( ( rule__SignedInt__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2350:3: ( rule__SignedInt__Group__0 ) + // InternalBehaviorAnnexParser.g:2474:2: ( ( rule__SignedInt__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2475:3: ( rule__SignedInt__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSignedIntAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2351:3: ( rule__SignedInt__Group__0 ) - // InternalBehaviorAnnexParser.g:2351:4: rule__SignedInt__Group__0 + // InternalBehaviorAnnexParser.g:2476:3: ( rule__SignedInt__Group__0 ) + // InternalBehaviorAnnexParser.g:2476:4: rule__SignedInt__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedInt__Group__0(); @@ -7732,11 +8153,11 @@ public final void ruleSignedInt() throws RecognitionException { // $ANTLR start "entryRuleRealTerm" - // InternalBehaviorAnnexParser.g:2360:1: entryRuleRealTerm : ruleRealTerm EOF ; + // InternalBehaviorAnnexParser.g:2485:1: entryRuleRealTerm : ruleRealTerm EOF ; public final void entryRuleRealTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2361:1: ( ruleRealTerm EOF ) - // InternalBehaviorAnnexParser.g:2362:1: ruleRealTerm EOF + // InternalBehaviorAnnexParser.g:2486:1: ( ruleRealTerm EOF ) + // InternalBehaviorAnnexParser.g:2487:1: ruleRealTerm EOF { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermRule()); @@ -7766,23 +8187,23 @@ public final void entryRuleRealTerm() throws RecognitionException { // $ANTLR start "ruleRealTerm" - // InternalBehaviorAnnexParser.g:2369:1: ruleRealTerm : ( ( rule__RealTerm__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2494:1: ruleRealTerm : ( ( rule__RealTerm__Group__0 ) ) ; public final void ruleRealTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2373:2: ( ( ( rule__RealTerm__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2374:2: ( ( rule__RealTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2498:2: ( ( ( rule__RealTerm__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2499:2: ( ( rule__RealTerm__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2374:2: ( ( rule__RealTerm__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2375:3: ( rule__RealTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2499:2: ( ( rule__RealTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2500:3: ( rule__RealTerm__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2376:3: ( rule__RealTerm__Group__0 ) - // InternalBehaviorAnnexParser.g:2376:4: rule__RealTerm__Group__0 + // InternalBehaviorAnnexParser.g:2501:3: ( rule__RealTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2501:4: rule__RealTerm__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__RealTerm__Group__0(); @@ -7817,11 +8238,11 @@ public final void ruleRealTerm() throws RecognitionException { // $ANTLR start "entryRuleSignedReal" - // InternalBehaviorAnnexParser.g:2385:1: entryRuleSignedReal : ruleSignedReal EOF ; + // InternalBehaviorAnnexParser.g:2510:1: entryRuleSignedReal : ruleSignedReal EOF ; public final void entryRuleSignedReal() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2386:1: ( ruleSignedReal EOF ) - // InternalBehaviorAnnexParser.g:2387:1: ruleSignedReal EOF + // InternalBehaviorAnnexParser.g:2511:1: ( ruleSignedReal EOF ) + // InternalBehaviorAnnexParser.g:2512:1: ruleSignedReal EOF { if ( state.backtracking==0 ) { before(grammarAccess.getSignedRealRule()); @@ -7851,23 +8272,23 @@ public final void entryRuleSignedReal() throws RecognitionException { // $ANTLR start "ruleSignedReal" - // InternalBehaviorAnnexParser.g:2394:1: ruleSignedReal : ( ( rule__SignedReal__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2519:1: ruleSignedReal : ( ( rule__SignedReal__Group__0 ) ) ; public final void ruleSignedReal() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2398:2: ( ( ( rule__SignedReal__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2399:2: ( ( rule__SignedReal__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2523:2: ( ( ( rule__SignedReal__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2524:2: ( ( rule__SignedReal__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2399:2: ( ( rule__SignedReal__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2400:3: ( rule__SignedReal__Group__0 ) + // InternalBehaviorAnnexParser.g:2524:2: ( ( rule__SignedReal__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2525:3: ( rule__SignedReal__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSignedRealAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2401:3: ( rule__SignedReal__Group__0 ) - // InternalBehaviorAnnexParser.g:2401:4: rule__SignedReal__Group__0 + // InternalBehaviorAnnexParser.g:2526:3: ( rule__SignedReal__Group__0 ) + // InternalBehaviorAnnexParser.g:2526:4: rule__SignedReal__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedReal__Group__0(); @@ -7902,11 +8323,11 @@ public final void ruleSignedReal() throws RecognitionException { // $ANTLR start "entryRuleNumericRangeTerm" - // InternalBehaviorAnnexParser.g:2410:1: entryRuleNumericRangeTerm : ruleNumericRangeTerm EOF ; + // InternalBehaviorAnnexParser.g:2535:1: entryRuleNumericRangeTerm : ruleNumericRangeTerm EOF ; public final void entryRuleNumericRangeTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2411:1: ( ruleNumericRangeTerm EOF ) - // InternalBehaviorAnnexParser.g:2412:1: ruleNumericRangeTerm EOF + // InternalBehaviorAnnexParser.g:2536:1: ( ruleNumericRangeTerm EOF ) + // InternalBehaviorAnnexParser.g:2537:1: ruleNumericRangeTerm EOF { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermRule()); @@ -7936,23 +8357,23 @@ public final void entryRuleNumericRangeTerm() throws RecognitionException { // $ANTLR start "ruleNumericRangeTerm" - // InternalBehaviorAnnexParser.g:2419:1: ruleNumericRangeTerm : ( ( rule__NumericRangeTerm__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2544:1: ruleNumericRangeTerm : ( ( rule__NumericRangeTerm__Group__0 ) ) ; public final void ruleNumericRangeTerm() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2423:2: ( ( ( rule__NumericRangeTerm__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2424:2: ( ( rule__NumericRangeTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2548:2: ( ( ( rule__NumericRangeTerm__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2549:2: ( ( rule__NumericRangeTerm__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2424:2: ( ( rule__NumericRangeTerm__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2425:3: ( rule__NumericRangeTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2549:2: ( ( rule__NumericRangeTerm__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2550:3: ( rule__NumericRangeTerm__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2426:3: ( rule__NumericRangeTerm__Group__0 ) - // InternalBehaviorAnnexParser.g:2426:4: rule__NumericRangeTerm__Group__0 + // InternalBehaviorAnnexParser.g:2551:3: ( rule__NumericRangeTerm__Group__0 ) + // InternalBehaviorAnnexParser.g:2551:4: rule__NumericRangeTerm__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__Group__0(); @@ -7987,11 +8408,11 @@ public final void ruleNumericRangeTerm() throws RecognitionException { // $ANTLR start "entryRuleNumAlt" - // InternalBehaviorAnnexParser.g:2435:1: entryRuleNumAlt : ruleNumAlt EOF ; + // InternalBehaviorAnnexParser.g:2560:1: entryRuleNumAlt : ruleNumAlt EOF ; public final void entryRuleNumAlt() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2436:1: ( ruleNumAlt EOF ) - // InternalBehaviorAnnexParser.g:2437:1: ruleNumAlt EOF + // InternalBehaviorAnnexParser.g:2561:1: ( ruleNumAlt EOF ) + // InternalBehaviorAnnexParser.g:2562:1: ruleNumAlt EOF { if ( state.backtracking==0 ) { before(grammarAccess.getNumAltRule()); @@ -8021,23 +8442,23 @@ public final void entryRuleNumAlt() throws RecognitionException { // $ANTLR start "ruleNumAlt" - // InternalBehaviorAnnexParser.g:2444:1: ruleNumAlt : ( ( rule__NumAlt__Alternatives ) ) ; + // InternalBehaviorAnnexParser.g:2569:1: ruleNumAlt : ( ( rule__NumAlt__Alternatives ) ) ; public final void ruleNumAlt() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2448:2: ( ( ( rule__NumAlt__Alternatives ) ) ) - // InternalBehaviorAnnexParser.g:2449:2: ( ( rule__NumAlt__Alternatives ) ) + // InternalBehaviorAnnexParser.g:2573:2: ( ( ( rule__NumAlt__Alternatives ) ) ) + // InternalBehaviorAnnexParser.g:2574:2: ( ( rule__NumAlt__Alternatives ) ) { - // InternalBehaviorAnnexParser.g:2449:2: ( ( rule__NumAlt__Alternatives ) ) - // InternalBehaviorAnnexParser.g:2450:3: ( rule__NumAlt__Alternatives ) + // InternalBehaviorAnnexParser.g:2574:2: ( ( rule__NumAlt__Alternatives ) ) + // InternalBehaviorAnnexParser.g:2575:3: ( rule__NumAlt__Alternatives ) { if ( state.backtracking==0 ) { before(grammarAccess.getNumAltAccess().getAlternatives()); } - // InternalBehaviorAnnexParser.g:2451:3: ( rule__NumAlt__Alternatives ) - // InternalBehaviorAnnexParser.g:2451:4: rule__NumAlt__Alternatives + // InternalBehaviorAnnexParser.g:2576:3: ( rule__NumAlt__Alternatives ) + // InternalBehaviorAnnexParser.g:2576:4: rule__NumAlt__Alternatives { pushFollow(FollowSets000.FOLLOW_2); rule__NumAlt__Alternatives(); @@ -8072,11 +8493,11 @@ public final void ruleNumAlt() throws RecognitionException { // $ANTLR start "entryRuleINTVALUE" - // InternalBehaviorAnnexParser.g:2460:1: entryRuleINTVALUE : ruleINTVALUE EOF ; + // InternalBehaviorAnnexParser.g:2585:1: entryRuleINTVALUE : ruleINTVALUE EOF ; public final void entryRuleINTVALUE() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2461:1: ( ruleINTVALUE EOF ) - // InternalBehaviorAnnexParser.g:2462:1: ruleINTVALUE EOF + // InternalBehaviorAnnexParser.g:2586:1: ( ruleINTVALUE EOF ) + // InternalBehaviorAnnexParser.g:2587:1: ruleINTVALUE EOF { if ( state.backtracking==0 ) { before(grammarAccess.getINTVALUERule()); @@ -8106,17 +8527,17 @@ public final void entryRuleINTVALUE() throws RecognitionException { // $ANTLR start "ruleINTVALUE" - // InternalBehaviorAnnexParser.g:2469:1: ruleINTVALUE : ( RULE_INTEGER_LIT ) ; + // InternalBehaviorAnnexParser.g:2594:1: ruleINTVALUE : ( RULE_INTEGER_LIT ) ; public final void ruleINTVALUE() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2473:2: ( ( RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:2474:2: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:2598:2: ( ( RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:2599:2: ( RULE_INTEGER_LIT ) { - // InternalBehaviorAnnexParser.g:2474:2: ( RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:2475:3: RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:2599:2: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:2600:3: RULE_INTEGER_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getINTVALUEAccess().getINTEGER_LITTerminalRuleCall()); @@ -8147,11 +8568,11 @@ public final void ruleINTVALUE() throws RecognitionException { // $ANTLR start "entryRuleQPREF" - // InternalBehaviorAnnexParser.g:2485:1: entryRuleQPREF : ruleQPREF EOF ; + // InternalBehaviorAnnexParser.g:2610:1: entryRuleQPREF : ruleQPREF EOF ; public final void entryRuleQPREF() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2486:1: ( ruleQPREF EOF ) - // InternalBehaviorAnnexParser.g:2487:1: ruleQPREF EOF + // InternalBehaviorAnnexParser.g:2611:1: ( ruleQPREF EOF ) + // InternalBehaviorAnnexParser.g:2612:1: ruleQPREF EOF { if ( state.backtracking==0 ) { before(grammarAccess.getQPREFRule()); @@ -8181,23 +8602,23 @@ public final void entryRuleQPREF() throws RecognitionException { // $ANTLR start "ruleQPREF" - // InternalBehaviorAnnexParser.g:2494:1: ruleQPREF : ( ( rule__QPREF__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2619:1: ruleQPREF : ( ( rule__QPREF__Group__0 ) ) ; public final void ruleQPREF() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2498:2: ( ( ( rule__QPREF__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2499:2: ( ( rule__QPREF__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2623:2: ( ( ( rule__QPREF__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2624:2: ( ( rule__QPREF__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2499:2: ( ( rule__QPREF__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2500:3: ( rule__QPREF__Group__0 ) + // InternalBehaviorAnnexParser.g:2624:2: ( ( rule__QPREF__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2625:3: ( rule__QPREF__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getQPREFAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2501:3: ( rule__QPREF__Group__0 ) - // InternalBehaviorAnnexParser.g:2501:4: rule__QPREF__Group__0 + // InternalBehaviorAnnexParser.g:2626:3: ( rule__QPREF__Group__0 ) + // InternalBehaviorAnnexParser.g:2626:4: rule__QPREF__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__QPREF__Group__0(); @@ -8232,11 +8653,11 @@ public final void ruleQPREF() throws RecognitionException { // $ANTLR start "entryRuleQCREF" - // InternalBehaviorAnnexParser.g:2510:1: entryRuleQCREF : ruleQCREF EOF ; + // InternalBehaviorAnnexParser.g:2635:1: entryRuleQCREF : ruleQCREF EOF ; public final void entryRuleQCREF() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2511:1: ( ruleQCREF EOF ) - // InternalBehaviorAnnexParser.g:2512:1: ruleQCREF EOF + // InternalBehaviorAnnexParser.g:2636:1: ( ruleQCREF EOF ) + // InternalBehaviorAnnexParser.g:2637:1: ruleQCREF EOF { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFRule()); @@ -8266,23 +8687,23 @@ public final void entryRuleQCREF() throws RecognitionException { // $ANTLR start "ruleQCREF" - // InternalBehaviorAnnexParser.g:2519:1: ruleQCREF : ( ( rule__QCREF__Group__0 ) ) ; + // InternalBehaviorAnnexParser.g:2644:1: ruleQCREF : ( ( rule__QCREF__Group__0 ) ) ; public final void ruleQCREF() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2523:2: ( ( ( rule__QCREF__Group__0 ) ) ) - // InternalBehaviorAnnexParser.g:2524:2: ( ( rule__QCREF__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2648:2: ( ( ( rule__QCREF__Group__0 ) ) ) + // InternalBehaviorAnnexParser.g:2649:2: ( ( rule__QCREF__Group__0 ) ) { - // InternalBehaviorAnnexParser.g:2524:2: ( ( rule__QCREF__Group__0 ) ) - // InternalBehaviorAnnexParser.g:2525:3: ( rule__QCREF__Group__0 ) + // InternalBehaviorAnnexParser.g:2649:2: ( ( rule__QCREF__Group__0 ) ) + // InternalBehaviorAnnexParser.g:2650:3: ( rule__QCREF__Group__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getGroup()); } - // InternalBehaviorAnnexParser.g:2526:3: ( rule__QCREF__Group__0 ) - // InternalBehaviorAnnexParser.g:2526:4: rule__QCREF__Group__0 + // InternalBehaviorAnnexParser.g:2651:3: ( rule__QCREF__Group__0 ) + // InternalBehaviorAnnexParser.g:2651:4: rule__QCREF__Group__0 { pushFollow(FollowSets000.FOLLOW_2); rule__QCREF__Group__0(); @@ -8317,11 +8738,11 @@ public final void ruleQCREF() throws RecognitionException { // $ANTLR start "entryRuleSTAR" - // InternalBehaviorAnnexParser.g:2535:1: entryRuleSTAR : ruleSTAR EOF ; + // InternalBehaviorAnnexParser.g:2660:1: entryRuleSTAR : ruleSTAR EOF ; public final void entryRuleSTAR() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:2536:1: ( ruleSTAR EOF ) - // InternalBehaviorAnnexParser.g:2537:1: ruleSTAR EOF + // InternalBehaviorAnnexParser.g:2661:1: ( ruleSTAR EOF ) + // InternalBehaviorAnnexParser.g:2662:1: ruleSTAR EOF { if ( state.backtracking==0 ) { before(grammarAccess.getSTARRule()); @@ -8351,17 +8772,17 @@ public final void entryRuleSTAR() throws RecognitionException { // $ANTLR start "ruleSTAR" - // InternalBehaviorAnnexParser.g:2544:1: ruleSTAR : ( Asterisk ) ; + // InternalBehaviorAnnexParser.g:2669:1: ruleSTAR : ( Asterisk ) ; public final void ruleSTAR() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2548:2: ( ( Asterisk ) ) - // InternalBehaviorAnnexParser.g:2549:2: ( Asterisk ) + // InternalBehaviorAnnexParser.g:2673:2: ( ( Asterisk ) ) + // InternalBehaviorAnnexParser.g:2674:2: ( Asterisk ) { - // InternalBehaviorAnnexParser.g:2549:2: ( Asterisk ) - // InternalBehaviorAnnexParser.g:2550:3: Asterisk + // InternalBehaviorAnnexParser.g:2674:2: ( Asterisk ) + // InternalBehaviorAnnexParser.g:2675:3: Asterisk { if ( state.backtracking==0 ) { before(grammarAccess.getSTARAccess().getAsteriskKeyword()); @@ -8392,13 +8813,13 @@ public final void ruleSTAR() throws RecognitionException { // $ANTLR start "rule__BehaviorCondition__Alternatives" - // InternalBehaviorAnnexParser.g:2559:1: rule__BehaviorCondition__Alternatives : ( ( ( rule__BehaviorCondition__Group_0__0 ) ) | ( ( rule__BehaviorCondition__ExecuteAssignment_1 ) ) ); + // InternalBehaviorAnnexParser.g:2684:1: rule__BehaviorCondition__Alternatives : ( ( ( rule__BehaviorCondition__Group_0__0 ) ) | ( ( rule__BehaviorCondition__ExecuteAssignment_1 ) ) ); public final void rule__BehaviorCondition__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2563:1: ( ( ( rule__BehaviorCondition__Group_0__0 ) ) | ( ( rule__BehaviorCondition__ExecuteAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:2688:1: ( ( ( rule__BehaviorCondition__Group_0__0 ) ) | ( ( rule__BehaviorCondition__ExecuteAssignment_1 ) ) ) int alt1=2; int LA1_0 = input.LA(1); @@ -8417,16 +8838,16 @@ else if ( (LA1_0==Otherwise||LA1_0==Timeout||LA1_0==False||LA1_0==True||LA1_0==A } switch (alt1) { case 1 : - // InternalBehaviorAnnexParser.g:2564:2: ( ( rule__BehaviorCondition__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:2689:2: ( ( rule__BehaviorCondition__Group_0__0 ) ) { - // InternalBehaviorAnnexParser.g:2564:2: ( ( rule__BehaviorCondition__Group_0__0 ) ) - // InternalBehaviorAnnexParser.g:2565:3: ( rule__BehaviorCondition__Group_0__0 ) + // InternalBehaviorAnnexParser.g:2689:2: ( ( rule__BehaviorCondition__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:2690:3: ( rule__BehaviorCondition__Group_0__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getGroup_0()); } - // InternalBehaviorAnnexParser.g:2566:3: ( rule__BehaviorCondition__Group_0__0 ) - // InternalBehaviorAnnexParser.g:2566:4: rule__BehaviorCondition__Group_0__0 + // InternalBehaviorAnnexParser.g:2691:3: ( rule__BehaviorCondition__Group_0__0 ) + // InternalBehaviorAnnexParser.g:2691:4: rule__BehaviorCondition__Group_0__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorCondition__Group_0__0(); @@ -8446,16 +8867,16 @@ else if ( (LA1_0==Otherwise||LA1_0==Timeout||LA1_0==False||LA1_0==True||LA1_0==A } break; case 2 : - // InternalBehaviorAnnexParser.g:2570:2: ( ( rule__BehaviorCondition__ExecuteAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:2695:2: ( ( rule__BehaviorCondition__ExecuteAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:2570:2: ( ( rule__BehaviorCondition__ExecuteAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:2571:3: ( rule__BehaviorCondition__ExecuteAssignment_1 ) + // InternalBehaviorAnnexParser.g:2695:2: ( ( rule__BehaviorCondition__ExecuteAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:2696:3: ( rule__BehaviorCondition__ExecuteAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getExecuteAssignment_1()); } - // InternalBehaviorAnnexParser.g:2572:3: ( rule__BehaviorCondition__ExecuteAssignment_1 ) - // InternalBehaviorAnnexParser.g:2572:4: rule__BehaviorCondition__ExecuteAssignment_1 + // InternalBehaviorAnnexParser.g:2697:3: ( rule__BehaviorCondition__ExecuteAssignment_1 ) + // InternalBehaviorAnnexParser.g:2697:4: rule__BehaviorCondition__ExecuteAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorCondition__ExecuteAssignment_1(); @@ -8492,13 +8913,13 @@ else if ( (LA1_0==Otherwise||LA1_0==Timeout||LA1_0==False||LA1_0==True||LA1_0==A // $ANTLR start "rule__BehaviorCondition__Alternatives_0_1" - // InternalBehaviorAnnexParser.g:2580:1: rule__BehaviorCondition__Alternatives_0_1 : ( ( ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) ) | ( ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) ) | ( ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) ) ); + // InternalBehaviorAnnexParser.g:2705:1: rule__BehaviorCondition__Alternatives_0_1 : ( ( ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) ) | ( ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) ) | ( ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) ) ); public final void rule__BehaviorCondition__Alternatives_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2584:1: ( ( ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) ) | ( ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) ) | ( ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:2709:1: ( ( ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) ) | ( ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) ) | ( ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) ) ) int alt2=3; switch ( input.LA(1) ) { case Dispatch: @@ -8527,16 +8948,16 @@ public final void rule__BehaviorCondition__Alternatives_0_1() throws Recognition switch (alt2) { case 1 : - // InternalBehaviorAnnexParser.g:2585:2: ( ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) ) + // InternalBehaviorAnnexParser.g:2710:2: ( ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) ) { - // InternalBehaviorAnnexParser.g:2585:2: ( ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) ) - // InternalBehaviorAnnexParser.g:2586:3: ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) + // InternalBehaviorAnnexParser.g:2710:2: ( ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) ) + // InternalBehaviorAnnexParser.g:2711:3: ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getDispatchAssignment_0_1_0()); } - // InternalBehaviorAnnexParser.g:2587:3: ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) - // InternalBehaviorAnnexParser.g:2587:4: rule__BehaviorCondition__DispatchAssignment_0_1_0 + // InternalBehaviorAnnexParser.g:2712:3: ( rule__BehaviorCondition__DispatchAssignment_0_1_0 ) + // InternalBehaviorAnnexParser.g:2712:4: rule__BehaviorCondition__DispatchAssignment_0_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorCondition__DispatchAssignment_0_1_0(); @@ -8556,16 +8977,16 @@ public final void rule__BehaviorCondition__Alternatives_0_1() throws Recognition } break; case 2 : - // InternalBehaviorAnnexParser.g:2591:2: ( ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) ) + // InternalBehaviorAnnexParser.g:2716:2: ( ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) ) { - // InternalBehaviorAnnexParser.g:2591:2: ( ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) ) - // InternalBehaviorAnnexParser.g:2592:3: ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) + // InternalBehaviorAnnexParser.g:2716:2: ( ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) ) + // InternalBehaviorAnnexParser.g:2717:3: ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getInternalAssignment_0_1_1()); } - // InternalBehaviorAnnexParser.g:2593:3: ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) - // InternalBehaviorAnnexParser.g:2593:4: rule__BehaviorCondition__InternalAssignment_0_1_1 + // InternalBehaviorAnnexParser.g:2718:3: ( rule__BehaviorCondition__InternalAssignment_0_1_1 ) + // InternalBehaviorAnnexParser.g:2718:4: rule__BehaviorCondition__InternalAssignment_0_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorCondition__InternalAssignment_0_1_1(); @@ -8585,16 +9006,16 @@ public final void rule__BehaviorCondition__Alternatives_0_1() throws Recognition } break; case 3 : - // InternalBehaviorAnnexParser.g:2597:2: ( ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) ) + // InternalBehaviorAnnexParser.g:2722:2: ( ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) ) { - // InternalBehaviorAnnexParser.g:2597:2: ( ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) ) - // InternalBehaviorAnnexParser.g:2598:3: ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) + // InternalBehaviorAnnexParser.g:2722:2: ( ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) ) + // InternalBehaviorAnnexParser.g:2723:3: ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getModeSwitchAssignment_0_1_2()); } - // InternalBehaviorAnnexParser.g:2599:3: ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) - // InternalBehaviorAnnexParser.g:2599:4: rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 + // InternalBehaviorAnnexParser.g:2724:3: ( rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 ) + // InternalBehaviorAnnexParser.g:2724:4: rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorCondition__ModeSwitchAssignment_0_1_2(); @@ -8631,13 +9052,13 @@ public final void rule__BehaviorCondition__Alternatives_0_1() throws Recognition // $ANTLR start "rule__ExecuteCondition__Alternatives" - // InternalBehaviorAnnexParser.g:2607:1: rule__ExecuteCondition__Alternatives : ( ( ( rule__ExecuteCondition__ValueAssignment_0 ) ) | ( ( rule__ExecuteCondition__TimeoutAssignment_1 ) ) | ( ( rule__ExecuteCondition__OtherwiseAssignment_2 ) ) ); + // InternalBehaviorAnnexParser.g:2732:1: rule__ExecuteCondition__Alternatives : ( ( ( rule__ExecuteCondition__ValueAssignment_0 ) ) | ( ( rule__ExecuteCondition__TimeoutAssignment_1 ) ) | ( ( rule__ExecuteCondition__OtherwiseAssignment_2 ) ) ); public final void rule__ExecuteCondition__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2611:1: ( ( ( rule__ExecuteCondition__ValueAssignment_0 ) ) | ( ( rule__ExecuteCondition__TimeoutAssignment_1 ) ) | ( ( rule__ExecuteCondition__OtherwiseAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:2736:1: ( ( ( rule__ExecuteCondition__ValueAssignment_0 ) ) | ( ( rule__ExecuteCondition__TimeoutAssignment_1 ) ) | ( ( rule__ExecuteCondition__OtherwiseAssignment_2 ) ) ) int alt3=3; switch ( input.LA(1) ) { case False: @@ -8676,16 +9097,16 @@ public final void rule__ExecuteCondition__Alternatives() throws RecognitionExcep switch (alt3) { case 1 : - // InternalBehaviorAnnexParser.g:2612:2: ( ( rule__ExecuteCondition__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:2737:2: ( ( rule__ExecuteCondition__ValueAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:2612:2: ( ( rule__ExecuteCondition__ValueAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:2613:3: ( rule__ExecuteCondition__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:2737:2: ( ( rule__ExecuteCondition__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:2738:3: ( rule__ExecuteCondition__ValueAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getValueAssignment_0()); } - // InternalBehaviorAnnexParser.g:2614:3: ( rule__ExecuteCondition__ValueAssignment_0 ) - // InternalBehaviorAnnexParser.g:2614:4: rule__ExecuteCondition__ValueAssignment_0 + // InternalBehaviorAnnexParser.g:2739:3: ( rule__ExecuteCondition__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:2739:4: rule__ExecuteCondition__ValueAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ExecuteCondition__ValueAssignment_0(); @@ -8705,16 +9126,16 @@ public final void rule__ExecuteCondition__Alternatives() throws RecognitionExcep } break; case 2 : - // InternalBehaviorAnnexParser.g:2618:2: ( ( rule__ExecuteCondition__TimeoutAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:2743:2: ( ( rule__ExecuteCondition__TimeoutAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:2618:2: ( ( rule__ExecuteCondition__TimeoutAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:2619:3: ( rule__ExecuteCondition__TimeoutAssignment_1 ) + // InternalBehaviorAnnexParser.g:2743:2: ( ( rule__ExecuteCondition__TimeoutAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:2744:3: ( rule__ExecuteCondition__TimeoutAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getTimeoutAssignment_1()); } - // InternalBehaviorAnnexParser.g:2620:3: ( rule__ExecuteCondition__TimeoutAssignment_1 ) - // InternalBehaviorAnnexParser.g:2620:4: rule__ExecuteCondition__TimeoutAssignment_1 + // InternalBehaviorAnnexParser.g:2745:3: ( rule__ExecuteCondition__TimeoutAssignment_1 ) + // InternalBehaviorAnnexParser.g:2745:4: rule__ExecuteCondition__TimeoutAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ExecuteCondition__TimeoutAssignment_1(); @@ -8734,16 +9155,16 @@ public final void rule__ExecuteCondition__Alternatives() throws RecognitionExcep } break; case 3 : - // InternalBehaviorAnnexParser.g:2624:2: ( ( rule__ExecuteCondition__OtherwiseAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:2749:2: ( ( rule__ExecuteCondition__OtherwiseAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:2624:2: ( ( rule__ExecuteCondition__OtherwiseAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:2625:3: ( rule__ExecuteCondition__OtherwiseAssignment_2 ) + // InternalBehaviorAnnexParser.g:2749:2: ( ( rule__ExecuteCondition__OtherwiseAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:2750:3: ( rule__ExecuteCondition__OtherwiseAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getOtherwiseAssignment_2()); } - // InternalBehaviorAnnexParser.g:2626:3: ( rule__ExecuteCondition__OtherwiseAssignment_2 ) - // InternalBehaviorAnnexParser.g:2626:4: rule__ExecuteCondition__OtherwiseAssignment_2 + // InternalBehaviorAnnexParser.g:2751:3: ( rule__ExecuteCondition__OtherwiseAssignment_2 ) + // InternalBehaviorAnnexParser.g:2751:4: rule__ExecuteCondition__OtherwiseAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ExecuteCondition__OtherwiseAssignment_2(); @@ -8780,13 +9201,13 @@ public final void rule__ExecuteCondition__Alternatives() throws RecognitionExcep // $ANTLR start "rule__DispatchTriggerCondition__Alternatives" - // InternalBehaviorAnnexParser.g:2634:1: rule__DispatchTriggerCondition__Alternatives : ( ( ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) ) | ( ( rule__DispatchTriggerCondition__Group_1__0 ) ) | ( ( rule__DispatchTriggerCondition__StopAssignment_2 ) ) ); + // InternalBehaviorAnnexParser.g:2759:1: rule__DispatchTriggerCondition__Alternatives : ( ( ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) ) | ( ( rule__DispatchTriggerCondition__Group_1__0 ) ) | ( ( rule__DispatchTriggerCondition__StopAssignment_2 ) ) ); public final void rule__DispatchTriggerCondition__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2638:1: ( ( ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) ) | ( ( rule__DispatchTriggerCondition__Group_1__0 ) ) | ( ( rule__DispatchTriggerCondition__StopAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:2763:1: ( ( ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) ) | ( ( rule__DispatchTriggerCondition__Group_1__0 ) ) | ( ( rule__DispatchTriggerCondition__StopAssignment_2 ) ) ) int alt4=3; switch ( input.LA(1) ) { case RULE_ID: @@ -8814,16 +9235,16 @@ public final void rule__DispatchTriggerCondition__Alternatives() throws Recognit switch (alt4) { case 1 : - // InternalBehaviorAnnexParser.g:2639:2: ( ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:2764:2: ( ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:2639:2: ( ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:2640:3: ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) + // InternalBehaviorAnnexParser.g:2764:2: ( ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:2765:3: ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getExpressionAssignment_0()); } - // InternalBehaviorAnnexParser.g:2641:3: ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) - // InternalBehaviorAnnexParser.g:2641:4: rule__DispatchTriggerCondition__ExpressionAssignment_0 + // InternalBehaviorAnnexParser.g:2766:3: ( rule__DispatchTriggerCondition__ExpressionAssignment_0 ) + // InternalBehaviorAnnexParser.g:2766:4: rule__DispatchTriggerCondition__ExpressionAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__ExpressionAssignment_0(); @@ -8843,16 +9264,16 @@ public final void rule__DispatchTriggerCondition__Alternatives() throws Recognit } break; case 2 : - // InternalBehaviorAnnexParser.g:2645:2: ( ( rule__DispatchTriggerCondition__Group_1__0 ) ) + // InternalBehaviorAnnexParser.g:2770:2: ( ( rule__DispatchTriggerCondition__Group_1__0 ) ) { - // InternalBehaviorAnnexParser.g:2645:2: ( ( rule__DispatchTriggerCondition__Group_1__0 ) ) - // InternalBehaviorAnnexParser.g:2646:3: ( rule__DispatchTriggerCondition__Group_1__0 ) + // InternalBehaviorAnnexParser.g:2770:2: ( ( rule__DispatchTriggerCondition__Group_1__0 ) ) + // InternalBehaviorAnnexParser.g:2771:3: ( rule__DispatchTriggerCondition__Group_1__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:2647:3: ( rule__DispatchTriggerCondition__Group_1__0 ) - // InternalBehaviorAnnexParser.g:2647:4: rule__DispatchTriggerCondition__Group_1__0 + // InternalBehaviorAnnexParser.g:2772:3: ( rule__DispatchTriggerCondition__Group_1__0 ) + // InternalBehaviorAnnexParser.g:2772:4: rule__DispatchTriggerCondition__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__Group_1__0(); @@ -8872,16 +9293,16 @@ public final void rule__DispatchTriggerCondition__Alternatives() throws Recognit } break; case 3 : - // InternalBehaviorAnnexParser.g:2651:2: ( ( rule__DispatchTriggerCondition__StopAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:2776:2: ( ( rule__DispatchTriggerCondition__StopAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:2651:2: ( ( rule__DispatchTriggerCondition__StopAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:2652:3: ( rule__DispatchTriggerCondition__StopAssignment_2 ) + // InternalBehaviorAnnexParser.g:2776:2: ( ( rule__DispatchTriggerCondition__StopAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:2777:3: ( rule__DispatchTriggerCondition__StopAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getStopAssignment_2()); } - // InternalBehaviorAnnexParser.g:2653:3: ( rule__DispatchTriggerCondition__StopAssignment_2 ) - // InternalBehaviorAnnexParser.g:2653:4: rule__DispatchTriggerCondition__StopAssignment_2 + // InternalBehaviorAnnexParser.g:2778:3: ( rule__DispatchTriggerCondition__StopAssignment_2 ) + // InternalBehaviorAnnexParser.g:2778:4: rule__DispatchTriggerCondition__StopAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__StopAssignment_2(); @@ -8918,13 +9339,13 @@ public final void rule__DispatchTriggerCondition__Alternatives() throws Recognit // $ANTLR start "rule__ModeSwitchTrigger__Alternatives" - // InternalBehaviorAnnexParser.g:2661:1: rule__ModeSwitchTrigger__Alternatives : ( ( ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) ) | ( ( rule__ModeSwitchTrigger__Group_1__0 ) ) ); + // InternalBehaviorAnnexParser.g:2786:1: rule__ModeSwitchTrigger__Alternatives : ( ( ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) ) | ( ( rule__ModeSwitchTrigger__Group_1__0 ) ) ); public final void rule__ModeSwitchTrigger__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2665:1: ( ( ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) ) | ( ( rule__ModeSwitchTrigger__Group_1__0 ) ) ) + // InternalBehaviorAnnexParser.g:2790:1: ( ( ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) ) | ( ( rule__ModeSwitchTrigger__Group_1__0 ) ) ) int alt5=2; int LA5_0 = input.LA(1); @@ -8943,16 +9364,16 @@ else if ( (LA5_0==LeftParenthesis) ) { } switch (alt5) { case 1 : - // InternalBehaviorAnnexParser.g:2666:2: ( ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:2791:2: ( ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:2666:2: ( ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:2667:3: ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) + // InternalBehaviorAnnexParser.g:2791:2: ( ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:2792:3: ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchTriggerAccess().getReferenceAssignment_0()); } - // InternalBehaviorAnnexParser.g:2668:3: ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) - // InternalBehaviorAnnexParser.g:2668:4: rule__ModeSwitchTrigger__ReferenceAssignment_0 + // InternalBehaviorAnnexParser.g:2793:3: ( rule__ModeSwitchTrigger__ReferenceAssignment_0 ) + // InternalBehaviorAnnexParser.g:2793:4: rule__ModeSwitchTrigger__ReferenceAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchTrigger__ReferenceAssignment_0(); @@ -8972,16 +9393,16 @@ else if ( (LA5_0==LeftParenthesis) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:2672:2: ( ( rule__ModeSwitchTrigger__Group_1__0 ) ) + // InternalBehaviorAnnexParser.g:2797:2: ( ( rule__ModeSwitchTrigger__Group_1__0 ) ) { - // InternalBehaviorAnnexParser.g:2672:2: ( ( rule__ModeSwitchTrigger__Group_1__0 ) ) - // InternalBehaviorAnnexParser.g:2673:3: ( rule__ModeSwitchTrigger__Group_1__0 ) + // InternalBehaviorAnnexParser.g:2797:2: ( ( rule__ModeSwitchTrigger__Group_1__0 ) ) + // InternalBehaviorAnnexParser.g:2798:3: ( rule__ModeSwitchTrigger__Group_1__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchTriggerAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:2674:3: ( rule__ModeSwitchTrigger__Group_1__0 ) - // InternalBehaviorAnnexParser.g:2674:4: rule__ModeSwitchTrigger__Group_1__0 + // InternalBehaviorAnnexParser.g:2799:3: ( rule__ModeSwitchTrigger__Group_1__0 ) + // InternalBehaviorAnnexParser.g:2799:4: rule__ModeSwitchTrigger__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchTrigger__Group_1__0(); @@ -9018,13 +9439,13 @@ else if ( (LA5_0==LeftParenthesis) ) { // $ANTLR start "rule__BehaviorActions__Alternatives_1" - // InternalBehaviorAnnexParser.g:2682:1: rule__BehaviorActions__Alternatives_1 : ( ( ( rule__BehaviorActions__Group_1_0__0 ) ) | ( ( rule__BehaviorActions__Group_1_1__0 ) ) ); + // InternalBehaviorAnnexParser.g:2807:1: rule__BehaviorActions__Alternatives_1 : ( ( ( rule__BehaviorActions__Group_1_0__0 ) ) | ( ( rule__BehaviorActions__Group_1_1__0 ) ) ); public final void rule__BehaviorActions__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2686:1: ( ( ( rule__BehaviorActions__Group_1_0__0 ) ) | ( ( rule__BehaviorActions__Group_1_1__0 ) ) ) + // InternalBehaviorAnnexParser.g:2811:1: ( ( ( rule__BehaviorActions__Group_1_0__0 ) ) | ( ( rule__BehaviorActions__Group_1_1__0 ) ) ) int alt6=2; int LA6_0 = input.LA(1); @@ -9043,16 +9464,16 @@ else if ( (LA6_0==Ampersand) ) { } switch (alt6) { case 1 : - // InternalBehaviorAnnexParser.g:2687:2: ( ( rule__BehaviorActions__Group_1_0__0 ) ) + // InternalBehaviorAnnexParser.g:2812:2: ( ( rule__BehaviorActions__Group_1_0__0 ) ) { - // InternalBehaviorAnnexParser.g:2687:2: ( ( rule__BehaviorActions__Group_1_0__0 ) ) - // InternalBehaviorAnnexParser.g:2688:3: ( rule__BehaviorActions__Group_1_0__0 ) + // InternalBehaviorAnnexParser.g:2812:2: ( ( rule__BehaviorActions__Group_1_0__0 ) ) + // InternalBehaviorAnnexParser.g:2813:3: ( rule__BehaviorActions__Group_1_0__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getGroup_1_0()); } - // InternalBehaviorAnnexParser.g:2689:3: ( rule__BehaviorActions__Group_1_0__0 ) - // InternalBehaviorAnnexParser.g:2689:4: rule__BehaviorActions__Group_1_0__0 + // InternalBehaviorAnnexParser.g:2814:3: ( rule__BehaviorActions__Group_1_0__0 ) + // InternalBehaviorAnnexParser.g:2814:4: rule__BehaviorActions__Group_1_0__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__Group_1_0__0(); @@ -9072,16 +9493,16 @@ else if ( (LA6_0==Ampersand) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:2693:2: ( ( rule__BehaviorActions__Group_1_1__0 ) ) + // InternalBehaviorAnnexParser.g:2818:2: ( ( rule__BehaviorActions__Group_1_1__0 ) ) { - // InternalBehaviorAnnexParser.g:2693:2: ( ( rule__BehaviorActions__Group_1_1__0 ) ) - // InternalBehaviorAnnexParser.g:2694:3: ( rule__BehaviorActions__Group_1_1__0 ) + // InternalBehaviorAnnexParser.g:2818:2: ( ( rule__BehaviorActions__Group_1_1__0 ) ) + // InternalBehaviorAnnexParser.g:2819:3: ( rule__BehaviorActions__Group_1_1__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getGroup_1_1()); } - // InternalBehaviorAnnexParser.g:2695:3: ( rule__BehaviorActions__Group_1_1__0 ) - // InternalBehaviorAnnexParser.g:2695:4: rule__BehaviorActions__Group_1_1__0 + // InternalBehaviorAnnexParser.g:2820:3: ( rule__BehaviorActions__Group_1_1__0 ) + // InternalBehaviorAnnexParser.g:2820:4: rule__BehaviorActions__Group_1_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__Group_1_1__0(); @@ -9118,27 +9539,27 @@ else if ( (LA6_0==Ampersand) ) { // $ANTLR start "rule__BehaviorAction__Alternatives" - // InternalBehaviorAnnexParser.g:2703:1: rule__BehaviorAction__Alternatives : ( ( ( ruleAssignmentAction ) ) | ( ruleCommunicationAction ) | ( ruleTimedAction ) | ( ruleIfStatement ) | ( ruleForStatement ) | ( ruleWhileStatement ) | ( ruleDoUntilStatement ) | ( ruleBehaviorActionBlock ) ); + // InternalBehaviorAnnexParser.g:2828:1: rule__BehaviorAction__Alternatives : ( ( ( ruleAssignmentAction ) ) | ( ruleCommunicationAction ) | ( ruleTimedAction ) | ( ruleIfStatement ) | ( ruleForStatement ) | ( ruleWhileStatement ) | ( ruleDoUntilStatement ) | ( ruleBehaviorActionBlock ) ); public final void rule__BehaviorAction__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2707:1: ( ( ( ruleAssignmentAction ) ) | ( ruleCommunicationAction ) | ( ruleTimedAction ) | ( ruleIfStatement ) | ( ruleForStatement ) | ( ruleWhileStatement ) | ( ruleDoUntilStatement ) | ( ruleBehaviorActionBlock ) ) + // InternalBehaviorAnnexParser.g:2832:1: ( ( ( ruleAssignmentAction ) ) | ( ruleCommunicationAction ) | ( ruleTimedAction ) | ( ruleIfStatement ) | ( ruleForStatement ) | ( ruleWhileStatement ) | ( ruleDoUntilStatement ) | ( ruleBehaviorActionBlock ) ) int alt7=8; alt7 = dfa7.predict(input); switch (alt7) { case 1 : - // InternalBehaviorAnnexParser.g:2708:2: ( ( ruleAssignmentAction ) ) + // InternalBehaviorAnnexParser.g:2833:2: ( ( ruleAssignmentAction ) ) { - // InternalBehaviorAnnexParser.g:2708:2: ( ( ruleAssignmentAction ) ) - // InternalBehaviorAnnexParser.g:2709:3: ( ruleAssignmentAction ) + // InternalBehaviorAnnexParser.g:2833:2: ( ( ruleAssignmentAction ) ) + // InternalBehaviorAnnexParser.g:2834:3: ( ruleAssignmentAction ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionAccess().getAssignmentActionParserRuleCall_0()); } - // InternalBehaviorAnnexParser.g:2710:3: ( ruleAssignmentAction ) - // InternalBehaviorAnnexParser.g:2710:4: ruleAssignmentAction + // InternalBehaviorAnnexParser.g:2835:3: ( ruleAssignmentAction ) + // InternalBehaviorAnnexParser.g:2835:4: ruleAssignmentAction { pushFollow(FollowSets000.FOLLOW_2); ruleAssignmentAction(); @@ -9158,10 +9579,10 @@ public final void rule__BehaviorAction__Alternatives() throws RecognitionExcepti } break; case 2 : - // InternalBehaviorAnnexParser.g:2714:2: ( ruleCommunicationAction ) + // InternalBehaviorAnnexParser.g:2839:2: ( ruleCommunicationAction ) { - // InternalBehaviorAnnexParser.g:2714:2: ( ruleCommunicationAction ) - // InternalBehaviorAnnexParser.g:2715:3: ruleCommunicationAction + // InternalBehaviorAnnexParser.g:2839:2: ( ruleCommunicationAction ) + // InternalBehaviorAnnexParser.g:2840:3: ruleCommunicationAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionAccess().getCommunicationActionParserRuleCall_1()); @@ -9181,10 +9602,10 @@ public final void rule__BehaviorAction__Alternatives() throws RecognitionExcepti } break; case 3 : - // InternalBehaviorAnnexParser.g:2720:2: ( ruleTimedAction ) + // InternalBehaviorAnnexParser.g:2845:2: ( ruleTimedAction ) { - // InternalBehaviorAnnexParser.g:2720:2: ( ruleTimedAction ) - // InternalBehaviorAnnexParser.g:2721:3: ruleTimedAction + // InternalBehaviorAnnexParser.g:2845:2: ( ruleTimedAction ) + // InternalBehaviorAnnexParser.g:2846:3: ruleTimedAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionAccess().getTimedActionParserRuleCall_2()); @@ -9204,10 +9625,10 @@ public final void rule__BehaviorAction__Alternatives() throws RecognitionExcepti } break; case 4 : - // InternalBehaviorAnnexParser.g:2726:2: ( ruleIfStatement ) + // InternalBehaviorAnnexParser.g:2851:2: ( ruleIfStatement ) { - // InternalBehaviorAnnexParser.g:2726:2: ( ruleIfStatement ) - // InternalBehaviorAnnexParser.g:2727:3: ruleIfStatement + // InternalBehaviorAnnexParser.g:2851:2: ( ruleIfStatement ) + // InternalBehaviorAnnexParser.g:2852:3: ruleIfStatement { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionAccess().getIfStatementParserRuleCall_3()); @@ -9227,10 +9648,10 @@ public final void rule__BehaviorAction__Alternatives() throws RecognitionExcepti } break; case 5 : - // InternalBehaviorAnnexParser.g:2732:2: ( ruleForStatement ) + // InternalBehaviorAnnexParser.g:2857:2: ( ruleForStatement ) { - // InternalBehaviorAnnexParser.g:2732:2: ( ruleForStatement ) - // InternalBehaviorAnnexParser.g:2733:3: ruleForStatement + // InternalBehaviorAnnexParser.g:2857:2: ( ruleForStatement ) + // InternalBehaviorAnnexParser.g:2858:3: ruleForStatement { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionAccess().getForStatementParserRuleCall_4()); @@ -9250,10 +9671,10 @@ public final void rule__BehaviorAction__Alternatives() throws RecognitionExcepti } break; case 6 : - // InternalBehaviorAnnexParser.g:2738:2: ( ruleWhileStatement ) + // InternalBehaviorAnnexParser.g:2863:2: ( ruleWhileStatement ) { - // InternalBehaviorAnnexParser.g:2738:2: ( ruleWhileStatement ) - // InternalBehaviorAnnexParser.g:2739:3: ruleWhileStatement + // InternalBehaviorAnnexParser.g:2863:2: ( ruleWhileStatement ) + // InternalBehaviorAnnexParser.g:2864:3: ruleWhileStatement { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionAccess().getWhileStatementParserRuleCall_5()); @@ -9273,10 +9694,10 @@ public final void rule__BehaviorAction__Alternatives() throws RecognitionExcepti } break; case 7 : - // InternalBehaviorAnnexParser.g:2744:2: ( ruleDoUntilStatement ) + // InternalBehaviorAnnexParser.g:2869:2: ( ruleDoUntilStatement ) { - // InternalBehaviorAnnexParser.g:2744:2: ( ruleDoUntilStatement ) - // InternalBehaviorAnnexParser.g:2745:3: ruleDoUntilStatement + // InternalBehaviorAnnexParser.g:2869:2: ( ruleDoUntilStatement ) + // InternalBehaviorAnnexParser.g:2870:3: ruleDoUntilStatement { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionAccess().getDoUntilStatementParserRuleCall_6()); @@ -9296,10 +9717,10 @@ public final void rule__BehaviorAction__Alternatives() throws RecognitionExcepti } break; case 8 : - // InternalBehaviorAnnexParser.g:2750:2: ( ruleBehaviorActionBlock ) + // InternalBehaviorAnnexParser.g:2875:2: ( ruleBehaviorActionBlock ) { - // InternalBehaviorAnnexParser.g:2750:2: ( ruleBehaviorActionBlock ) - // InternalBehaviorAnnexParser.g:2751:3: ruleBehaviorActionBlock + // InternalBehaviorAnnexParser.g:2875:2: ( ruleBehaviorActionBlock ) + // InternalBehaviorAnnexParser.g:2876:3: ruleBehaviorActionBlock { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionAccess().getBehaviorActionBlockParserRuleCall_7()); @@ -9336,13 +9757,13 @@ public final void rule__BehaviorAction__Alternatives() throws RecognitionExcepti // $ANTLR start "rule__AssignmentAction__Alternatives_2" - // InternalBehaviorAnnexParser.g:2760:1: rule__AssignmentAction__Alternatives_2 : ( ( ( rule__AssignmentAction__ValueAssignment_2_0 ) ) | ( ( rule__AssignmentAction__AnyAssignment_2_1 ) ) ); + // InternalBehaviorAnnexParser.g:2885:1: rule__AssignmentAction__Alternatives_2 : ( ( ( rule__AssignmentAction__ValueAssignment_2_0 ) ) | ( ( rule__AssignmentAction__AnyAssignment_2_1 ) ) ); public final void rule__AssignmentAction__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2764:1: ( ( ( rule__AssignmentAction__ValueAssignment_2_0 ) ) | ( ( rule__AssignmentAction__AnyAssignment_2_1 ) ) ) + // InternalBehaviorAnnexParser.g:2889:1: ( ( ( rule__AssignmentAction__ValueAssignment_2_0 ) ) | ( ( rule__AssignmentAction__AnyAssignment_2_1 ) ) ) int alt8=2; int LA8_0 = input.LA(1); @@ -9361,16 +9782,16 @@ else if ( (LA8_0==Any) ) { } switch (alt8) { case 1 : - // InternalBehaviorAnnexParser.g:2765:2: ( ( rule__AssignmentAction__ValueAssignment_2_0 ) ) + // InternalBehaviorAnnexParser.g:2890:2: ( ( rule__AssignmentAction__ValueAssignment_2_0 ) ) { - // InternalBehaviorAnnexParser.g:2765:2: ( ( rule__AssignmentAction__ValueAssignment_2_0 ) ) - // InternalBehaviorAnnexParser.g:2766:3: ( rule__AssignmentAction__ValueAssignment_2_0 ) + // InternalBehaviorAnnexParser.g:2890:2: ( ( rule__AssignmentAction__ValueAssignment_2_0 ) ) + // InternalBehaviorAnnexParser.g:2891:3: ( rule__AssignmentAction__ValueAssignment_2_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getValueAssignment_2_0()); } - // InternalBehaviorAnnexParser.g:2767:3: ( rule__AssignmentAction__ValueAssignment_2_0 ) - // InternalBehaviorAnnexParser.g:2767:4: rule__AssignmentAction__ValueAssignment_2_0 + // InternalBehaviorAnnexParser.g:2892:3: ( rule__AssignmentAction__ValueAssignment_2_0 ) + // InternalBehaviorAnnexParser.g:2892:4: rule__AssignmentAction__ValueAssignment_2_0 { pushFollow(FollowSets000.FOLLOW_2); rule__AssignmentAction__ValueAssignment_2_0(); @@ -9390,16 +9811,16 @@ else if ( (LA8_0==Any) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:2771:2: ( ( rule__AssignmentAction__AnyAssignment_2_1 ) ) + // InternalBehaviorAnnexParser.g:2896:2: ( ( rule__AssignmentAction__AnyAssignment_2_1 ) ) { - // InternalBehaviorAnnexParser.g:2771:2: ( ( rule__AssignmentAction__AnyAssignment_2_1 ) ) - // InternalBehaviorAnnexParser.g:2772:3: ( rule__AssignmentAction__AnyAssignment_2_1 ) + // InternalBehaviorAnnexParser.g:2896:2: ( ( rule__AssignmentAction__AnyAssignment_2_1 ) ) + // InternalBehaviorAnnexParser.g:2897:3: ( rule__AssignmentAction__AnyAssignment_2_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getAnyAssignment_2_1()); } - // InternalBehaviorAnnexParser.g:2773:3: ( rule__AssignmentAction__AnyAssignment_2_1 ) - // InternalBehaviorAnnexParser.g:2773:4: rule__AssignmentAction__AnyAssignment_2_1 + // InternalBehaviorAnnexParser.g:2898:3: ( rule__AssignmentAction__AnyAssignment_2_1 ) + // InternalBehaviorAnnexParser.g:2898:4: rule__AssignmentAction__AnyAssignment_2_1 { pushFollow(FollowSets000.FOLLOW_2); rule__AssignmentAction__AnyAssignment_2_1(); @@ -9436,13 +9857,13 @@ else if ( (LA8_0==Any) ) { // $ANTLR start "rule__CommunicationAction__Alternatives" - // InternalBehaviorAnnexParser.g:2781:1: rule__CommunicationAction__Alternatives : ( ( ( rule__CommunicationAction__Group_0__0 ) ) | ( ( rule__CommunicationAction__Group_1__0 ) ) ); + // InternalBehaviorAnnexParser.g:2906:1: rule__CommunicationAction__Alternatives : ( ( ( rule__CommunicationAction__Group_0__0 ) ) | ( ( rule__CommunicationAction__Group_1__0 ) ) ); public final void rule__CommunicationAction__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2785:1: ( ( ( rule__CommunicationAction__Group_0__0 ) ) | ( ( rule__CommunicationAction__Group_1__0 ) ) ) + // InternalBehaviorAnnexParser.g:2910:1: ( ( ( rule__CommunicationAction__Group_0__0 ) ) | ( ( rule__CommunicationAction__Group_1__0 ) ) ) int alt9=2; int LA9_0 = input.LA(1); @@ -9461,16 +9882,16 @@ else if ( (LA9_0==Asterisk) ) { } switch (alt9) { case 1 : - // InternalBehaviorAnnexParser.g:2786:2: ( ( rule__CommunicationAction__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:2911:2: ( ( rule__CommunicationAction__Group_0__0 ) ) { - // InternalBehaviorAnnexParser.g:2786:2: ( ( rule__CommunicationAction__Group_0__0 ) ) - // InternalBehaviorAnnexParser.g:2787:3: ( rule__CommunicationAction__Group_0__0 ) + // InternalBehaviorAnnexParser.g:2911:2: ( ( rule__CommunicationAction__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:2912:3: ( rule__CommunicationAction__Group_0__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getGroup_0()); } - // InternalBehaviorAnnexParser.g:2788:3: ( rule__CommunicationAction__Group_0__0 ) - // InternalBehaviorAnnexParser.g:2788:4: rule__CommunicationAction__Group_0__0 + // InternalBehaviorAnnexParser.g:2913:3: ( rule__CommunicationAction__Group_0__0 ) + // InternalBehaviorAnnexParser.g:2913:4: rule__CommunicationAction__Group_0__0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0__0(); @@ -9490,16 +9911,16 @@ else if ( (LA9_0==Asterisk) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:2792:2: ( ( rule__CommunicationAction__Group_1__0 ) ) + // InternalBehaviorAnnexParser.g:2917:2: ( ( rule__CommunicationAction__Group_1__0 ) ) { - // InternalBehaviorAnnexParser.g:2792:2: ( ( rule__CommunicationAction__Group_1__0 ) ) - // InternalBehaviorAnnexParser.g:2793:3: ( rule__CommunicationAction__Group_1__0 ) + // InternalBehaviorAnnexParser.g:2917:2: ( ( rule__CommunicationAction__Group_1__0 ) ) + // InternalBehaviorAnnexParser.g:2918:3: ( rule__CommunicationAction__Group_1__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:2794:3: ( rule__CommunicationAction__Group_1__0 ) - // InternalBehaviorAnnexParser.g:2794:4: rule__CommunicationAction__Group_1__0 + // InternalBehaviorAnnexParser.g:2919:3: ( rule__CommunicationAction__Group_1__0 ) + // InternalBehaviorAnnexParser.g:2919:4: rule__CommunicationAction__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_1__0(); @@ -9536,13 +9957,13 @@ else if ( (LA9_0==Asterisk) ) { // $ANTLR start "rule__CommunicationAction__Alternatives_0_1" - // InternalBehaviorAnnexParser.g:2802:1: rule__CommunicationAction__Alternatives_0_1 : ( ( ( rule__CommunicationAction__Group_0_1_0__0 ) ) | ( ( rule__CommunicationAction__Group_0_1_1__0 ) ) | ( ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) ) | ( ( rule__CommunicationAction__LockAssignment_0_1_3 ) ) | ( ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) ) ); + // InternalBehaviorAnnexParser.g:2927:1: rule__CommunicationAction__Alternatives_0_1 : ( ( ( rule__CommunicationAction__Group_0_1_0__0 ) ) | ( ( rule__CommunicationAction__Group_0_1_1__0 ) ) | ( ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) ) | ( ( rule__CommunicationAction__LockAssignment_0_1_3 ) ) | ( ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) ) ); public final void rule__CommunicationAction__Alternatives_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2806:1: ( ( ( rule__CommunicationAction__Group_0_1_0__0 ) ) | ( ( rule__CommunicationAction__Group_0_1_1__0 ) ) | ( ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) ) | ( ( rule__CommunicationAction__LockAssignment_0_1_3 ) ) | ( ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) ) ) + // InternalBehaviorAnnexParser.g:2931:1: ( ( ( rule__CommunicationAction__Group_0_1_0__0 ) ) | ( ( rule__CommunicationAction__Group_0_1_1__0 ) ) | ( ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) ) | ( ( rule__CommunicationAction__LockAssignment_0_1_3 ) ) | ( ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) ) ) int alt10=5; switch ( input.LA(1) ) { case ExclamationMark: @@ -9580,16 +10001,16 @@ public final void rule__CommunicationAction__Alternatives_0_1() throws Recogniti switch (alt10) { case 1 : - // InternalBehaviorAnnexParser.g:2807:2: ( ( rule__CommunicationAction__Group_0_1_0__0 ) ) + // InternalBehaviorAnnexParser.g:2932:2: ( ( rule__CommunicationAction__Group_0_1_0__0 ) ) { - // InternalBehaviorAnnexParser.g:2807:2: ( ( rule__CommunicationAction__Group_0_1_0__0 ) ) - // InternalBehaviorAnnexParser.g:2808:3: ( rule__CommunicationAction__Group_0_1_0__0 ) + // InternalBehaviorAnnexParser.g:2932:2: ( ( rule__CommunicationAction__Group_0_1_0__0 ) ) + // InternalBehaviorAnnexParser.g:2933:3: ( rule__CommunicationAction__Group_0_1_0__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getGroup_0_1_0()); } - // InternalBehaviorAnnexParser.g:2809:3: ( rule__CommunicationAction__Group_0_1_0__0 ) - // InternalBehaviorAnnexParser.g:2809:4: rule__CommunicationAction__Group_0_1_0__0 + // InternalBehaviorAnnexParser.g:2934:3: ( rule__CommunicationAction__Group_0_1_0__0 ) + // InternalBehaviorAnnexParser.g:2934:4: rule__CommunicationAction__Group_0_1_0__0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0_1_0__0(); @@ -9609,16 +10030,16 @@ public final void rule__CommunicationAction__Alternatives_0_1() throws Recogniti } break; case 2 : - // InternalBehaviorAnnexParser.g:2813:2: ( ( rule__CommunicationAction__Group_0_1_1__0 ) ) + // InternalBehaviorAnnexParser.g:2938:2: ( ( rule__CommunicationAction__Group_0_1_1__0 ) ) { - // InternalBehaviorAnnexParser.g:2813:2: ( ( rule__CommunicationAction__Group_0_1_1__0 ) ) - // InternalBehaviorAnnexParser.g:2814:3: ( rule__CommunicationAction__Group_0_1_1__0 ) + // InternalBehaviorAnnexParser.g:2938:2: ( ( rule__CommunicationAction__Group_0_1_1__0 ) ) + // InternalBehaviorAnnexParser.g:2939:3: ( rule__CommunicationAction__Group_0_1_1__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getGroup_0_1_1()); } - // InternalBehaviorAnnexParser.g:2815:3: ( rule__CommunicationAction__Group_0_1_1__0 ) - // InternalBehaviorAnnexParser.g:2815:4: rule__CommunicationAction__Group_0_1_1__0 + // InternalBehaviorAnnexParser.g:2940:3: ( rule__CommunicationAction__Group_0_1_1__0 ) + // InternalBehaviorAnnexParser.g:2940:4: rule__CommunicationAction__Group_0_1_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0_1_1__0(); @@ -9638,16 +10059,16 @@ public final void rule__CommunicationAction__Alternatives_0_1() throws Recogniti } break; case 3 : - // InternalBehaviorAnnexParser.g:2819:2: ( ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) ) + // InternalBehaviorAnnexParser.g:2944:2: ( ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) ) { - // InternalBehaviorAnnexParser.g:2819:2: ( ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) ) - // InternalBehaviorAnnexParser.g:2820:3: ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) + // InternalBehaviorAnnexParser.g:2944:2: ( ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) ) + // InternalBehaviorAnnexParser.g:2945:3: ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getFreezeAssignment_0_1_2()); } - // InternalBehaviorAnnexParser.g:2821:3: ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) - // InternalBehaviorAnnexParser.g:2821:4: rule__CommunicationAction__FreezeAssignment_0_1_2 + // InternalBehaviorAnnexParser.g:2946:3: ( rule__CommunicationAction__FreezeAssignment_0_1_2 ) + // InternalBehaviorAnnexParser.g:2946:4: rule__CommunicationAction__FreezeAssignment_0_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__FreezeAssignment_0_1_2(); @@ -9667,16 +10088,16 @@ public final void rule__CommunicationAction__Alternatives_0_1() throws Recogniti } break; case 4 : - // InternalBehaviorAnnexParser.g:2825:2: ( ( rule__CommunicationAction__LockAssignment_0_1_3 ) ) + // InternalBehaviorAnnexParser.g:2950:2: ( ( rule__CommunicationAction__LockAssignment_0_1_3 ) ) { - // InternalBehaviorAnnexParser.g:2825:2: ( ( rule__CommunicationAction__LockAssignment_0_1_3 ) ) - // InternalBehaviorAnnexParser.g:2826:3: ( rule__CommunicationAction__LockAssignment_0_1_3 ) + // InternalBehaviorAnnexParser.g:2950:2: ( ( rule__CommunicationAction__LockAssignment_0_1_3 ) ) + // InternalBehaviorAnnexParser.g:2951:3: ( rule__CommunicationAction__LockAssignment_0_1_3 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getLockAssignment_0_1_3()); } - // InternalBehaviorAnnexParser.g:2827:3: ( rule__CommunicationAction__LockAssignment_0_1_3 ) - // InternalBehaviorAnnexParser.g:2827:4: rule__CommunicationAction__LockAssignment_0_1_3 + // InternalBehaviorAnnexParser.g:2952:3: ( rule__CommunicationAction__LockAssignment_0_1_3 ) + // InternalBehaviorAnnexParser.g:2952:4: rule__CommunicationAction__LockAssignment_0_1_3 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__LockAssignment_0_1_3(); @@ -9696,16 +10117,16 @@ public final void rule__CommunicationAction__Alternatives_0_1() throws Recogniti } break; case 5 : - // InternalBehaviorAnnexParser.g:2831:2: ( ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) ) + // InternalBehaviorAnnexParser.g:2956:2: ( ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) ) { - // InternalBehaviorAnnexParser.g:2831:2: ( ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) ) - // InternalBehaviorAnnexParser.g:2832:3: ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) + // InternalBehaviorAnnexParser.g:2956:2: ( ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) ) + // InternalBehaviorAnnexParser.g:2957:3: ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getUnlockAssignment_0_1_4()); } - // InternalBehaviorAnnexParser.g:2833:3: ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) - // InternalBehaviorAnnexParser.g:2833:4: rule__CommunicationAction__UnlockAssignment_0_1_4 + // InternalBehaviorAnnexParser.g:2958:3: ( rule__CommunicationAction__UnlockAssignment_0_1_4 ) + // InternalBehaviorAnnexParser.g:2958:4: rule__CommunicationAction__UnlockAssignment_0_1_4 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__UnlockAssignment_0_1_4(); @@ -9742,13 +10163,13 @@ public final void rule__CommunicationAction__Alternatives_0_1() throws Recogniti // $ANTLR start "rule__CommunicationAction__Alternatives_1_1" - // InternalBehaviorAnnexParser.g:2841:1: rule__CommunicationAction__Alternatives_1_1 : ( ( ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) ) | ( ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) ) ); + // InternalBehaviorAnnexParser.g:2966:1: rule__CommunicationAction__Alternatives_1_1 : ( ( ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) ) | ( ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) ) ); public final void rule__CommunicationAction__Alternatives_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2845:1: ( ( ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) ) | ( ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:2970:1: ( ( ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) ) | ( ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) ) ) int alt11=2; int LA11_0 = input.LA(1); @@ -9767,16 +10188,16 @@ else if ( (LA11_0==ExclamationMarkGreaterThanSign) ) { } switch (alt11) { case 1 : - // InternalBehaviorAnnexParser.g:2846:2: ( ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) ) + // InternalBehaviorAnnexParser.g:2971:2: ( ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) ) { - // InternalBehaviorAnnexParser.g:2846:2: ( ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) ) - // InternalBehaviorAnnexParser.g:2847:3: ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) + // InternalBehaviorAnnexParser.g:2971:2: ( ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) ) + // InternalBehaviorAnnexParser.g:2972:3: ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllLockAssignment_1_1_0()); } - // InternalBehaviorAnnexParser.g:2848:3: ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) - // InternalBehaviorAnnexParser.g:2848:4: rule__CommunicationAction__AllLockAssignment_1_1_0 + // InternalBehaviorAnnexParser.g:2973:3: ( rule__CommunicationAction__AllLockAssignment_1_1_0 ) + // InternalBehaviorAnnexParser.g:2973:4: rule__CommunicationAction__AllLockAssignment_1_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__AllLockAssignment_1_1_0(); @@ -9796,16 +10217,16 @@ else if ( (LA11_0==ExclamationMarkGreaterThanSign) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:2852:2: ( ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:2977:2: ( ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) ) { - // InternalBehaviorAnnexParser.g:2852:2: ( ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) ) - // InternalBehaviorAnnexParser.g:2853:3: ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) + // InternalBehaviorAnnexParser.g:2977:2: ( ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:2978:3: ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllUnlockAssignment_1_1_1()); } - // InternalBehaviorAnnexParser.g:2854:3: ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) - // InternalBehaviorAnnexParser.g:2854:4: rule__CommunicationAction__AllUnlockAssignment_1_1_1 + // InternalBehaviorAnnexParser.g:2979:3: ( rule__CommunicationAction__AllUnlockAssignment_1_1_1 ) + // InternalBehaviorAnnexParser.g:2979:4: rule__CommunicationAction__AllUnlockAssignment_1_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__AllUnlockAssignment_1_1_1(); @@ -9842,13 +10263,13 @@ else if ( (LA11_0==ExclamationMarkGreaterThanSign) ) { // $ANTLR start "rule__ForStatement__Alternatives_0" - // InternalBehaviorAnnexParser.g:2862:1: rule__ForStatement__Alternatives_0 : ( ( ( rule__ForStatement__ForAssignment_0_0 ) ) | ( ( rule__ForStatement__ForallAssignment_0_1 ) ) ); + // InternalBehaviorAnnexParser.g:2987:1: rule__ForStatement__Alternatives_0 : ( ( ( rule__ForStatement__ForAssignment_0_0 ) ) | ( ( rule__ForStatement__ForallAssignment_0_1 ) ) ); public final void rule__ForStatement__Alternatives_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2866:1: ( ( ( rule__ForStatement__ForAssignment_0_0 ) ) | ( ( rule__ForStatement__ForallAssignment_0_1 ) ) ) + // InternalBehaviorAnnexParser.g:2991:1: ( ( ( rule__ForStatement__ForAssignment_0_0 ) ) | ( ( rule__ForStatement__ForallAssignment_0_1 ) ) ) int alt12=2; int LA12_0 = input.LA(1); @@ -9867,16 +10288,16 @@ else if ( (LA12_0==Forall) ) { } switch (alt12) { case 1 : - // InternalBehaviorAnnexParser.g:2867:2: ( ( rule__ForStatement__ForAssignment_0_0 ) ) + // InternalBehaviorAnnexParser.g:2992:2: ( ( rule__ForStatement__ForAssignment_0_0 ) ) { - // InternalBehaviorAnnexParser.g:2867:2: ( ( rule__ForStatement__ForAssignment_0_0 ) ) - // InternalBehaviorAnnexParser.g:2868:3: ( rule__ForStatement__ForAssignment_0_0 ) + // InternalBehaviorAnnexParser.g:2992:2: ( ( rule__ForStatement__ForAssignment_0_0 ) ) + // InternalBehaviorAnnexParser.g:2993:3: ( rule__ForStatement__ForAssignment_0_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getForAssignment_0_0()); } - // InternalBehaviorAnnexParser.g:2869:3: ( rule__ForStatement__ForAssignment_0_0 ) - // InternalBehaviorAnnexParser.g:2869:4: rule__ForStatement__ForAssignment_0_0 + // InternalBehaviorAnnexParser.g:2994:3: ( rule__ForStatement__ForAssignment_0_0 ) + // InternalBehaviorAnnexParser.g:2994:4: rule__ForStatement__ForAssignment_0_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ForStatement__ForAssignment_0_0(); @@ -9896,16 +10317,16 @@ else if ( (LA12_0==Forall) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:2873:2: ( ( rule__ForStatement__ForallAssignment_0_1 ) ) + // InternalBehaviorAnnexParser.g:2998:2: ( ( rule__ForStatement__ForallAssignment_0_1 ) ) { - // InternalBehaviorAnnexParser.g:2873:2: ( ( rule__ForStatement__ForallAssignment_0_1 ) ) - // InternalBehaviorAnnexParser.g:2874:3: ( rule__ForStatement__ForallAssignment_0_1 ) + // InternalBehaviorAnnexParser.g:2998:2: ( ( rule__ForStatement__ForallAssignment_0_1 ) ) + // InternalBehaviorAnnexParser.g:2999:3: ( rule__ForStatement__ForallAssignment_0_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getForallAssignment_0_1()); } - // InternalBehaviorAnnexParser.g:2875:3: ( rule__ForStatement__ForallAssignment_0_1 ) - // InternalBehaviorAnnexParser.g:2875:4: rule__ForStatement__ForallAssignment_0_1 + // InternalBehaviorAnnexParser.g:3000:3: ( rule__ForStatement__ForallAssignment_0_1 ) + // InternalBehaviorAnnexParser.g:3000:4: rule__ForStatement__ForallAssignment_0_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ForStatement__ForallAssignment_0_1(); @@ -9942,13 +10363,13 @@ else if ( (LA12_0==Forall) ) { // $ANTLR start "rule__IntegerValue__Alternatives" - // InternalBehaviorAnnexParser.g:2883:1: rule__IntegerValue__Alternatives : ( ( ruleBehaviorIntegerLiteral ) | ( ruleHashPropertyReference ) | ( ruleReferenceExpression ) ); + // InternalBehaviorAnnexParser.g:3008:1: rule__IntegerValue__Alternatives : ( ( ruleBehaviorIntegerLiteral ) | ( ruleHashPropertyReference ) | ( ruleReferenceExpression ) ); public final void rule__IntegerValue__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2887:1: ( ( ruleBehaviorIntegerLiteral ) | ( ruleHashPropertyReference ) | ( ruleReferenceExpression ) ) + // InternalBehaviorAnnexParser.g:3012:1: ( ( ruleBehaviorIntegerLiteral ) | ( ruleHashPropertyReference ) | ( ruleReferenceExpression ) ) int alt13=3; switch ( input.LA(1) ) { case RULE_INTEGER_LIT: @@ -9976,10 +10397,10 @@ public final void rule__IntegerValue__Alternatives() throws RecognitionException switch (alt13) { case 1 : - // InternalBehaviorAnnexParser.g:2888:2: ( ruleBehaviorIntegerLiteral ) + // InternalBehaviorAnnexParser.g:3013:2: ( ruleBehaviorIntegerLiteral ) { - // InternalBehaviorAnnexParser.g:2888:2: ( ruleBehaviorIntegerLiteral ) - // InternalBehaviorAnnexParser.g:2889:3: ruleBehaviorIntegerLiteral + // InternalBehaviorAnnexParser.g:3013:2: ( ruleBehaviorIntegerLiteral ) + // InternalBehaviorAnnexParser.g:3014:3: ruleBehaviorIntegerLiteral { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerValueAccess().getBehaviorIntegerLiteralParserRuleCall_0()); @@ -9999,10 +10420,10 @@ public final void rule__IntegerValue__Alternatives() throws RecognitionException } break; case 2 : - // InternalBehaviorAnnexParser.g:2894:2: ( ruleHashPropertyReference ) + // InternalBehaviorAnnexParser.g:3019:2: ( ruleHashPropertyReference ) { - // InternalBehaviorAnnexParser.g:2894:2: ( ruleHashPropertyReference ) - // InternalBehaviorAnnexParser.g:2895:3: ruleHashPropertyReference + // InternalBehaviorAnnexParser.g:3019:2: ( ruleHashPropertyReference ) + // InternalBehaviorAnnexParser.g:3020:3: ruleHashPropertyReference { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerValueAccess().getHashPropertyReferenceParserRuleCall_1()); @@ -10022,10 +10443,10 @@ public final void rule__IntegerValue__Alternatives() throws RecognitionException } break; case 3 : - // InternalBehaviorAnnexParser.g:2900:2: ( ruleReferenceExpression ) + // InternalBehaviorAnnexParser.g:3025:2: ( ruleReferenceExpression ) { - // InternalBehaviorAnnexParser.g:2900:2: ( ruleReferenceExpression ) - // InternalBehaviorAnnexParser.g:2901:3: ruleReferenceExpression + // InternalBehaviorAnnexParser.g:3025:2: ( ruleReferenceExpression ) + // InternalBehaviorAnnexParser.g:3026:3: ruleReferenceExpression { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerValueAccess().getReferenceExpressionParserRuleCall_2()); @@ -10061,21 +10482,21 @@ public final void rule__IntegerValue__Alternatives() throws RecognitionException // $ANTLR end "rule__IntegerValue__Alternatives" - // $ANTLR start "rule__LogicalOrOperator__Alternatives" - // InternalBehaviorAnnexParser.g:2910:1: rule__LogicalOrOperator__Alternatives : ( ( ( rule__LogicalOrOperator__Group_0__0 ) ) | ( Xor ) ); - public final void rule__LogicalOrOperator__Alternatives() throws RecognitionException { + // $ANTLR start "rule__LogicalOperator__Alternatives" + // InternalBehaviorAnnexParser.g:3035:1: rule__LogicalOperator__Alternatives : ( ( ruleLogicalAndOperator ) | ( ruleLogicalOrOperator ) ); + public final void rule__LogicalOperator__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2914:1: ( ( ( rule__LogicalOrOperator__Group_0__0 ) ) | ( Xor ) ) + // InternalBehaviorAnnexParser.g:3039:1: ( ( ruleLogicalAndOperator ) | ( ruleLogicalOrOperator ) ) int alt14=2; int LA14_0 = input.LA(1); - if ( (LA14_0==Or) ) { + if ( (LA14_0==And) ) { alt14=1; } - else if ( (LA14_0==Xor) ) { + else if ( (LA14_0==Xor||LA14_0==Or) ) { alt14=2; } else { @@ -10087,16 +10508,104 @@ else if ( (LA14_0==Xor) ) { } switch (alt14) { case 1 : - // InternalBehaviorAnnexParser.g:2915:2: ( ( rule__LogicalOrOperator__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:3040:2: ( ruleLogicalAndOperator ) { - // InternalBehaviorAnnexParser.g:2915:2: ( ( rule__LogicalOrOperator__Group_0__0 ) ) - // InternalBehaviorAnnexParser.g:2916:3: ( rule__LogicalOrOperator__Group_0__0 ) + // InternalBehaviorAnnexParser.g:3040:2: ( ruleLogicalAndOperator ) + // InternalBehaviorAnnexParser.g:3041:3: ruleLogicalAndOperator + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLogicalOperatorAccess().getLogicalAndOperatorParserRuleCall_0()); + } + pushFollow(FollowSets000.FOLLOW_2); + ruleLogicalAndOperator(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLogicalOperatorAccess().getLogicalAndOperatorParserRuleCall_0()); + } + + } + + + } + break; + case 2 : + // InternalBehaviorAnnexParser.g:3046:2: ( ruleLogicalOrOperator ) + { + // InternalBehaviorAnnexParser.g:3046:2: ( ruleLogicalOrOperator ) + // InternalBehaviorAnnexParser.g:3047:3: ruleLogicalOrOperator + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLogicalOperatorAccess().getLogicalOrOperatorParserRuleCall_1()); + } + pushFollow(FollowSets000.FOLLOW_2); + ruleLogicalOrOperator(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLogicalOperatorAccess().getLogicalOrOperatorParserRuleCall_1()); + } + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LogicalOperator__Alternatives" + + + // $ANTLR start "rule__LogicalOrOperator__Alternatives" + // InternalBehaviorAnnexParser.g:3056:1: rule__LogicalOrOperator__Alternatives : ( ( ( rule__LogicalOrOperator__Group_0__0 ) ) | ( Xor ) ); + public final void rule__LogicalOrOperator__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalBehaviorAnnexParser.g:3060:1: ( ( ( rule__LogicalOrOperator__Group_0__0 ) ) | ( Xor ) ) + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==Or) ) { + alt15=1; + } + else if ( (LA15_0==Xor) ) { + alt15=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + switch (alt15) { + case 1 : + // InternalBehaviorAnnexParser.g:3061:2: ( ( rule__LogicalOrOperator__Group_0__0 ) ) + { + // InternalBehaviorAnnexParser.g:3061:2: ( ( rule__LogicalOrOperator__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:3062:3: ( rule__LogicalOrOperator__Group_0__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getLogicalOrOperatorAccess().getGroup_0()); } - // InternalBehaviorAnnexParser.g:2917:3: ( rule__LogicalOrOperator__Group_0__0 ) - // InternalBehaviorAnnexParser.g:2917:4: rule__LogicalOrOperator__Group_0__0 + // InternalBehaviorAnnexParser.g:3063:3: ( rule__LogicalOrOperator__Group_0__0 ) + // InternalBehaviorAnnexParser.g:3063:4: rule__LogicalOrOperator__Group_0__0 { pushFollow(FollowSets000.FOLLOW_2); rule__LogicalOrOperator__Group_0__0(); @@ -10116,10 +10625,10 @@ else if ( (LA14_0==Xor) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:2921:2: ( Xor ) + // InternalBehaviorAnnexParser.g:3067:2: ( Xor ) { - // InternalBehaviorAnnexParser.g:2921:2: ( Xor ) - // InternalBehaviorAnnexParser.g:2922:3: Xor + // InternalBehaviorAnnexParser.g:3067:2: ( Xor ) + // InternalBehaviorAnnexParser.g:3068:3: Xor { if ( state.backtracking==0 ) { before(grammarAccess.getLogicalOrOperatorAccess().getXorKeyword_1()); @@ -10151,67 +10660,67 @@ else if ( (LA14_0==Xor) ) { // $ANTLR end "rule__LogicalOrOperator__Alternatives" - // $ANTLR start "rule__RelationalExpression__OperatorAlternatives_1_1_0" - // InternalBehaviorAnnexParser.g:2931:1: rule__RelationalExpression__OperatorAlternatives_1_1_0 : ( ( EqualsSign ) | ( ExclamationMarkEqualsSign ) | ( LessThanSign ) | ( LessThanSignEqualsSign ) | ( GreaterThanSign ) | ( GreaterThanSignEqualsSign ) ); - public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throws RecognitionException { + // $ANTLR start "rule__RelationalOperator__Alternatives" + // InternalBehaviorAnnexParser.g:3077:1: rule__RelationalOperator__Alternatives : ( ( EqualsSign ) | ( ExclamationMarkEqualsSign ) | ( LessThanSign ) | ( LessThanSignEqualsSign ) | ( GreaterThanSign ) | ( GreaterThanSignEqualsSign ) ); + public final void rule__RelationalOperator__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2935:1: ( ( EqualsSign ) | ( ExclamationMarkEqualsSign ) | ( LessThanSign ) | ( LessThanSignEqualsSign ) | ( GreaterThanSign ) | ( GreaterThanSignEqualsSign ) ) - int alt15=6; + // InternalBehaviorAnnexParser.g:3081:1: ( ( EqualsSign ) | ( ExclamationMarkEqualsSign ) | ( LessThanSign ) | ( LessThanSignEqualsSign ) | ( GreaterThanSign ) | ( GreaterThanSignEqualsSign ) ) + int alt16=6; switch ( input.LA(1) ) { case EqualsSign: { - alt15=1; + alt16=1; } break; case ExclamationMarkEqualsSign: { - alt15=2; + alt16=2; } break; case LessThanSign: { - alt15=3; + alt16=3; } break; case LessThanSignEqualsSign: { - alt15=4; + alt16=4; } break; case GreaterThanSign: { - alt15=5; + alt16=5; } break; case GreaterThanSignEqualsSign: { - alt15=6; + alt16=6; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 15, 0, input); + new NoViableAltException("", 16, 0, input); throw nvae; } - switch (alt15) { + switch (alt16) { case 1 : - // InternalBehaviorAnnexParser.g:2936:2: ( EqualsSign ) + // InternalBehaviorAnnexParser.g:3082:2: ( EqualsSign ) { - // InternalBehaviorAnnexParser.g:2936:2: ( EqualsSign ) - // InternalBehaviorAnnexParser.g:2937:3: EqualsSign + // InternalBehaviorAnnexParser.g:3082:2: ( EqualsSign ) + // InternalBehaviorAnnexParser.g:3083:3: EqualsSign { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignKeyword_1_1_0_0()); + before(grammarAccess.getRelationalOperatorAccess().getEqualsSignKeyword_0()); } match(input,EqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignKeyword_1_1_0_0()); + after(grammarAccess.getRelationalOperatorAccess().getEqualsSignKeyword_0()); } } @@ -10220,17 +10729,17 @@ public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throw } break; case 2 : - // InternalBehaviorAnnexParser.g:2942:2: ( ExclamationMarkEqualsSign ) + // InternalBehaviorAnnexParser.g:3088:2: ( ExclamationMarkEqualsSign ) { - // InternalBehaviorAnnexParser.g:2942:2: ( ExclamationMarkEqualsSign ) - // InternalBehaviorAnnexParser.g:2943:3: ExclamationMarkEqualsSign + // InternalBehaviorAnnexParser.g:3088:2: ( ExclamationMarkEqualsSign ) + // InternalBehaviorAnnexParser.g:3089:3: ExclamationMarkEqualsSign { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); + before(grammarAccess.getRelationalOperatorAccess().getExclamationMarkEqualsSignKeyword_1()); } match(input,ExclamationMarkEqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); + after(grammarAccess.getRelationalOperatorAccess().getExclamationMarkEqualsSignKeyword_1()); } } @@ -10239,17 +10748,17 @@ public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throw } break; case 3 : - // InternalBehaviorAnnexParser.g:2948:2: ( LessThanSign ) + // InternalBehaviorAnnexParser.g:3094:2: ( LessThanSign ) { - // InternalBehaviorAnnexParser.g:2948:2: ( LessThanSign ) - // InternalBehaviorAnnexParser.g:2949:3: LessThanSign + // InternalBehaviorAnnexParser.g:3094:2: ( LessThanSign ) + // InternalBehaviorAnnexParser.g:3095:3: LessThanSign { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_2()); + before(grammarAccess.getRelationalOperatorAccess().getLessThanSignKeyword_2()); } match(input,LessThanSign,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_2()); + after(grammarAccess.getRelationalOperatorAccess().getLessThanSignKeyword_2()); } } @@ -10258,17 +10767,17 @@ public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throw } break; case 4 : - // InternalBehaviorAnnexParser.g:2954:2: ( LessThanSignEqualsSign ) + // InternalBehaviorAnnexParser.g:3100:2: ( LessThanSignEqualsSign ) { - // InternalBehaviorAnnexParser.g:2954:2: ( LessThanSignEqualsSign ) - // InternalBehaviorAnnexParser.g:2955:3: LessThanSignEqualsSign + // InternalBehaviorAnnexParser.g:3100:2: ( LessThanSignEqualsSign ) + // InternalBehaviorAnnexParser.g:3101:3: LessThanSignEqualsSign { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); + before(grammarAccess.getRelationalOperatorAccess().getLessThanSignEqualsSignKeyword_3()); } match(input,LessThanSignEqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); + after(grammarAccess.getRelationalOperatorAccess().getLessThanSignEqualsSignKeyword_3()); } } @@ -10277,17 +10786,17 @@ public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throw } break; case 5 : - // InternalBehaviorAnnexParser.g:2960:2: ( GreaterThanSign ) + // InternalBehaviorAnnexParser.g:3106:2: ( GreaterThanSign ) { - // InternalBehaviorAnnexParser.g:2960:2: ( GreaterThanSign ) - // InternalBehaviorAnnexParser.g:2961:3: GreaterThanSign + // InternalBehaviorAnnexParser.g:3106:2: ( GreaterThanSign ) + // InternalBehaviorAnnexParser.g:3107:3: GreaterThanSign { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); + before(grammarAccess.getRelationalOperatorAccess().getGreaterThanSignKeyword_4()); } match(input,GreaterThanSign,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); + after(grammarAccess.getRelationalOperatorAccess().getGreaterThanSignKeyword_4()); } } @@ -10296,17 +10805,17 @@ public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throw } break; case 6 : - // InternalBehaviorAnnexParser.g:2966:2: ( GreaterThanSignEqualsSign ) + // InternalBehaviorAnnexParser.g:3112:2: ( GreaterThanSignEqualsSign ) { - // InternalBehaviorAnnexParser.g:2966:2: ( GreaterThanSignEqualsSign ) - // InternalBehaviorAnnexParser.g:2967:3: GreaterThanSignEqualsSign + // InternalBehaviorAnnexParser.g:3112:2: ( GreaterThanSignEqualsSign ) + // InternalBehaviorAnnexParser.g:3113:3: GreaterThanSignEqualsSign { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_5()); + before(grammarAccess.getRelationalOperatorAccess().getGreaterThanSignEqualsSignKeyword_5()); } match(input,GreaterThanSignEqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_5()); + after(grammarAccess.getRelationalOperatorAccess().getGreaterThanSignEqualsSignKeyword_5()); } } @@ -10328,46 +10837,56 @@ public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throw } return ; } - // $ANTLR end "rule__RelationalExpression__OperatorAlternatives_1_1_0" + // $ANTLR end "rule__RelationalOperator__Alternatives" - // $ANTLR start "rule__AdditiveExpression__OperatorAlternatives_1_1_0" - // InternalBehaviorAnnexParser.g:2976:1: rule__AdditiveExpression__OperatorAlternatives_1_1_0 : ( ( PlusSign ) | ( HyphenMinus ) ); - public final void rule__AdditiveExpression__OperatorAlternatives_1_1_0() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__Alternatives_0" + // InternalBehaviorAnnexParser.g:3122:1: rule__SimpleExpression__Alternatives_0 : ( ( ( rule__SimpleExpression__Group_0_0__0 ) ) | ( ruleTerm ) ); + public final void rule__SimpleExpression__Alternatives_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:2980:1: ( ( PlusSign ) | ( HyphenMinus ) ) - int alt16=2; - int LA16_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3126:1: ( ( ( rule__SimpleExpression__Group_0_0__0 ) ) | ( ruleTerm ) ) + int alt17=2; + int LA17_0 = input.LA(1); - if ( (LA16_0==PlusSign) ) { - alt16=1; + if ( (LA17_0==PlusSign||LA17_0==HyphenMinus) ) { + alt17=1; } - else if ( (LA16_0==HyphenMinus) ) { - alt16=2; + else if ( (LA17_0==False||LA17_0==True||LA17_0==Abs||LA17_0==Not||LA17_0==NumberSign||LA17_0==LeftParenthesis||LA17_0==RULE_REAL_LIT||LA17_0==RULE_INTEGER_LIT||(LA17_0>=RULE_STRING && LA17_0<=RULE_ID)) ) { + alt17=2; } else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 16, 0, input); + new NoViableAltException("", 17, 0, input); throw nvae; } - switch (alt16) { + switch (alt17) { case 1 : - // InternalBehaviorAnnexParser.g:2981:2: ( PlusSign ) + // InternalBehaviorAnnexParser.g:3127:2: ( ( rule__SimpleExpression__Group_0_0__0 ) ) { - // InternalBehaviorAnnexParser.g:2981:2: ( PlusSign ) - // InternalBehaviorAnnexParser.g:2982:3: PlusSign + // InternalBehaviorAnnexParser.g:3127:2: ( ( rule__SimpleExpression__Group_0_0__0 ) ) + // InternalBehaviorAnnexParser.g:3128:3: ( rule__SimpleExpression__Group_0_0__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getOperatorPlusSignKeyword_1_1_0_0()); + before(grammarAccess.getSimpleExpressionAccess().getGroup_0_0()); } - match(input,PlusSign,FollowSets000.FOLLOW_2); if (state.failed) return ; + // InternalBehaviorAnnexParser.g:3129:3: ( rule__SimpleExpression__Group_0_0__0 ) + // InternalBehaviorAnnexParser.g:3129:4: rule__SimpleExpression__Group_0_0__0 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__SimpleExpression__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getOperatorPlusSignKeyword_1_1_0_0()); + after(grammarAccess.getSimpleExpressionAccess().getGroup_0_0()); } } @@ -10376,17 +10895,21 @@ else if ( (LA16_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:2987:2: ( HyphenMinus ) + // InternalBehaviorAnnexParser.g:3133:2: ( ruleTerm ) { - // InternalBehaviorAnnexParser.g:2987:2: ( HyphenMinus ) - // InternalBehaviorAnnexParser.g:2988:3: HyphenMinus + // InternalBehaviorAnnexParser.g:3133:2: ( ruleTerm ) + // InternalBehaviorAnnexParser.g:3134:3: ruleTerm { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getOperatorHyphenMinusKeyword_1_1_0_1()); + before(grammarAccess.getSimpleExpressionAccess().getTermParserRuleCall_0_1()); } - match(input,HyphenMinus,FollowSets000.FOLLOW_2); if (state.failed) return ; + pushFollow(FollowSets000.FOLLOW_2); + ruleTerm(); + + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getOperatorHyphenMinusKeyword_1_1_0_1()); + after(grammarAccess.getSimpleExpressionAccess().getTermParserRuleCall_0_1()); } } @@ -10408,60 +10931,46 @@ else if ( (LA16_0==HyphenMinus) ) { } return ; } - // $ANTLR end "rule__AdditiveExpression__OperatorAlternatives_1_1_0" + // $ANTLR end "rule__SimpleExpression__Alternatives_0" - // $ANTLR start "rule__MultiplicativeExpression__OperatorAlternatives_1_1_0" - // InternalBehaviorAnnexParser.g:2997:1: rule__MultiplicativeExpression__OperatorAlternatives_1_1_0 : ( ( Asterisk ) | ( Solidus ) | ( Mod ) | ( Rem ) ); - public final void rule__MultiplicativeExpression__OperatorAlternatives_1_1_0() throws RecognitionException { + // $ANTLR start "rule__UnaryAddingOperator__Alternatives" + // InternalBehaviorAnnexParser.g:3143:1: rule__UnaryAddingOperator__Alternatives : ( ( HyphenMinus ) | ( PlusSign ) ); + public final void rule__UnaryAddingOperator__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3001:1: ( ( Asterisk ) | ( Solidus ) | ( Mod ) | ( Rem ) ) - int alt17=4; - switch ( input.LA(1) ) { - case Asterisk: - { - alt17=1; - } - break; - case Solidus: - { - alt17=2; - } - break; - case Mod: - { - alt17=3; - } - break; - case Rem: - { - alt17=4; - } - break; - default: + // InternalBehaviorAnnexParser.g:3147:1: ( ( HyphenMinus ) | ( PlusSign ) ) + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==HyphenMinus) ) { + alt18=1; + } + else if ( (LA18_0==PlusSign) ) { + alt18=2; + } + else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 17, 0, input); + new NoViableAltException("", 18, 0, input); throw nvae; } - - switch (alt17) { + switch (alt18) { case 1 : - // InternalBehaviorAnnexParser.g:3002:2: ( Asterisk ) + // InternalBehaviorAnnexParser.g:3148:2: ( HyphenMinus ) { - // InternalBehaviorAnnexParser.g:3002:2: ( Asterisk ) - // InternalBehaviorAnnexParser.g:3003:3: Asterisk + // InternalBehaviorAnnexParser.g:3148:2: ( HyphenMinus ) + // InternalBehaviorAnnexParser.g:3149:3: HyphenMinus { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskKeyword_1_1_0_0()); + before(grammarAccess.getUnaryAddingOperatorAccess().getHyphenMinusKeyword_0()); } - match(input,Asterisk,FollowSets000.FOLLOW_2); if (state.failed) return ; + match(input,HyphenMinus,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskKeyword_1_1_0_0()); + after(grammarAccess.getUnaryAddingOperatorAccess().getHyphenMinusKeyword_0()); } } @@ -10470,55 +10979,17 @@ public final void rule__MultiplicativeExpression__OperatorAlternatives_1_1_0() t } break; case 2 : - // InternalBehaviorAnnexParser.g:3008:2: ( Solidus ) - { - // InternalBehaviorAnnexParser.g:3008:2: ( Solidus ) - // InternalBehaviorAnnexParser.g:3009:3: Solidus - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorSolidusKeyword_1_1_0_1()); - } - match(input,Solidus,FollowSets000.FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorSolidusKeyword_1_1_0_1()); - } - - } - - - } - break; - case 3 : - // InternalBehaviorAnnexParser.g:3014:2: ( Mod ) + // InternalBehaviorAnnexParser.g:3154:2: ( PlusSign ) { - // InternalBehaviorAnnexParser.g:3014:2: ( Mod ) - // InternalBehaviorAnnexParser.g:3015:3: Mod + // InternalBehaviorAnnexParser.g:3154:2: ( PlusSign ) + // InternalBehaviorAnnexParser.g:3155:3: PlusSign { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorModKeyword_1_1_0_2()); + before(grammarAccess.getUnaryAddingOperatorAccess().getPlusSignKeyword_1()); } - match(input,Mod,FollowSets000.FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorModKeyword_1_1_0_2()); - } - - } - - - } - break; - case 4 : - // InternalBehaviorAnnexParser.g:3020:2: ( Rem ) - { - // InternalBehaviorAnnexParser.g:3020:2: ( Rem ) - // InternalBehaviorAnnexParser.g:3021:3: Rem - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorRemKeyword_1_1_0_3()); - } - match(input,Rem,FollowSets000.FOLLOW_2); if (state.failed) return ; + match(input,PlusSign,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorRemKeyword_1_1_0_3()); + after(grammarAccess.getUnaryAddingOperatorAccess().getPlusSignKeyword_1()); } } @@ -10540,56 +11011,46 @@ public final void rule__MultiplicativeExpression__OperatorAlternatives_1_1_0() t } return ; } - // $ANTLR end "rule__MultiplicativeExpression__OperatorAlternatives_1_1_0" + // $ANTLR end "rule__UnaryAddingOperator__Alternatives" - // $ANTLR start "rule__UnaryExpression__Alternatives" - // InternalBehaviorAnnexParser.g:3030:1: rule__UnaryExpression__Alternatives : ( ( ( rule__UnaryExpression__Group_0__0 ) ) | ( rulePrimaryExpression ) ); - public final void rule__UnaryExpression__Alternatives() throws RecognitionException { + // $ANTLR start "rule__BinaryAddingOperator__Alternatives" + // InternalBehaviorAnnexParser.g:3164:1: rule__BinaryAddingOperator__Alternatives : ( ( PlusSign ) | ( HyphenMinus ) ); + public final void rule__BinaryAddingOperator__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3034:1: ( ( ( rule__UnaryExpression__Group_0__0 ) ) | ( rulePrimaryExpression ) ) - int alt18=2; - int LA18_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3168:1: ( ( PlusSign ) | ( HyphenMinus ) ) + int alt19=2; + int LA19_0 = input.LA(1); - if ( (LA18_0==Abs||LA18_0==Not||LA18_0==PlusSign||LA18_0==HyphenMinus) ) { - alt18=1; + if ( (LA19_0==PlusSign) ) { + alt19=1; } - else if ( (LA18_0==False||LA18_0==True||LA18_0==NumberSign||LA18_0==LeftParenthesis||LA18_0==RULE_REAL_LIT||LA18_0==RULE_INTEGER_LIT||(LA18_0>=RULE_STRING && LA18_0<=RULE_ID)) ) { - alt18=2; + else if ( (LA19_0==HyphenMinus) ) { + alt19=2; } else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 18, 0, input); + new NoViableAltException("", 19, 0, input); throw nvae; } - switch (alt18) { + switch (alt19) { case 1 : - // InternalBehaviorAnnexParser.g:3035:2: ( ( rule__UnaryExpression__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:3169:2: ( PlusSign ) { - // InternalBehaviorAnnexParser.g:3035:2: ( ( rule__UnaryExpression__Group_0__0 ) ) - // InternalBehaviorAnnexParser.g:3036:3: ( rule__UnaryExpression__Group_0__0 ) + // InternalBehaviorAnnexParser.g:3169:2: ( PlusSign ) + // InternalBehaviorAnnexParser.g:3170:3: PlusSign { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getGroup_0()); - } - // InternalBehaviorAnnexParser.g:3037:3: ( rule__UnaryExpression__Group_0__0 ) - // InternalBehaviorAnnexParser.g:3037:4: rule__UnaryExpression__Group_0__0 - { - pushFollow(FollowSets000.FOLLOW_2); - rule__UnaryExpression__Group_0__0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getBinaryAddingOperatorAccess().getPlusSignKeyword_0()); } - + match(input,PlusSign,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getGroup_0()); + after(grammarAccess.getBinaryAddingOperatorAccess().getPlusSignKeyword_0()); } } @@ -10598,21 +11059,17 @@ else if ( (LA18_0==False||LA18_0==True||LA18_0==NumberSign||LA18_0==LeftParenthe } break; case 2 : - // InternalBehaviorAnnexParser.g:3041:2: ( rulePrimaryExpression ) + // InternalBehaviorAnnexParser.g:3175:2: ( HyphenMinus ) { - // InternalBehaviorAnnexParser.g:3041:2: ( rulePrimaryExpression ) - // InternalBehaviorAnnexParser.g:3042:3: rulePrimaryExpression + // InternalBehaviorAnnexParser.g:3175:2: ( HyphenMinus ) + // InternalBehaviorAnnexParser.g:3176:3: HyphenMinus { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getPrimaryExpressionParserRuleCall_1()); + before(grammarAccess.getBinaryAddingOperatorAccess().getHyphenMinusKeyword_1()); } - pushFollow(FollowSets000.FOLLOW_2); - rulePrimaryExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,HyphenMinus,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getPrimaryExpressionParserRuleCall_1()); + after(grammarAccess.getBinaryAddingOperatorAccess().getHyphenMinusKeyword_1()); } } @@ -10634,60 +11091,60 @@ else if ( (LA18_0==False||LA18_0==True||LA18_0==NumberSign||LA18_0==LeftParenthe } return ; } - // $ANTLR end "rule__UnaryExpression__Alternatives" + // $ANTLR end "rule__BinaryAddingOperator__Alternatives" - // $ANTLR start "rule__UnaryExpression__OperatorAlternatives_0_1_0" - // InternalBehaviorAnnexParser.g:3051:1: rule__UnaryExpression__OperatorAlternatives_0_1_0 : ( ( PlusSign ) | ( HyphenMinus ) | ( Abs ) | ( Not ) ); - public final void rule__UnaryExpression__OperatorAlternatives_0_1_0() throws RecognitionException { + // $ANTLR start "rule__MultiplyingOperator__Alternatives" + // InternalBehaviorAnnexParser.g:3185:1: rule__MultiplyingOperator__Alternatives : ( ( Asterisk ) | ( Solidus ) | ( Mod ) | ( Rem ) ); + public final void rule__MultiplyingOperator__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3055:1: ( ( PlusSign ) | ( HyphenMinus ) | ( Abs ) | ( Not ) ) - int alt19=4; + // InternalBehaviorAnnexParser.g:3189:1: ( ( Asterisk ) | ( Solidus ) | ( Mod ) | ( Rem ) ) + int alt20=4; switch ( input.LA(1) ) { - case PlusSign: + case Asterisk: { - alt19=1; + alt20=1; } break; - case HyphenMinus: + case Solidus: { - alt19=2; + alt20=2; } break; - case Abs: + case Mod: { - alt19=3; + alt20=3; } break; - case Not: + case Rem: { - alt19=4; + alt20=4; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 19, 0, input); + new NoViableAltException("", 20, 0, input); throw nvae; } - switch (alt19) { + switch (alt20) { case 1 : - // InternalBehaviorAnnexParser.g:3056:2: ( PlusSign ) + // InternalBehaviorAnnexParser.g:3190:2: ( Asterisk ) { - // InternalBehaviorAnnexParser.g:3056:2: ( PlusSign ) - // InternalBehaviorAnnexParser.g:3057:3: PlusSign + // InternalBehaviorAnnexParser.g:3190:2: ( Asterisk ) + // InternalBehaviorAnnexParser.g:3191:3: Asterisk { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getOperatorPlusSignKeyword_0_1_0_0()); + before(grammarAccess.getMultiplyingOperatorAccess().getAsteriskKeyword_0()); } - match(input,PlusSign,FollowSets000.FOLLOW_2); if (state.failed) return ; + match(input,Asterisk,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getOperatorPlusSignKeyword_0_1_0_0()); + after(grammarAccess.getMultiplyingOperatorAccess().getAsteriskKeyword_0()); } } @@ -10696,17 +11153,17 @@ public final void rule__UnaryExpression__OperatorAlternatives_0_1_0() throws Rec } break; case 2 : - // InternalBehaviorAnnexParser.g:3062:2: ( HyphenMinus ) + // InternalBehaviorAnnexParser.g:3196:2: ( Solidus ) { - // InternalBehaviorAnnexParser.g:3062:2: ( HyphenMinus ) - // InternalBehaviorAnnexParser.g:3063:3: HyphenMinus + // InternalBehaviorAnnexParser.g:3196:2: ( Solidus ) + // InternalBehaviorAnnexParser.g:3197:3: Solidus { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getOperatorHyphenMinusKeyword_0_1_0_1()); + before(grammarAccess.getMultiplyingOperatorAccess().getSolidusKeyword_1()); } - match(input,HyphenMinus,FollowSets000.FOLLOW_2); if (state.failed) return ; + match(input,Solidus,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getOperatorHyphenMinusKeyword_0_1_0_1()); + after(grammarAccess.getMultiplyingOperatorAccess().getSolidusKeyword_1()); } } @@ -10715,17 +11172,17 @@ public final void rule__UnaryExpression__OperatorAlternatives_0_1_0() throws Rec } break; case 3 : - // InternalBehaviorAnnexParser.g:3068:2: ( Abs ) + // InternalBehaviorAnnexParser.g:3202:2: ( Mod ) { - // InternalBehaviorAnnexParser.g:3068:2: ( Abs ) - // InternalBehaviorAnnexParser.g:3069:3: Abs + // InternalBehaviorAnnexParser.g:3202:2: ( Mod ) + // InternalBehaviorAnnexParser.g:3203:3: Mod { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getOperatorAbsKeyword_0_1_0_2()); + before(grammarAccess.getMultiplyingOperatorAccess().getModKeyword_2()); } - match(input,Abs,FollowSets000.FOLLOW_2); if (state.failed) return ; + match(input,Mod,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getOperatorAbsKeyword_0_1_0_2()); + after(grammarAccess.getMultiplyingOperatorAccess().getModKeyword_2()); } } @@ -10734,17 +11191,197 @@ public final void rule__UnaryExpression__OperatorAlternatives_0_1_0() throws Rec } break; case 4 : - // InternalBehaviorAnnexParser.g:3074:2: ( Not ) + // InternalBehaviorAnnexParser.g:3208:2: ( Rem ) { - // InternalBehaviorAnnexParser.g:3074:2: ( Not ) - // InternalBehaviorAnnexParser.g:3075:3: Not + // InternalBehaviorAnnexParser.g:3208:2: ( Rem ) + // InternalBehaviorAnnexParser.g:3209:3: Rem { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getOperatorNotKeyword_0_1_0_3()); + before(grammarAccess.getMultiplyingOperatorAccess().getRemKeyword_3()); + } + match(input,Rem,FollowSets000.FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplyingOperatorAccess().getRemKeyword_3()); + } + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplyingOperator__Alternatives" + + + // $ANTLR start "rule__Factor__Alternatives" + // InternalBehaviorAnnexParser.g:3218:1: rule__Factor__Alternatives : ( ( ( rule__Factor__Group_0__0 ) ) | ( ( rule__Factor__Group_1__0 ) ) ); + public final void rule__Factor__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalBehaviorAnnexParser.g:3222:1: ( ( ( rule__Factor__Group_0__0 ) ) | ( ( rule__Factor__Group_1__0 ) ) ) + int alt21=2; + int LA21_0 = input.LA(1); + + if ( (LA21_0==False||LA21_0==True||LA21_0==NumberSign||LA21_0==LeftParenthesis||LA21_0==RULE_REAL_LIT||LA21_0==RULE_INTEGER_LIT||(LA21_0>=RULE_STRING && LA21_0<=RULE_ID)) ) { + alt21=1; + } + else if ( (LA21_0==Abs||LA21_0==Not) ) { + alt21=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 0, input); + + throw nvae; + } + switch (alt21) { + case 1 : + // InternalBehaviorAnnexParser.g:3223:2: ( ( rule__Factor__Group_0__0 ) ) + { + // InternalBehaviorAnnexParser.g:3223:2: ( ( rule__Factor__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:3224:3: ( rule__Factor__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFactorAccess().getGroup_0()); + } + // InternalBehaviorAnnexParser.g:3225:3: ( rule__Factor__Group_0__0 ) + // InternalBehaviorAnnexParser.g:3225:4: rule__Factor__Group_0__0 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__Factor__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFactorAccess().getGroup_0()); + } + + } + + + } + break; + case 2 : + // InternalBehaviorAnnexParser.g:3229:2: ( ( rule__Factor__Group_1__0 ) ) + { + // InternalBehaviorAnnexParser.g:3229:2: ( ( rule__Factor__Group_1__0 ) ) + // InternalBehaviorAnnexParser.g:3230:3: ( rule__Factor__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFactorAccess().getGroup_1()); + } + // InternalBehaviorAnnexParser.g:3231:3: ( rule__Factor__Group_1__0 ) + // InternalBehaviorAnnexParser.g:3231:4: rule__Factor__Group_1__0 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__Factor__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFactorAccess().getGroup_1()); + } + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Factor__Alternatives" + + + // $ANTLR start "rule__UnaryValueOperator__Alternatives" + // InternalBehaviorAnnexParser.g:3239:1: rule__UnaryValueOperator__Alternatives : ( ( Abs ) | ( Not ) ); + public final void rule__UnaryValueOperator__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalBehaviorAnnexParser.g:3243:1: ( ( Abs ) | ( Not ) ) + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==Abs) ) { + alt22=1; + } + else if ( (LA22_0==Not) ) { + alt22=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 22, 0, input); + + throw nvae; + } + switch (alt22) { + case 1 : + // InternalBehaviorAnnexParser.g:3244:2: ( Abs ) + { + // InternalBehaviorAnnexParser.g:3244:2: ( Abs ) + // InternalBehaviorAnnexParser.g:3245:3: Abs + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryValueOperatorAccess().getAbsKeyword_0()); + } + match(input,Abs,FollowSets000.FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryValueOperatorAccess().getAbsKeyword_0()); + } + + } + + + } + break; + case 2 : + // InternalBehaviorAnnexParser.g:3250:2: ( Not ) + { + // InternalBehaviorAnnexParser.g:3250:2: ( Not ) + // InternalBehaviorAnnexParser.g:3251:3: Not + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryValueOperatorAccess().getNotKeyword_1()); } match(input,Not,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getOperatorNotKeyword_0_1_0_3()); + after(grammarAccess.getUnaryValueOperatorAccess().getNotKeyword_1()); } } @@ -10766,18 +11403,18 @@ public final void rule__UnaryExpression__OperatorAlternatives_0_1_0() throws Rec } return ; } - // $ANTLR end "rule__UnaryExpression__OperatorAlternatives_0_1_0" + // $ANTLR end "rule__UnaryValueOperator__Alternatives" - // $ANTLR start "rule__PrimaryExpression__Alternatives" - // InternalBehaviorAnnexParser.g:3084:1: rule__PrimaryExpression__Alternatives : ( ( ruleValueConstant ) | ( ruleReferenceExpression ) | ( ( rule__PrimaryExpression__Group_2__0 ) ) ); - public final void rule__PrimaryExpression__Alternatives() throws RecognitionException { + // $ANTLR start "rule__Value__Alternatives" + // InternalBehaviorAnnexParser.g:3260:1: rule__Value__Alternatives : ( ( ruleValueConstant ) | ( ruleReferenceExpression ) | ( ruleParenthesizedExpression ) ); + public final void rule__Value__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3088:1: ( ( ruleValueConstant ) | ( ruleReferenceExpression ) | ( ( rule__PrimaryExpression__Group_2__0 ) ) ) - int alt20=3; + // InternalBehaviorAnnexParser.g:3264:1: ( ( ruleValueConstant ) | ( ruleReferenceExpression ) | ( ruleParenthesizedExpression ) ) + int alt23=3; switch ( input.LA(1) ) { case False: case True: @@ -10786,36 +11423,36 @@ public final void rule__PrimaryExpression__Alternatives() throws RecognitionExce case RULE_INTEGER_LIT: case RULE_STRING: { - alt20=1; + alt23=1; } break; case RULE_ID: { - alt20=2; + alt23=2; } break; case LeftParenthesis: { - alt20=3; + alt23=3; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 20, 0, input); + new NoViableAltException("", 23, 0, input); throw nvae; } - switch (alt20) { + switch (alt23) { case 1 : - // InternalBehaviorAnnexParser.g:3089:2: ( ruleValueConstant ) + // InternalBehaviorAnnexParser.g:3265:2: ( ruleValueConstant ) { - // InternalBehaviorAnnexParser.g:3089:2: ( ruleValueConstant ) - // InternalBehaviorAnnexParser.g:3090:3: ruleValueConstant + // InternalBehaviorAnnexParser.g:3265:2: ( ruleValueConstant ) + // InternalBehaviorAnnexParser.g:3266:3: ruleValueConstant { if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getValueConstantParserRuleCall_0()); + before(grammarAccess.getValueAccess().getValueConstantParserRuleCall_0()); } pushFollow(FollowSets000.FOLLOW_2); ruleValueConstant(); @@ -10823,7 +11460,7 @@ public final void rule__PrimaryExpression__Alternatives() throws RecognitionExce state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getValueConstantParserRuleCall_0()); + after(grammarAccess.getValueAccess().getValueConstantParserRuleCall_0()); } } @@ -10832,13 +11469,13 @@ public final void rule__PrimaryExpression__Alternatives() throws RecognitionExce } break; case 2 : - // InternalBehaviorAnnexParser.g:3095:2: ( ruleReferenceExpression ) + // InternalBehaviorAnnexParser.g:3271:2: ( ruleReferenceExpression ) { - // InternalBehaviorAnnexParser.g:3095:2: ( ruleReferenceExpression ) - // InternalBehaviorAnnexParser.g:3096:3: ruleReferenceExpression + // InternalBehaviorAnnexParser.g:3271:2: ( ruleReferenceExpression ) + // InternalBehaviorAnnexParser.g:3272:3: ruleReferenceExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getReferenceExpressionParserRuleCall_1()); + before(grammarAccess.getValueAccess().getReferenceExpressionParserRuleCall_1()); } pushFollow(FollowSets000.FOLLOW_2); ruleReferenceExpression(); @@ -10846,7 +11483,7 @@ public final void rule__PrimaryExpression__Alternatives() throws RecognitionExce state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getReferenceExpressionParserRuleCall_1()); + after(grammarAccess.getValueAccess().getReferenceExpressionParserRuleCall_1()); } } @@ -10855,27 +11492,21 @@ public final void rule__PrimaryExpression__Alternatives() throws RecognitionExce } break; case 3 : - // InternalBehaviorAnnexParser.g:3101:2: ( ( rule__PrimaryExpression__Group_2__0 ) ) + // InternalBehaviorAnnexParser.g:3277:2: ( ruleParenthesizedExpression ) { - // InternalBehaviorAnnexParser.g:3101:2: ( ( rule__PrimaryExpression__Group_2__0 ) ) - // InternalBehaviorAnnexParser.g:3102:3: ( rule__PrimaryExpression__Group_2__0 ) + // InternalBehaviorAnnexParser.g:3277:2: ( ruleParenthesizedExpression ) + // InternalBehaviorAnnexParser.g:3278:3: ruleParenthesizedExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getGroup_2()); + before(grammarAccess.getValueAccess().getParenthesizedExpressionParserRuleCall_2()); } - // InternalBehaviorAnnexParser.g:3103:3: ( rule__PrimaryExpression__Group_2__0 ) - // InternalBehaviorAnnexParser.g:3103:4: rule__PrimaryExpression__Group_2__0 - { pushFollow(FollowSets000.FOLLOW_2); - rule__PrimaryExpression__Group_2__0(); + ruleParenthesizedExpression(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getGroup_2()); + after(grammarAccess.getValueAccess().getParenthesizedExpressionParserRuleCall_2()); } } @@ -10897,59 +11528,59 @@ public final void rule__PrimaryExpression__Alternatives() throws RecognitionExce } return ; } - // $ANTLR end "rule__PrimaryExpression__Alternatives" + // $ANTLR end "rule__Value__Alternatives" // $ANTLR start "rule__ValueConstant__Alternatives" - // InternalBehaviorAnnexParser.g:3111:1: rule__ValueConstant__Alternatives : ( ( ruleBehaviorIntegerLiteral ) | ( ruleBehaviorRealLiteral ) | ( ruleBehaviorStringLiteral ) | ( ruleBehaviorBooleanLiteral ) | ( ruleHashPropertyReference ) ); + // InternalBehaviorAnnexParser.g:3287:1: rule__ValueConstant__Alternatives : ( ( ruleBehaviorIntegerLiteral ) | ( ruleBehaviorRealLiteral ) | ( ruleBehaviorStringLiteral ) | ( ruleBehaviorBooleanLiteral ) | ( ruleHashPropertyReference ) ); public final void rule__ValueConstant__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3115:1: ( ( ruleBehaviorIntegerLiteral ) | ( ruleBehaviorRealLiteral ) | ( ruleBehaviorStringLiteral ) | ( ruleBehaviorBooleanLiteral ) | ( ruleHashPropertyReference ) ) - int alt21=5; + // InternalBehaviorAnnexParser.g:3291:1: ( ( ruleBehaviorIntegerLiteral ) | ( ruleBehaviorRealLiteral ) | ( ruleBehaviorStringLiteral ) | ( ruleBehaviorBooleanLiteral ) | ( ruleHashPropertyReference ) ) + int alt24=5; switch ( input.LA(1) ) { case RULE_INTEGER_LIT: { - alt21=1; + alt24=1; } break; case RULE_REAL_LIT: { - alt21=2; + alt24=2; } break; case RULE_STRING: { - alt21=3; + alt24=3; } break; case False: case True: { - alt21=4; + alt24=4; } break; case NumberSign: { - alt21=5; + alt24=5; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 21, 0, input); + new NoViableAltException("", 24, 0, input); throw nvae; } - switch (alt21) { + switch (alt24) { case 1 : - // InternalBehaviorAnnexParser.g:3116:2: ( ruleBehaviorIntegerLiteral ) + // InternalBehaviorAnnexParser.g:3292:2: ( ruleBehaviorIntegerLiteral ) { - // InternalBehaviorAnnexParser.g:3116:2: ( ruleBehaviorIntegerLiteral ) - // InternalBehaviorAnnexParser.g:3117:3: ruleBehaviorIntegerLiteral + // InternalBehaviorAnnexParser.g:3292:2: ( ruleBehaviorIntegerLiteral ) + // InternalBehaviorAnnexParser.g:3293:3: ruleBehaviorIntegerLiteral { if ( state.backtracking==0 ) { before(grammarAccess.getValueConstantAccess().getBehaviorIntegerLiteralParserRuleCall_0()); @@ -10969,10 +11600,10 @@ public final void rule__ValueConstant__Alternatives() throws RecognitionExceptio } break; case 2 : - // InternalBehaviorAnnexParser.g:3122:2: ( ruleBehaviorRealLiteral ) + // InternalBehaviorAnnexParser.g:3298:2: ( ruleBehaviorRealLiteral ) { - // InternalBehaviorAnnexParser.g:3122:2: ( ruleBehaviorRealLiteral ) - // InternalBehaviorAnnexParser.g:3123:3: ruleBehaviorRealLiteral + // InternalBehaviorAnnexParser.g:3298:2: ( ruleBehaviorRealLiteral ) + // InternalBehaviorAnnexParser.g:3299:3: ruleBehaviorRealLiteral { if ( state.backtracking==0 ) { before(grammarAccess.getValueConstantAccess().getBehaviorRealLiteralParserRuleCall_1()); @@ -10992,10 +11623,10 @@ public final void rule__ValueConstant__Alternatives() throws RecognitionExceptio } break; case 3 : - // InternalBehaviorAnnexParser.g:3128:2: ( ruleBehaviorStringLiteral ) + // InternalBehaviorAnnexParser.g:3304:2: ( ruleBehaviorStringLiteral ) { - // InternalBehaviorAnnexParser.g:3128:2: ( ruleBehaviorStringLiteral ) - // InternalBehaviorAnnexParser.g:3129:3: ruleBehaviorStringLiteral + // InternalBehaviorAnnexParser.g:3304:2: ( ruleBehaviorStringLiteral ) + // InternalBehaviorAnnexParser.g:3305:3: ruleBehaviorStringLiteral { if ( state.backtracking==0 ) { before(grammarAccess.getValueConstantAccess().getBehaviorStringLiteralParserRuleCall_2()); @@ -11015,10 +11646,10 @@ public final void rule__ValueConstant__Alternatives() throws RecognitionExceptio } break; case 4 : - // InternalBehaviorAnnexParser.g:3134:2: ( ruleBehaviorBooleanLiteral ) + // InternalBehaviorAnnexParser.g:3310:2: ( ruleBehaviorBooleanLiteral ) { - // InternalBehaviorAnnexParser.g:3134:2: ( ruleBehaviorBooleanLiteral ) - // InternalBehaviorAnnexParser.g:3135:3: ruleBehaviorBooleanLiteral + // InternalBehaviorAnnexParser.g:3310:2: ( ruleBehaviorBooleanLiteral ) + // InternalBehaviorAnnexParser.g:3311:3: ruleBehaviorBooleanLiteral { if ( state.backtracking==0 ) { before(grammarAccess.getValueConstantAccess().getBehaviorBooleanLiteralParserRuleCall_3()); @@ -11038,10 +11669,10 @@ public final void rule__ValueConstant__Alternatives() throws RecognitionExceptio } break; case 5 : - // InternalBehaviorAnnexParser.g:3140:2: ( ruleHashPropertyReference ) + // InternalBehaviorAnnexParser.g:3316:2: ( ruleHashPropertyReference ) { - // InternalBehaviorAnnexParser.g:3140:2: ( ruleHashPropertyReference ) - // InternalBehaviorAnnexParser.g:3141:3: ruleHashPropertyReference + // InternalBehaviorAnnexParser.g:3316:2: ( ruleHashPropertyReference ) + // InternalBehaviorAnnexParser.g:3317:3: ruleHashPropertyReference { if ( state.backtracking==0 ) { before(grammarAccess.getValueConstantAccess().getHashPropertyReferenceParserRuleCall_4()); @@ -11078,41 +11709,41 @@ public final void rule__ValueConstant__Alternatives() throws RecognitionExceptio // $ANTLR start "rule__BehaviorBooleanLiteral__Alternatives_1" - // InternalBehaviorAnnexParser.g:3150:1: rule__BehaviorBooleanLiteral__Alternatives_1 : ( ( ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) ) | ( False ) ); + // InternalBehaviorAnnexParser.g:3326:1: rule__BehaviorBooleanLiteral__Alternatives_1 : ( ( ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) ) | ( False ) ); public final void rule__BehaviorBooleanLiteral__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3154:1: ( ( ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) ) | ( False ) ) - int alt22=2; - int LA22_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3330:1: ( ( ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) ) | ( False ) ) + int alt25=2; + int LA25_0 = input.LA(1); - if ( (LA22_0==True) ) { - alt22=1; + if ( (LA25_0==True) ) { + alt25=1; } - else if ( (LA22_0==False) ) { - alt22=2; + else if ( (LA25_0==False) ) { + alt25=2; } else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 22, 0, input); + new NoViableAltException("", 25, 0, input); throw nvae; } - switch (alt22) { + switch (alt25) { case 1 : - // InternalBehaviorAnnexParser.g:3155:2: ( ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:3331:2: ( ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) ) { - // InternalBehaviorAnnexParser.g:3155:2: ( ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) ) - // InternalBehaviorAnnexParser.g:3156:3: ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:3331:2: ( ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:3332:3: ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getValueAssignment_1_0()); } - // InternalBehaviorAnnexParser.g:3157:3: ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) - // InternalBehaviorAnnexParser.g:3157:4: rule__BehaviorBooleanLiteral__ValueAssignment_1_0 + // InternalBehaviorAnnexParser.g:3333:3: ( rule__BehaviorBooleanLiteral__ValueAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:3333:4: rule__BehaviorBooleanLiteral__ValueAssignment_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorBooleanLiteral__ValueAssignment_1_0(); @@ -11132,10 +11763,10 @@ else if ( (LA22_0==False) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3161:2: ( False ) + // InternalBehaviorAnnexParser.g:3337:2: ( False ) { - // InternalBehaviorAnnexParser.g:3161:2: ( False ) - // InternalBehaviorAnnexParser.g:3162:3: False + // InternalBehaviorAnnexParser.g:3337:2: ( False ) + // InternalBehaviorAnnexParser.g:3338:3: False { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getFalseKeyword_1_1()); @@ -11168,50 +11799,50 @@ else if ( (LA22_0==False) ) { // $ANTLR start "rule__ReferenceExpression__Alternatives_1" - // InternalBehaviorAnnexParser.g:3171:1: rule__ReferenceExpression__Alternatives_1 : ( ( ( rule__ReferenceExpression__PropertyAssignment_1_0 ) ) | ( ( rule__ReferenceExpression__DequeueAssignment_1_1 ) ) | ( ( rule__ReferenceExpression__Group_1_2__0 ) ) ); + // InternalBehaviorAnnexParser.g:3347:1: rule__ReferenceExpression__Alternatives_1 : ( ( ( rule__ReferenceExpression__PropertyAssignment_1_0 ) ) | ( ( rule__ReferenceExpression__DequeueAssignment_1_1 ) ) | ( ( rule__ReferenceExpression__Group_1_2__0 ) ) ); public final void rule__ReferenceExpression__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3175:1: ( ( ( rule__ReferenceExpression__PropertyAssignment_1_0 ) ) | ( ( rule__ReferenceExpression__DequeueAssignment_1_1 ) ) | ( ( rule__ReferenceExpression__Group_1_2__0 ) ) ) - int alt23=3; + // InternalBehaviorAnnexParser.g:3351:1: ( ( ( rule__ReferenceExpression__PropertyAssignment_1_0 ) ) | ( ( rule__ReferenceExpression__DequeueAssignment_1_1 ) ) | ( ( rule__ReferenceExpression__Group_1_2__0 ) ) ) + int alt26=3; switch ( input.LA(1) ) { case NumberSign: { - alt23=1; + alt26=1; } break; case QuestionMark: { - alt23=2; + alt26=2; } break; case Apostrophe: { - alt23=3; + alt26=3; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 23, 0, input); + new NoViableAltException("", 26, 0, input); throw nvae; } - switch (alt23) { + switch (alt26) { case 1 : - // InternalBehaviorAnnexParser.g:3176:2: ( ( rule__ReferenceExpression__PropertyAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:3352:2: ( ( rule__ReferenceExpression__PropertyAssignment_1_0 ) ) { - // InternalBehaviorAnnexParser.g:3176:2: ( ( rule__ReferenceExpression__PropertyAssignment_1_0 ) ) - // InternalBehaviorAnnexParser.g:3177:3: ( rule__ReferenceExpression__PropertyAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:3352:2: ( ( rule__ReferenceExpression__PropertyAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:3353:3: ( rule__ReferenceExpression__PropertyAssignment_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getPropertyAssignment_1_0()); } - // InternalBehaviorAnnexParser.g:3178:3: ( rule__ReferenceExpression__PropertyAssignment_1_0 ) - // InternalBehaviorAnnexParser.g:3178:4: rule__ReferenceExpression__PropertyAssignment_1_0 + // InternalBehaviorAnnexParser.g:3354:3: ( rule__ReferenceExpression__PropertyAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:3354:4: rule__ReferenceExpression__PropertyAssignment_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__PropertyAssignment_1_0(); @@ -11231,16 +11862,16 @@ public final void rule__ReferenceExpression__Alternatives_1() throws Recognition } break; case 2 : - // InternalBehaviorAnnexParser.g:3182:2: ( ( rule__ReferenceExpression__DequeueAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:3358:2: ( ( rule__ReferenceExpression__DequeueAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:3182:2: ( ( rule__ReferenceExpression__DequeueAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:3183:3: ( rule__ReferenceExpression__DequeueAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:3358:2: ( ( rule__ReferenceExpression__DequeueAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:3359:3: ( rule__ReferenceExpression__DequeueAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getDequeueAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:3184:3: ( rule__ReferenceExpression__DequeueAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:3184:4: rule__ReferenceExpression__DequeueAssignment_1_1 + // InternalBehaviorAnnexParser.g:3360:3: ( rule__ReferenceExpression__DequeueAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:3360:4: rule__ReferenceExpression__DequeueAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__DequeueAssignment_1_1(); @@ -11260,16 +11891,16 @@ public final void rule__ReferenceExpression__Alternatives_1() throws Recognition } break; case 3 : - // InternalBehaviorAnnexParser.g:3188:2: ( ( rule__ReferenceExpression__Group_1_2__0 ) ) + // InternalBehaviorAnnexParser.g:3364:2: ( ( rule__ReferenceExpression__Group_1_2__0 ) ) { - // InternalBehaviorAnnexParser.g:3188:2: ( ( rule__ReferenceExpression__Group_1_2__0 ) ) - // InternalBehaviorAnnexParser.g:3189:3: ( rule__ReferenceExpression__Group_1_2__0 ) + // InternalBehaviorAnnexParser.g:3364:2: ( ( rule__ReferenceExpression__Group_1_2__0 ) ) + // InternalBehaviorAnnexParser.g:3365:3: ( rule__ReferenceExpression__Group_1_2__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getGroup_1_2()); } - // InternalBehaviorAnnexParser.g:3190:3: ( rule__ReferenceExpression__Group_1_2__0 ) - // InternalBehaviorAnnexParser.g:3190:4: rule__ReferenceExpression__Group_1_2__0 + // InternalBehaviorAnnexParser.g:3366:3: ( rule__ReferenceExpression__Group_1_2__0 ) + // InternalBehaviorAnnexParser.g:3366:4: rule__ReferenceExpression__Group_1_2__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__Group_1_2__0(); @@ -11306,50 +11937,50 @@ public final void rule__ReferenceExpression__Alternatives_1() throws Recognition // $ANTLR start "rule__ReferenceExpression__Alternatives_1_2_1" - // InternalBehaviorAnnexParser.g:3198:1: rule__ReferenceExpression__Alternatives_1_2_1 : ( ( ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) ) | ( ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) ) | ( ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) ) ); + // InternalBehaviorAnnexParser.g:3374:1: rule__ReferenceExpression__Alternatives_1_2_1 : ( ( ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) ) | ( ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) ) | ( ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) ) ); public final void rule__ReferenceExpression__Alternatives_1_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3202:1: ( ( ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) ) | ( ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) ) | ( ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) ) ) - int alt24=3; + // InternalBehaviorAnnexParser.g:3378:1: ( ( ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) ) | ( ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) ) | ( ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) ) ) + int alt27=3; switch ( input.LA(1) ) { case Count: { - alt24=1; + alt27=1; } break; case Fresh: { - alt24=2; + alt27=2; } break; case Updated: { - alt24=3; + alt27=3; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 24, 0, input); + new NoViableAltException("", 27, 0, input); throw nvae; } - switch (alt24) { + switch (alt27) { case 1 : - // InternalBehaviorAnnexParser.g:3203:2: ( ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) ) + // InternalBehaviorAnnexParser.g:3379:2: ( ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) ) { - // InternalBehaviorAnnexParser.g:3203:2: ( ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) ) - // InternalBehaviorAnnexParser.g:3204:3: ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) + // InternalBehaviorAnnexParser.g:3379:2: ( ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) ) + // InternalBehaviorAnnexParser.g:3380:3: ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getCountAssignment_1_2_1_0()); } - // InternalBehaviorAnnexParser.g:3205:3: ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) - // InternalBehaviorAnnexParser.g:3205:4: rule__ReferenceExpression__CountAssignment_1_2_1_0 + // InternalBehaviorAnnexParser.g:3381:3: ( rule__ReferenceExpression__CountAssignment_1_2_1_0 ) + // InternalBehaviorAnnexParser.g:3381:4: rule__ReferenceExpression__CountAssignment_1_2_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__CountAssignment_1_2_1_0(); @@ -11369,16 +12000,16 @@ public final void rule__ReferenceExpression__Alternatives_1_2_1() throws Recogni } break; case 2 : - // InternalBehaviorAnnexParser.g:3209:2: ( ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) ) + // InternalBehaviorAnnexParser.g:3385:2: ( ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) ) { - // InternalBehaviorAnnexParser.g:3209:2: ( ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) ) - // InternalBehaviorAnnexParser.g:3210:3: ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) + // InternalBehaviorAnnexParser.g:3385:2: ( ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) ) + // InternalBehaviorAnnexParser.g:3386:3: ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getFreshAssignment_1_2_1_1()); } - // InternalBehaviorAnnexParser.g:3211:3: ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) - // InternalBehaviorAnnexParser.g:3211:4: rule__ReferenceExpression__FreshAssignment_1_2_1_1 + // InternalBehaviorAnnexParser.g:3387:3: ( rule__ReferenceExpression__FreshAssignment_1_2_1_1 ) + // InternalBehaviorAnnexParser.g:3387:4: rule__ReferenceExpression__FreshAssignment_1_2_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__FreshAssignment_1_2_1_1(); @@ -11398,16 +12029,16 @@ public final void rule__ReferenceExpression__Alternatives_1_2_1() throws Recogni } break; case 3 : - // InternalBehaviorAnnexParser.g:3215:2: ( ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) ) + // InternalBehaviorAnnexParser.g:3391:2: ( ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) ) { - // InternalBehaviorAnnexParser.g:3215:2: ( ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) ) - // InternalBehaviorAnnexParser.g:3216:3: ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) + // InternalBehaviorAnnexParser.g:3391:2: ( ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) ) + // InternalBehaviorAnnexParser.g:3392:3: ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getUpdatedAssignment_1_2_1_2()); } - // InternalBehaviorAnnexParser.g:3217:3: ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) - // InternalBehaviorAnnexParser.g:3217:4: rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 + // InternalBehaviorAnnexParser.g:3393:3: ( rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 ) + // InternalBehaviorAnnexParser.g:3393:4: rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__UpdatedAssignment_1_2_1_2(); @@ -11444,44 +12075,44 @@ public final void rule__ReferenceExpression__Alternatives_1_2_1() throws Recogni // $ANTLR start "rule__PropertyIndexValue__Alternatives" - // InternalBehaviorAnnexParser.g:3225:1: rule__PropertyIndexValue__Alternatives : ( ( ruleBehaviorIntegerLiteral ) | ( rulePropertyIndexPropertyReference ) | ( ruleUnindexedReferenceExpression ) ); + // InternalBehaviorAnnexParser.g:3401:1: rule__PropertyIndexValue__Alternatives : ( ( ruleBehaviorIntegerLiteral ) | ( rulePropertyIndexPropertyReference ) | ( ruleUnindexedReferenceExpression ) ); public final void rule__PropertyIndexValue__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3229:1: ( ( ruleBehaviorIntegerLiteral ) | ( rulePropertyIndexPropertyReference ) | ( ruleUnindexedReferenceExpression ) ) - int alt25=3; + // InternalBehaviorAnnexParser.g:3405:1: ( ( ruleBehaviorIntegerLiteral ) | ( rulePropertyIndexPropertyReference ) | ( ruleUnindexedReferenceExpression ) ) + int alt28=3; switch ( input.LA(1) ) { case RULE_INTEGER_LIT: { - alt25=1; + alt28=1; } break; case NumberSign: { - alt25=2; + alt28=2; } break; case RULE_ID: { - alt25=3; + alt28=3; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 25, 0, input); + new NoViableAltException("", 28, 0, input); throw nvae; } - switch (alt25) { + switch (alt28) { case 1 : - // InternalBehaviorAnnexParser.g:3230:2: ( ruleBehaviorIntegerLiteral ) + // InternalBehaviorAnnexParser.g:3406:2: ( ruleBehaviorIntegerLiteral ) { - // InternalBehaviorAnnexParser.g:3230:2: ( ruleBehaviorIntegerLiteral ) - // InternalBehaviorAnnexParser.g:3231:3: ruleBehaviorIntegerLiteral + // InternalBehaviorAnnexParser.g:3406:2: ( ruleBehaviorIntegerLiteral ) + // InternalBehaviorAnnexParser.g:3407:3: ruleBehaviorIntegerLiteral { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexValueAccess().getBehaviorIntegerLiteralParserRuleCall_0()); @@ -11501,10 +12132,10 @@ public final void rule__PropertyIndexValue__Alternatives() throws RecognitionExc } break; case 2 : - // InternalBehaviorAnnexParser.g:3236:2: ( rulePropertyIndexPropertyReference ) + // InternalBehaviorAnnexParser.g:3412:2: ( rulePropertyIndexPropertyReference ) { - // InternalBehaviorAnnexParser.g:3236:2: ( rulePropertyIndexPropertyReference ) - // InternalBehaviorAnnexParser.g:3237:3: rulePropertyIndexPropertyReference + // InternalBehaviorAnnexParser.g:3412:2: ( rulePropertyIndexPropertyReference ) + // InternalBehaviorAnnexParser.g:3413:3: rulePropertyIndexPropertyReference { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexValueAccess().getPropertyIndexPropertyReferenceParserRuleCall_1()); @@ -11524,10 +12155,10 @@ public final void rule__PropertyIndexValue__Alternatives() throws RecognitionExc } break; case 3 : - // InternalBehaviorAnnexParser.g:3242:2: ( ruleUnindexedReferenceExpression ) + // InternalBehaviorAnnexParser.g:3418:2: ( ruleUnindexedReferenceExpression ) { - // InternalBehaviorAnnexParser.g:3242:2: ( ruleUnindexedReferenceExpression ) - // InternalBehaviorAnnexParser.g:3243:3: ruleUnindexedReferenceExpression + // InternalBehaviorAnnexParser.g:3418:2: ( ruleUnindexedReferenceExpression ) + // InternalBehaviorAnnexParser.g:3419:3: ruleUnindexedReferenceExpression { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexValueAccess().getUnindexedReferenceExpressionParserRuleCall_2()); @@ -11564,41 +12195,41 @@ public final void rule__PropertyIndexValue__Alternatives() throws RecognitionExc // $ANTLR start "rule__UnindexedReferenceExpression__Alternatives_1" - // InternalBehaviorAnnexParser.g:3252:1: rule__UnindexedReferenceExpression__Alternatives_1 : ( ( ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) ) | ( ( rule__UnindexedReferenceExpression__Group_1_1__0 ) ) ); + // InternalBehaviorAnnexParser.g:3428:1: rule__UnindexedReferenceExpression__Alternatives_1 : ( ( ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) ) | ( ( rule__UnindexedReferenceExpression__Group_1_1__0 ) ) ); public final void rule__UnindexedReferenceExpression__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3256:1: ( ( ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) ) | ( ( rule__UnindexedReferenceExpression__Group_1_1__0 ) ) ) - int alt26=2; - int LA26_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3432:1: ( ( ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) ) | ( ( rule__UnindexedReferenceExpression__Group_1_1__0 ) ) ) + int alt29=2; + int LA29_0 = input.LA(1); - if ( (LA26_0==QuestionMark) ) { - alt26=1; + if ( (LA29_0==QuestionMark) ) { + alt29=1; } - else if ( (LA26_0==Apostrophe) ) { - alt26=2; + else if ( (LA29_0==Apostrophe) ) { + alt29=2; } else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 26, 0, input); + new NoViableAltException("", 29, 0, input); throw nvae; } - switch (alt26) { + switch (alt29) { case 1 : - // InternalBehaviorAnnexParser.g:3257:2: ( ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:3433:2: ( ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) ) { - // InternalBehaviorAnnexParser.g:3257:2: ( ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) ) - // InternalBehaviorAnnexParser.g:3258:3: ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:3433:2: ( ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:3434:3: ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getDequeueAssignment_1_0()); } - // InternalBehaviorAnnexParser.g:3259:3: ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) - // InternalBehaviorAnnexParser.g:3259:4: rule__UnindexedReferenceExpression__DequeueAssignment_1_0 + // InternalBehaviorAnnexParser.g:3435:3: ( rule__UnindexedReferenceExpression__DequeueAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:3435:4: rule__UnindexedReferenceExpression__DequeueAssignment_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__DequeueAssignment_1_0(); @@ -11618,16 +12249,16 @@ else if ( (LA26_0==Apostrophe) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3263:2: ( ( rule__UnindexedReferenceExpression__Group_1_1__0 ) ) + // InternalBehaviorAnnexParser.g:3439:2: ( ( rule__UnindexedReferenceExpression__Group_1_1__0 ) ) { - // InternalBehaviorAnnexParser.g:3263:2: ( ( rule__UnindexedReferenceExpression__Group_1_1__0 ) ) - // InternalBehaviorAnnexParser.g:3264:3: ( rule__UnindexedReferenceExpression__Group_1_1__0 ) + // InternalBehaviorAnnexParser.g:3439:2: ( ( rule__UnindexedReferenceExpression__Group_1_1__0 ) ) + // InternalBehaviorAnnexParser.g:3440:3: ( rule__UnindexedReferenceExpression__Group_1_1__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getGroup_1_1()); } - // InternalBehaviorAnnexParser.g:3265:3: ( rule__UnindexedReferenceExpression__Group_1_1__0 ) - // InternalBehaviorAnnexParser.g:3265:4: rule__UnindexedReferenceExpression__Group_1_1__0 + // InternalBehaviorAnnexParser.g:3441:3: ( rule__UnindexedReferenceExpression__Group_1_1__0 ) + // InternalBehaviorAnnexParser.g:3441:4: rule__UnindexedReferenceExpression__Group_1_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__Group_1_1__0(); @@ -11664,50 +12295,50 @@ else if ( (LA26_0==Apostrophe) ) { // $ANTLR start "rule__UnindexedReferenceExpression__Alternatives_1_1_1" - // InternalBehaviorAnnexParser.g:3273:1: rule__UnindexedReferenceExpression__Alternatives_1_1_1 : ( ( ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) ) | ( ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) ) | ( ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) ) ); + // InternalBehaviorAnnexParser.g:3449:1: rule__UnindexedReferenceExpression__Alternatives_1_1_1 : ( ( ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) ) | ( ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) ) | ( ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) ) ); public final void rule__UnindexedReferenceExpression__Alternatives_1_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3277:1: ( ( ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) ) | ( ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) ) | ( ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) ) ) - int alt27=3; + // InternalBehaviorAnnexParser.g:3453:1: ( ( ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) ) | ( ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) ) | ( ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) ) ) + int alt30=3; switch ( input.LA(1) ) { case Count: { - alt27=1; + alt30=1; } break; case Fresh: { - alt27=2; + alt30=2; } break; case Updated: { - alt27=3; + alt30=3; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 27, 0, input); + new NoViableAltException("", 30, 0, input); throw nvae; } - switch (alt27) { + switch (alt30) { case 1 : - // InternalBehaviorAnnexParser.g:3278:2: ( ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) ) + // InternalBehaviorAnnexParser.g:3454:2: ( ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) ) { - // InternalBehaviorAnnexParser.g:3278:2: ( ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) ) - // InternalBehaviorAnnexParser.g:3279:3: ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) + // InternalBehaviorAnnexParser.g:3454:2: ( ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) ) + // InternalBehaviorAnnexParser.g:3455:3: ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getCountAssignment_1_1_1_0()); } - // InternalBehaviorAnnexParser.g:3280:3: ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) - // InternalBehaviorAnnexParser.g:3280:4: rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 + // InternalBehaviorAnnexParser.g:3456:3: ( rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 ) + // InternalBehaviorAnnexParser.g:3456:4: rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0(); @@ -11727,16 +12358,16 @@ public final void rule__UnindexedReferenceExpression__Alternatives_1_1_1() throw } break; case 2 : - // InternalBehaviorAnnexParser.g:3284:2: ( ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:3460:2: ( ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) ) { - // InternalBehaviorAnnexParser.g:3284:2: ( ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) ) - // InternalBehaviorAnnexParser.g:3285:3: ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) + // InternalBehaviorAnnexParser.g:3460:2: ( ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:3461:3: ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getFreshAssignment_1_1_1_1()); } - // InternalBehaviorAnnexParser.g:3286:3: ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) - // InternalBehaviorAnnexParser.g:3286:4: rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 + // InternalBehaviorAnnexParser.g:3462:3: ( rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 ) + // InternalBehaviorAnnexParser.g:3462:4: rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1(); @@ -11756,16 +12387,16 @@ public final void rule__UnindexedReferenceExpression__Alternatives_1_1_1() throw } break; case 3 : - // InternalBehaviorAnnexParser.g:3290:2: ( ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) ) + // InternalBehaviorAnnexParser.g:3466:2: ( ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) ) { - // InternalBehaviorAnnexParser.g:3290:2: ( ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) ) - // InternalBehaviorAnnexParser.g:3291:3: ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) + // InternalBehaviorAnnexParser.g:3466:2: ( ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) ) + // InternalBehaviorAnnexParser.g:3467:3: ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getUpdatedAssignment_1_1_1_2()); } - // InternalBehaviorAnnexParser.g:3292:3: ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) - // InternalBehaviorAnnexParser.g:3292:4: rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 + // InternalBehaviorAnnexParser.g:3468:3: ( rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 ) + // InternalBehaviorAnnexParser.g:3468:4: rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2(); @@ -11802,35 +12433,35 @@ public final void rule__UnindexedReferenceExpression__Alternatives_1_1_1() throw // $ANTLR start "rule__ReferenceSeparator__Alternatives" - // InternalBehaviorAnnexParser.g:3300:1: rule__ReferenceSeparator__Alternatives : ( ( ColonColon ) | ( FullStop ) ); + // InternalBehaviorAnnexParser.g:3476:1: rule__ReferenceSeparator__Alternatives : ( ( ColonColon ) | ( FullStop ) ); public final void rule__ReferenceSeparator__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3304:1: ( ( ColonColon ) | ( FullStop ) ) - int alt28=2; - int LA28_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3480:1: ( ( ColonColon ) | ( FullStop ) ) + int alt31=2; + int LA31_0 = input.LA(1); - if ( (LA28_0==ColonColon) ) { - alt28=1; + if ( (LA31_0==ColonColon) ) { + alt31=1; } - else if ( (LA28_0==FullStop) ) { - alt28=2; + else if ( (LA31_0==FullStop) ) { + alt31=2; } else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 28, 0, input); + new NoViableAltException("", 31, 0, input); throw nvae; } - switch (alt28) { + switch (alt31) { case 1 : - // InternalBehaviorAnnexParser.g:3305:2: ( ColonColon ) + // InternalBehaviorAnnexParser.g:3481:2: ( ColonColon ) { - // InternalBehaviorAnnexParser.g:3305:2: ( ColonColon ) - // InternalBehaviorAnnexParser.g:3306:3: ColonColon + // InternalBehaviorAnnexParser.g:3481:2: ( ColonColon ) + // InternalBehaviorAnnexParser.g:3482:3: ColonColon { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSeparatorAccess().getColonColonKeyword_0()); @@ -11846,10 +12477,10 @@ else if ( (LA28_0==FullStop) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3311:2: ( FullStop ) + // InternalBehaviorAnnexParser.g:3487:2: ( FullStop ) { - // InternalBehaviorAnnexParser.g:3311:2: ( FullStop ) - // InternalBehaviorAnnexParser.g:3312:3: FullStop + // InternalBehaviorAnnexParser.g:3487:2: ( FullStop ) + // InternalBehaviorAnnexParser.g:3488:3: FullStop { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSeparatorAccess().getFullStopKeyword_1()); @@ -11882,35 +12513,35 @@ else if ( (LA28_0==FullStop) ) { // $ANTLR start "rule__ContainedPropertyAssociation__Alternatives_1" - // InternalBehaviorAnnexParser.g:3321:1: rule__ContainedPropertyAssociation__Alternatives_1 : ( ( EqualsSignGreaterThanSign ) | ( ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) ) ); + // InternalBehaviorAnnexParser.g:3497:1: rule__ContainedPropertyAssociation__Alternatives_1 : ( ( EqualsSignGreaterThanSign ) | ( ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) ) ); public final void rule__ContainedPropertyAssociation__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3325:1: ( ( EqualsSignGreaterThanSign ) | ( ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) ) ) - int alt29=2; - int LA29_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3501:1: ( ( EqualsSignGreaterThanSign ) | ( ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) ) ) + int alt32=2; + int LA32_0 = input.LA(1); - if ( (LA29_0==EqualsSignGreaterThanSign) ) { - alt29=1; + if ( (LA32_0==EqualsSignGreaterThanSign) ) { + alt32=1; } - else if ( (LA29_0==PlusSignEqualsSignGreaterThanSign) ) { - alt29=2; + else if ( (LA32_0==PlusSignEqualsSignGreaterThanSign) ) { + alt32=2; } else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 29, 0, input); + new NoViableAltException("", 32, 0, input); throw nvae; } - switch (alt29) { + switch (alt32) { case 1 : - // InternalBehaviorAnnexParser.g:3326:2: ( EqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:3502:2: ( EqualsSignGreaterThanSign ) { - // InternalBehaviorAnnexParser.g:3326:2: ( EqualsSignGreaterThanSign ) - // InternalBehaviorAnnexParser.g:3327:3: EqualsSignGreaterThanSign + // InternalBehaviorAnnexParser.g:3502:2: ( EqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:3503:3: EqualsSignGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getEqualsSignGreaterThanSignKeyword_1_0()); @@ -11926,16 +12557,16 @@ else if ( (LA29_0==PlusSignEqualsSignGreaterThanSign) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3332:2: ( ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:3508:2: ( ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:3332:2: ( ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:3333:3: ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:3508:2: ( ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:3509:3: ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppendAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:3334:3: ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:3334:4: rule__ContainedPropertyAssociation__AppendAssignment_1_1 + // InternalBehaviorAnnexParser.g:3510:3: ( rule__ContainedPropertyAssociation__AppendAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:3510:4: rule__ContainedPropertyAssociation__AppendAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__AppendAssignment_1_1(); @@ -11972,21 +12603,21 @@ else if ( (LA29_0==PlusSignEqualsSignGreaterThanSign) ) { // $ANTLR start "rule__PropertyExpression__Alternatives" - // InternalBehaviorAnnexParser.g:3342:1: rule__PropertyExpression__Alternatives : ( ( ruleRecordTerm ) | ( ruleReferenceTerm ) | ( ruleComponentClassifierTerm ) | ( ruleComputedTerm ) | ( ruleStringTerm ) | ( ruleNumericRangeTerm ) | ( ruleRealTerm ) | ( ruleIntegerTerm ) | ( ruleListTerm ) | ( ruleBooleanLiteral ) | ( ruleLiteralorReferenceTerm ) ); + // InternalBehaviorAnnexParser.g:3518:1: rule__PropertyExpression__Alternatives : ( ( ruleRecordTerm ) | ( ruleReferenceTerm ) | ( ruleComponentClassifierTerm ) | ( ruleComputedTerm ) | ( ruleStringTerm ) | ( ruleNumericRangeTerm ) | ( ruleRealTerm ) | ( ruleIntegerTerm ) | ( ruleListTerm ) | ( ruleBooleanLiteral ) | ( ruleLiteralorReferenceTerm ) ); public final void rule__PropertyExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3346:1: ( ( ruleRecordTerm ) | ( ruleReferenceTerm ) | ( ruleComponentClassifierTerm ) | ( ruleComputedTerm ) | ( ruleStringTerm ) | ( ruleNumericRangeTerm ) | ( ruleRealTerm ) | ( ruleIntegerTerm ) | ( ruleListTerm ) | ( ruleBooleanLiteral ) | ( ruleLiteralorReferenceTerm ) ) - int alt30=11; - alt30 = dfa30.predict(input); - switch (alt30) { + // InternalBehaviorAnnexParser.g:3522:1: ( ( ruleRecordTerm ) | ( ruleReferenceTerm ) | ( ruleComponentClassifierTerm ) | ( ruleComputedTerm ) | ( ruleStringTerm ) | ( ruleNumericRangeTerm ) | ( ruleRealTerm ) | ( ruleIntegerTerm ) | ( ruleListTerm ) | ( ruleBooleanLiteral ) | ( ruleLiteralorReferenceTerm ) ) + int alt33=11; + alt33 = dfa33.predict(input); + switch (alt33) { case 1 : - // InternalBehaviorAnnexParser.g:3347:2: ( ruleRecordTerm ) + // InternalBehaviorAnnexParser.g:3523:2: ( ruleRecordTerm ) { - // InternalBehaviorAnnexParser.g:3347:2: ( ruleRecordTerm ) - // InternalBehaviorAnnexParser.g:3348:3: ruleRecordTerm + // InternalBehaviorAnnexParser.g:3523:2: ( ruleRecordTerm ) + // InternalBehaviorAnnexParser.g:3524:3: ruleRecordTerm { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getRecordTermParserRuleCall_0()); @@ -12006,10 +12637,10 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc } break; case 2 : - // InternalBehaviorAnnexParser.g:3353:2: ( ruleReferenceTerm ) + // InternalBehaviorAnnexParser.g:3529:2: ( ruleReferenceTerm ) { - // InternalBehaviorAnnexParser.g:3353:2: ( ruleReferenceTerm ) - // InternalBehaviorAnnexParser.g:3354:3: ruleReferenceTerm + // InternalBehaviorAnnexParser.g:3529:2: ( ruleReferenceTerm ) + // InternalBehaviorAnnexParser.g:3530:3: ruleReferenceTerm { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getReferenceTermParserRuleCall_1()); @@ -12029,10 +12660,10 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc } break; case 3 : - // InternalBehaviorAnnexParser.g:3359:2: ( ruleComponentClassifierTerm ) + // InternalBehaviorAnnexParser.g:3535:2: ( ruleComponentClassifierTerm ) { - // InternalBehaviorAnnexParser.g:3359:2: ( ruleComponentClassifierTerm ) - // InternalBehaviorAnnexParser.g:3360:3: ruleComponentClassifierTerm + // InternalBehaviorAnnexParser.g:3535:2: ( ruleComponentClassifierTerm ) + // InternalBehaviorAnnexParser.g:3536:3: ruleComponentClassifierTerm { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getComponentClassifierTermParserRuleCall_2()); @@ -12052,10 +12683,10 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc } break; case 4 : - // InternalBehaviorAnnexParser.g:3365:2: ( ruleComputedTerm ) + // InternalBehaviorAnnexParser.g:3541:2: ( ruleComputedTerm ) { - // InternalBehaviorAnnexParser.g:3365:2: ( ruleComputedTerm ) - // InternalBehaviorAnnexParser.g:3366:3: ruleComputedTerm + // InternalBehaviorAnnexParser.g:3541:2: ( ruleComputedTerm ) + // InternalBehaviorAnnexParser.g:3542:3: ruleComputedTerm { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getComputedTermParserRuleCall_3()); @@ -12075,10 +12706,10 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc } break; case 5 : - // InternalBehaviorAnnexParser.g:3371:2: ( ruleStringTerm ) + // InternalBehaviorAnnexParser.g:3547:2: ( ruleStringTerm ) { - // InternalBehaviorAnnexParser.g:3371:2: ( ruleStringTerm ) - // InternalBehaviorAnnexParser.g:3372:3: ruleStringTerm + // InternalBehaviorAnnexParser.g:3547:2: ( ruleStringTerm ) + // InternalBehaviorAnnexParser.g:3548:3: ruleStringTerm { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getStringTermParserRuleCall_4()); @@ -12098,10 +12729,10 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc } break; case 6 : - // InternalBehaviorAnnexParser.g:3377:2: ( ruleNumericRangeTerm ) + // InternalBehaviorAnnexParser.g:3553:2: ( ruleNumericRangeTerm ) { - // InternalBehaviorAnnexParser.g:3377:2: ( ruleNumericRangeTerm ) - // InternalBehaviorAnnexParser.g:3378:3: ruleNumericRangeTerm + // InternalBehaviorAnnexParser.g:3553:2: ( ruleNumericRangeTerm ) + // InternalBehaviorAnnexParser.g:3554:3: ruleNumericRangeTerm { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getNumericRangeTermParserRuleCall_5()); @@ -12121,10 +12752,10 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc } break; case 7 : - // InternalBehaviorAnnexParser.g:3383:2: ( ruleRealTerm ) + // InternalBehaviorAnnexParser.g:3559:2: ( ruleRealTerm ) { - // InternalBehaviorAnnexParser.g:3383:2: ( ruleRealTerm ) - // InternalBehaviorAnnexParser.g:3384:3: ruleRealTerm + // InternalBehaviorAnnexParser.g:3559:2: ( ruleRealTerm ) + // InternalBehaviorAnnexParser.g:3560:3: ruleRealTerm { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getRealTermParserRuleCall_6()); @@ -12144,10 +12775,10 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc } break; case 8 : - // InternalBehaviorAnnexParser.g:3389:2: ( ruleIntegerTerm ) + // InternalBehaviorAnnexParser.g:3565:2: ( ruleIntegerTerm ) { - // InternalBehaviorAnnexParser.g:3389:2: ( ruleIntegerTerm ) - // InternalBehaviorAnnexParser.g:3390:3: ruleIntegerTerm + // InternalBehaviorAnnexParser.g:3565:2: ( ruleIntegerTerm ) + // InternalBehaviorAnnexParser.g:3566:3: ruleIntegerTerm { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getIntegerTermParserRuleCall_7()); @@ -12167,10 +12798,10 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc } break; case 9 : - // InternalBehaviorAnnexParser.g:3395:2: ( ruleListTerm ) + // InternalBehaviorAnnexParser.g:3571:2: ( ruleListTerm ) { - // InternalBehaviorAnnexParser.g:3395:2: ( ruleListTerm ) - // InternalBehaviorAnnexParser.g:3396:3: ruleListTerm + // InternalBehaviorAnnexParser.g:3571:2: ( ruleListTerm ) + // InternalBehaviorAnnexParser.g:3572:3: ruleListTerm { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getListTermParserRuleCall_8()); @@ -12190,10 +12821,10 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc } break; case 10 : - // InternalBehaviorAnnexParser.g:3401:2: ( ruleBooleanLiteral ) + // InternalBehaviorAnnexParser.g:3577:2: ( ruleBooleanLiteral ) { - // InternalBehaviorAnnexParser.g:3401:2: ( ruleBooleanLiteral ) - // InternalBehaviorAnnexParser.g:3402:3: ruleBooleanLiteral + // InternalBehaviorAnnexParser.g:3577:2: ( ruleBooleanLiteral ) + // InternalBehaviorAnnexParser.g:3578:3: ruleBooleanLiteral { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getBooleanLiteralParserRuleCall_9()); @@ -12213,10 +12844,10 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc } break; case 11 : - // InternalBehaviorAnnexParser.g:3407:2: ( ruleLiteralorReferenceTerm ) + // InternalBehaviorAnnexParser.g:3583:2: ( ruleLiteralorReferenceTerm ) { - // InternalBehaviorAnnexParser.g:3407:2: ( ruleLiteralorReferenceTerm ) - // InternalBehaviorAnnexParser.g:3408:3: ruleLiteralorReferenceTerm + // InternalBehaviorAnnexParser.g:3583:2: ( ruleLiteralorReferenceTerm ) + // InternalBehaviorAnnexParser.g:3584:3: ruleLiteralorReferenceTerm { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyExpressionAccess().getLiteralorReferenceTermParserRuleCall_10()); @@ -12253,41 +12884,41 @@ public final void rule__PropertyExpression__Alternatives() throws RecognitionExc // $ANTLR start "rule__BooleanLiteral__Alternatives_1" - // InternalBehaviorAnnexParser.g:3417:1: rule__BooleanLiteral__Alternatives_1 : ( ( ( rule__BooleanLiteral__ValueAssignment_1_0 ) ) | ( False ) ); + // InternalBehaviorAnnexParser.g:3593:1: rule__BooleanLiteral__Alternatives_1 : ( ( ( rule__BooleanLiteral__ValueAssignment_1_0 ) ) | ( False ) ); public final void rule__BooleanLiteral__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3421:1: ( ( ( rule__BooleanLiteral__ValueAssignment_1_0 ) ) | ( False ) ) - int alt31=2; - int LA31_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3597:1: ( ( ( rule__BooleanLiteral__ValueAssignment_1_0 ) ) | ( False ) ) + int alt34=2; + int LA34_0 = input.LA(1); - if ( (LA31_0==True) ) { - alt31=1; + if ( (LA34_0==True) ) { + alt34=1; } - else if ( (LA31_0==False) ) { - alt31=2; + else if ( (LA34_0==False) ) { + alt34=2; } else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 31, 0, input); + new NoViableAltException("", 34, 0, input); throw nvae; } - switch (alt31) { + switch (alt34) { case 1 : - // InternalBehaviorAnnexParser.g:3422:2: ( ( rule__BooleanLiteral__ValueAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:3598:2: ( ( rule__BooleanLiteral__ValueAssignment_1_0 ) ) { - // InternalBehaviorAnnexParser.g:3422:2: ( ( rule__BooleanLiteral__ValueAssignment_1_0 ) ) - // InternalBehaviorAnnexParser.g:3423:3: ( rule__BooleanLiteral__ValueAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:3598:2: ( ( rule__BooleanLiteral__ValueAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:3599:3: ( rule__BooleanLiteral__ValueAssignment_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getValueAssignment_1_0()); } - // InternalBehaviorAnnexParser.g:3424:3: ( rule__BooleanLiteral__ValueAssignment_1_0 ) - // InternalBehaviorAnnexParser.g:3424:4: rule__BooleanLiteral__ValueAssignment_1_0 + // InternalBehaviorAnnexParser.g:3600:3: ( rule__BooleanLiteral__ValueAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:3600:4: rule__BooleanLiteral__ValueAssignment_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__BooleanLiteral__ValueAssignment_1_0(); @@ -12307,10 +12938,10 @@ else if ( (LA31_0==False) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3428:2: ( False ) + // InternalBehaviorAnnexParser.g:3604:2: ( False ) { - // InternalBehaviorAnnexParser.g:3428:2: ( False ) - // InternalBehaviorAnnexParser.g:3429:3: False + // InternalBehaviorAnnexParser.g:3604:2: ( False ) + // InternalBehaviorAnnexParser.g:3605:3: False { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_1()); @@ -12343,35 +12974,35 @@ else if ( (LA31_0==False) ) { // $ANTLR start "rule__PlusMinus__Alternatives" - // InternalBehaviorAnnexParser.g:3438:1: rule__PlusMinus__Alternatives : ( ( PlusSign ) | ( HyphenMinus ) ); + // InternalBehaviorAnnexParser.g:3614:1: rule__PlusMinus__Alternatives : ( ( PlusSign ) | ( HyphenMinus ) ); public final void rule__PlusMinus__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3442:1: ( ( PlusSign ) | ( HyphenMinus ) ) - int alt32=2; - int LA32_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3618:1: ( ( PlusSign ) | ( HyphenMinus ) ) + int alt35=2; + int LA35_0 = input.LA(1); - if ( (LA32_0==PlusSign) ) { - alt32=1; + if ( (LA35_0==PlusSign) ) { + alt35=1; } - else if ( (LA32_0==HyphenMinus) ) { - alt32=2; + else if ( (LA35_0==HyphenMinus) ) { + alt35=2; } else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 32, 0, input); + new NoViableAltException("", 35, 0, input); throw nvae; } - switch (alt32) { + switch (alt35) { case 1 : - // InternalBehaviorAnnexParser.g:3443:2: ( PlusSign ) + // InternalBehaviorAnnexParser.g:3619:2: ( PlusSign ) { - // InternalBehaviorAnnexParser.g:3443:2: ( PlusSign ) - // InternalBehaviorAnnexParser.g:3444:3: PlusSign + // InternalBehaviorAnnexParser.g:3619:2: ( PlusSign ) + // InternalBehaviorAnnexParser.g:3620:3: PlusSign { if ( state.backtracking==0 ) { before(grammarAccess.getPlusMinusAccess().getPlusSignKeyword_0()); @@ -12387,10 +13018,10 @@ else if ( (LA32_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3449:2: ( HyphenMinus ) + // InternalBehaviorAnnexParser.g:3625:2: ( HyphenMinus ) { - // InternalBehaviorAnnexParser.g:3449:2: ( HyphenMinus ) - // InternalBehaviorAnnexParser.g:3450:3: HyphenMinus + // InternalBehaviorAnnexParser.g:3625:2: ( HyphenMinus ) + // InternalBehaviorAnnexParser.g:3626:3: HyphenMinus { if ( state.backtracking==0 ) { before(grammarAccess.getPlusMinusAccess().getHyphenMinusKeyword_1()); @@ -12423,35 +13054,35 @@ else if ( (LA32_0==HyphenMinus) ) { // $ANTLR start "rule__SignedInt__Alternatives_0" - // InternalBehaviorAnnexParser.g:3459:1: rule__SignedInt__Alternatives_0 : ( ( PlusSign ) | ( HyphenMinus ) ); + // InternalBehaviorAnnexParser.g:3635:1: rule__SignedInt__Alternatives_0 : ( ( PlusSign ) | ( HyphenMinus ) ); public final void rule__SignedInt__Alternatives_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3463:1: ( ( PlusSign ) | ( HyphenMinus ) ) - int alt33=2; - int LA33_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3639:1: ( ( PlusSign ) | ( HyphenMinus ) ) + int alt36=2; + int LA36_0 = input.LA(1); - if ( (LA33_0==PlusSign) ) { - alt33=1; + if ( (LA36_0==PlusSign) ) { + alt36=1; } - else if ( (LA33_0==HyphenMinus) ) { - alt33=2; + else if ( (LA36_0==HyphenMinus) ) { + alt36=2; } else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 33, 0, input); + new NoViableAltException("", 36, 0, input); throw nvae; } - switch (alt33) { + switch (alt36) { case 1 : - // InternalBehaviorAnnexParser.g:3464:2: ( PlusSign ) + // InternalBehaviorAnnexParser.g:3640:2: ( PlusSign ) { - // InternalBehaviorAnnexParser.g:3464:2: ( PlusSign ) - // InternalBehaviorAnnexParser.g:3465:3: PlusSign + // InternalBehaviorAnnexParser.g:3640:2: ( PlusSign ) + // InternalBehaviorAnnexParser.g:3641:3: PlusSign { if ( state.backtracking==0 ) { before(grammarAccess.getSignedIntAccess().getPlusSignKeyword_0_0()); @@ -12467,10 +13098,10 @@ else if ( (LA33_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3470:2: ( HyphenMinus ) + // InternalBehaviorAnnexParser.g:3646:2: ( HyphenMinus ) { - // InternalBehaviorAnnexParser.g:3470:2: ( HyphenMinus ) - // InternalBehaviorAnnexParser.g:3471:3: HyphenMinus + // InternalBehaviorAnnexParser.g:3646:2: ( HyphenMinus ) + // InternalBehaviorAnnexParser.g:3647:3: HyphenMinus { if ( state.backtracking==0 ) { before(grammarAccess.getSignedIntAccess().getHyphenMinusKeyword_0_1()); @@ -12503,35 +13134,35 @@ else if ( (LA33_0==HyphenMinus) ) { // $ANTLR start "rule__SignedReal__Alternatives_0" - // InternalBehaviorAnnexParser.g:3480:1: rule__SignedReal__Alternatives_0 : ( ( PlusSign ) | ( HyphenMinus ) ); + // InternalBehaviorAnnexParser.g:3656:1: rule__SignedReal__Alternatives_0 : ( ( PlusSign ) | ( HyphenMinus ) ); public final void rule__SignedReal__Alternatives_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3484:1: ( ( PlusSign ) | ( HyphenMinus ) ) - int alt34=2; - int LA34_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3660:1: ( ( PlusSign ) | ( HyphenMinus ) ) + int alt37=2; + int LA37_0 = input.LA(1); - if ( (LA34_0==PlusSign) ) { - alt34=1; + if ( (LA37_0==PlusSign) ) { + alt37=1; } - else if ( (LA34_0==HyphenMinus) ) { - alt34=2; + else if ( (LA37_0==HyphenMinus) ) { + alt37=2; } else { if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 34, 0, input); + new NoViableAltException("", 37, 0, input); throw nvae; } - switch (alt34) { + switch (alt37) { case 1 : - // InternalBehaviorAnnexParser.g:3485:2: ( PlusSign ) + // InternalBehaviorAnnexParser.g:3661:2: ( PlusSign ) { - // InternalBehaviorAnnexParser.g:3485:2: ( PlusSign ) - // InternalBehaviorAnnexParser.g:3486:3: PlusSign + // InternalBehaviorAnnexParser.g:3661:2: ( PlusSign ) + // InternalBehaviorAnnexParser.g:3662:3: PlusSign { if ( state.backtracking==0 ) { before(grammarAccess.getSignedRealAccess().getPlusSignKeyword_0_0()); @@ -12547,10 +13178,10 @@ else if ( (LA34_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3491:2: ( HyphenMinus ) + // InternalBehaviorAnnexParser.g:3667:2: ( HyphenMinus ) { - // InternalBehaviorAnnexParser.g:3491:2: ( HyphenMinus ) - // InternalBehaviorAnnexParser.g:3492:3: HyphenMinus + // InternalBehaviorAnnexParser.g:3667:2: ( HyphenMinus ) + // InternalBehaviorAnnexParser.g:3668:3: HyphenMinus { if ( state.backtracking==0 ) { before(grammarAccess.getSignedRealAccess().getHyphenMinusKeyword_0_1()); @@ -12583,37 +13214,37 @@ else if ( (LA34_0==HyphenMinus) ) { // $ANTLR start "rule__NumAlt__Alternatives" - // InternalBehaviorAnnexParser.g:3501:1: rule__NumAlt__Alternatives : ( ( ruleRealTerm ) | ( ruleIntegerTerm ) | ( ruleSignedConstant ) | ( ruleConstantValue ) ); + // InternalBehaviorAnnexParser.g:3677:1: rule__NumAlt__Alternatives : ( ( ruleRealTerm ) | ( ruleIntegerTerm ) | ( ruleSignedConstant ) | ( ruleConstantValue ) ); public final void rule__NumAlt__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3505:1: ( ( ruleRealTerm ) | ( ruleIntegerTerm ) | ( ruleSignedConstant ) | ( ruleConstantValue ) ) - int alt35=4; + // InternalBehaviorAnnexParser.g:3681:1: ( ( ruleRealTerm ) | ( ruleIntegerTerm ) | ( ruleSignedConstant ) | ( ruleConstantValue ) ) + int alt38=4; switch ( input.LA(1) ) { case PlusSign: { switch ( input.LA(2) ) { case RULE_ID: { - alt35=3; + alt38=3; } break; case RULE_INTEGER_LIT: { - alt35=2; + alt38=2; } break; case RULE_REAL_LIT: { - alt35=1; + alt38=1; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 35, 1, input); + new NoViableAltException("", 38, 1, input); throw nvae; } @@ -12623,25 +13254,25 @@ public final void rule__NumAlt__Alternatives() throws RecognitionException { case HyphenMinus: { switch ( input.LA(2) ) { - case RULE_REAL_LIT: + case RULE_ID: { - alt35=1; + alt38=3; } break; - case RULE_ID: + case RULE_INTEGER_LIT: { - alt35=3; + alt38=2; } break; - case RULE_INTEGER_LIT: + case RULE_REAL_LIT: { - alt35=2; + alt38=1; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 35, 2, input); + new NoViableAltException("", 38, 2, input); throw nvae; } @@ -12650,33 +13281,33 @@ public final void rule__NumAlt__Alternatives() throws RecognitionException { break; case RULE_REAL_LIT: { - alt35=1; + alt38=1; } break; case RULE_INTEGER_LIT: { - alt35=2; + alt38=2; } break; case RULE_ID: { - alt35=4; + alt38=4; } break; default: if (state.backtracking>0) {state.failed=true; return ;} NoViableAltException nvae = - new NoViableAltException("", 35, 0, input); + new NoViableAltException("", 38, 0, input); throw nvae; } - switch (alt35) { + switch (alt38) { case 1 : - // InternalBehaviorAnnexParser.g:3506:2: ( ruleRealTerm ) + // InternalBehaviorAnnexParser.g:3682:2: ( ruleRealTerm ) { - // InternalBehaviorAnnexParser.g:3506:2: ( ruleRealTerm ) - // InternalBehaviorAnnexParser.g:3507:3: ruleRealTerm + // InternalBehaviorAnnexParser.g:3682:2: ( ruleRealTerm ) + // InternalBehaviorAnnexParser.g:3683:3: ruleRealTerm { if ( state.backtracking==0 ) { before(grammarAccess.getNumAltAccess().getRealTermParserRuleCall_0()); @@ -12696,10 +13327,10 @@ public final void rule__NumAlt__Alternatives() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:3512:2: ( ruleIntegerTerm ) + // InternalBehaviorAnnexParser.g:3688:2: ( ruleIntegerTerm ) { - // InternalBehaviorAnnexParser.g:3512:2: ( ruleIntegerTerm ) - // InternalBehaviorAnnexParser.g:3513:3: ruleIntegerTerm + // InternalBehaviorAnnexParser.g:3688:2: ( ruleIntegerTerm ) + // InternalBehaviorAnnexParser.g:3689:3: ruleIntegerTerm { if ( state.backtracking==0 ) { before(grammarAccess.getNumAltAccess().getIntegerTermParserRuleCall_1()); @@ -12719,10 +13350,10 @@ public final void rule__NumAlt__Alternatives() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:3518:2: ( ruleSignedConstant ) + // InternalBehaviorAnnexParser.g:3694:2: ( ruleSignedConstant ) { - // InternalBehaviorAnnexParser.g:3518:2: ( ruleSignedConstant ) - // InternalBehaviorAnnexParser.g:3519:3: ruleSignedConstant + // InternalBehaviorAnnexParser.g:3694:2: ( ruleSignedConstant ) + // InternalBehaviorAnnexParser.g:3695:3: ruleSignedConstant { if ( state.backtracking==0 ) { before(grammarAccess.getNumAltAccess().getSignedConstantParserRuleCall_2()); @@ -12742,10 +13373,10 @@ public final void rule__NumAlt__Alternatives() throws RecognitionException { } break; case 4 : - // InternalBehaviorAnnexParser.g:3524:2: ( ruleConstantValue ) + // InternalBehaviorAnnexParser.g:3700:2: ( ruleConstantValue ) { - // InternalBehaviorAnnexParser.g:3524:2: ( ruleConstantValue ) - // InternalBehaviorAnnexParser.g:3525:3: ruleConstantValue + // InternalBehaviorAnnexParser.g:3700:2: ( ruleConstantValue ) + // InternalBehaviorAnnexParser.g:3701:3: ruleConstantValue { if ( state.backtracking==0 ) { before(grammarAccess.getNumAltAccess().getConstantValueParserRuleCall_3()); @@ -12782,14 +13413,14 @@ public final void rule__NumAlt__Alternatives() throws RecognitionException { // $ANTLR start "rule__BehaviorAnnex__Group__0" - // InternalBehaviorAnnexParser.g:3534:1: rule__BehaviorAnnex__Group__0 : rule__BehaviorAnnex__Group__0__Impl rule__BehaviorAnnex__Group__1 ; + // InternalBehaviorAnnexParser.g:3710:1: rule__BehaviorAnnex__Group__0 : rule__BehaviorAnnex__Group__0__Impl rule__BehaviorAnnex__Group__1 ; public final void rule__BehaviorAnnex__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3538:1: ( rule__BehaviorAnnex__Group__0__Impl rule__BehaviorAnnex__Group__1 ) - // InternalBehaviorAnnexParser.g:3539:2: rule__BehaviorAnnex__Group__0__Impl rule__BehaviorAnnex__Group__1 + // InternalBehaviorAnnexParser.g:3714:1: ( rule__BehaviorAnnex__Group__0__Impl rule__BehaviorAnnex__Group__1 ) + // InternalBehaviorAnnexParser.g:3715:2: rule__BehaviorAnnex__Group__0__Impl rule__BehaviorAnnex__Group__1 { pushFollow(FollowSets000.FOLLOW_3); rule__BehaviorAnnex__Group__0__Impl(); @@ -12820,23 +13451,23 @@ public final void rule__BehaviorAnnex__Group__0() throws RecognitionException { // $ANTLR start "rule__BehaviorAnnex__Group__0__Impl" - // InternalBehaviorAnnexParser.g:3546:1: rule__BehaviorAnnex__Group__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:3722:1: rule__BehaviorAnnex__Group__0__Impl : ( () ) ; public final void rule__BehaviorAnnex__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3550:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:3551:1: ( () ) + // InternalBehaviorAnnexParser.g:3726:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:3727:1: ( () ) { - // InternalBehaviorAnnexParser.g:3551:1: ( () ) - // InternalBehaviorAnnexParser.g:3552:2: () + // InternalBehaviorAnnexParser.g:3727:1: ( () ) + // InternalBehaviorAnnexParser.g:3728:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getBehaviorAnnexAction_0()); } - // InternalBehaviorAnnexParser.g:3553:2: () - // InternalBehaviorAnnexParser.g:3553:3: + // InternalBehaviorAnnexParser.g:3729:2: () + // InternalBehaviorAnnexParser.g:3729:3: { } @@ -12861,14 +13492,14 @@ public final void rule__BehaviorAnnex__Group__0__Impl() throws RecognitionExcept // $ANTLR start "rule__BehaviorAnnex__Group__1" - // InternalBehaviorAnnexParser.g:3561:1: rule__BehaviorAnnex__Group__1 : rule__BehaviorAnnex__Group__1__Impl rule__BehaviorAnnex__Group__2 ; + // InternalBehaviorAnnexParser.g:3737:1: rule__BehaviorAnnex__Group__1 : rule__BehaviorAnnex__Group__1__Impl rule__BehaviorAnnex__Group__2 ; public final void rule__BehaviorAnnex__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3565:1: ( rule__BehaviorAnnex__Group__1__Impl rule__BehaviorAnnex__Group__2 ) - // InternalBehaviorAnnexParser.g:3566:2: rule__BehaviorAnnex__Group__1__Impl rule__BehaviorAnnex__Group__2 + // InternalBehaviorAnnexParser.g:3741:1: ( rule__BehaviorAnnex__Group__1__Impl rule__BehaviorAnnex__Group__2 ) + // InternalBehaviorAnnexParser.g:3742:2: rule__BehaviorAnnex__Group__1__Impl rule__BehaviorAnnex__Group__2 { pushFollow(FollowSets000.FOLLOW_3); rule__BehaviorAnnex__Group__1__Impl(); @@ -12899,31 +13530,31 @@ public final void rule__BehaviorAnnex__Group__1() throws RecognitionException { // $ANTLR start "rule__BehaviorAnnex__Group__1__Impl" - // InternalBehaviorAnnexParser.g:3573:1: rule__BehaviorAnnex__Group__1__Impl : ( ( rule__BehaviorAnnex__Group_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:3749:1: rule__BehaviorAnnex__Group__1__Impl : ( ( rule__BehaviorAnnex__Group_1__0 )? ) ; public final void rule__BehaviorAnnex__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3577:1: ( ( ( rule__BehaviorAnnex__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:3578:1: ( ( rule__BehaviorAnnex__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:3753:1: ( ( ( rule__BehaviorAnnex__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:3754:1: ( ( rule__BehaviorAnnex__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:3578:1: ( ( rule__BehaviorAnnex__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:3579:2: ( rule__BehaviorAnnex__Group_1__0 )? + // InternalBehaviorAnnexParser.g:3754:1: ( ( rule__BehaviorAnnex__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:3755:2: ( rule__BehaviorAnnex__Group_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:3580:2: ( rule__BehaviorAnnex__Group_1__0 )? - int alt36=2; - int LA36_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3756:2: ( rule__BehaviorAnnex__Group_1__0 )? + int alt39=2; + int LA39_0 = input.LA(1); - if ( (LA36_0==Variables) ) { - alt36=1; + if ( (LA39_0==Variables) ) { + alt39=1; } - switch (alt36) { + switch (alt39) { case 1 : - // InternalBehaviorAnnexParser.g:3580:3: rule__BehaviorAnnex__Group_1__0 + // InternalBehaviorAnnexParser.g:3756:3: rule__BehaviorAnnex__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorAnnex__Group_1__0(); @@ -12961,14 +13592,14 @@ public final void rule__BehaviorAnnex__Group__1__Impl() throws RecognitionExcept // $ANTLR start "rule__BehaviorAnnex__Group__2" - // InternalBehaviorAnnexParser.g:3588:1: rule__BehaviorAnnex__Group__2 : rule__BehaviorAnnex__Group__2__Impl rule__BehaviorAnnex__Group__3 ; + // InternalBehaviorAnnexParser.g:3764:1: rule__BehaviorAnnex__Group__2 : rule__BehaviorAnnex__Group__2__Impl rule__BehaviorAnnex__Group__3 ; public final void rule__BehaviorAnnex__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3592:1: ( rule__BehaviorAnnex__Group__2__Impl rule__BehaviorAnnex__Group__3 ) - // InternalBehaviorAnnexParser.g:3593:2: rule__BehaviorAnnex__Group__2__Impl rule__BehaviorAnnex__Group__3 + // InternalBehaviorAnnexParser.g:3768:1: ( rule__BehaviorAnnex__Group__2__Impl rule__BehaviorAnnex__Group__3 ) + // InternalBehaviorAnnexParser.g:3769:2: rule__BehaviorAnnex__Group__2__Impl rule__BehaviorAnnex__Group__3 { pushFollow(FollowSets000.FOLLOW_3); rule__BehaviorAnnex__Group__2__Impl(); @@ -12999,31 +13630,31 @@ public final void rule__BehaviorAnnex__Group__2() throws RecognitionException { // $ANTLR start "rule__BehaviorAnnex__Group__2__Impl" - // InternalBehaviorAnnexParser.g:3600:1: rule__BehaviorAnnex__Group__2__Impl : ( ( rule__BehaviorAnnex__Group_2__0 )? ) ; + // InternalBehaviorAnnexParser.g:3776:1: rule__BehaviorAnnex__Group__2__Impl : ( ( rule__BehaviorAnnex__Group_2__0 )? ) ; public final void rule__BehaviorAnnex__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3604:1: ( ( ( rule__BehaviorAnnex__Group_2__0 )? ) ) - // InternalBehaviorAnnexParser.g:3605:1: ( ( rule__BehaviorAnnex__Group_2__0 )? ) + // InternalBehaviorAnnexParser.g:3780:1: ( ( ( rule__BehaviorAnnex__Group_2__0 )? ) ) + // InternalBehaviorAnnexParser.g:3781:1: ( ( rule__BehaviorAnnex__Group_2__0 )? ) { - // InternalBehaviorAnnexParser.g:3605:1: ( ( rule__BehaviorAnnex__Group_2__0 )? ) - // InternalBehaviorAnnexParser.g:3606:2: ( rule__BehaviorAnnex__Group_2__0 )? + // InternalBehaviorAnnexParser.g:3781:1: ( ( rule__BehaviorAnnex__Group_2__0 )? ) + // InternalBehaviorAnnexParser.g:3782:2: ( rule__BehaviorAnnex__Group_2__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getGroup_2()); } - // InternalBehaviorAnnexParser.g:3607:2: ( rule__BehaviorAnnex__Group_2__0 )? - int alt37=2; - int LA37_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3783:2: ( rule__BehaviorAnnex__Group_2__0 )? + int alt40=2; + int LA40_0 = input.LA(1); - if ( (LA37_0==States) ) { - alt37=1; + if ( (LA40_0==States) ) { + alt40=1; } - switch (alt37) { + switch (alt40) { case 1 : - // InternalBehaviorAnnexParser.g:3607:3: rule__BehaviorAnnex__Group_2__0 + // InternalBehaviorAnnexParser.g:3783:3: rule__BehaviorAnnex__Group_2__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorAnnex__Group_2__0(); @@ -13061,14 +13692,14 @@ public final void rule__BehaviorAnnex__Group__2__Impl() throws RecognitionExcept // $ANTLR start "rule__BehaviorAnnex__Group__3" - // InternalBehaviorAnnexParser.g:3615:1: rule__BehaviorAnnex__Group__3 : rule__BehaviorAnnex__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:3791:1: rule__BehaviorAnnex__Group__3 : rule__BehaviorAnnex__Group__3__Impl ; public final void rule__BehaviorAnnex__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3619:1: ( rule__BehaviorAnnex__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:3620:2: rule__BehaviorAnnex__Group__3__Impl + // InternalBehaviorAnnexParser.g:3795:1: ( rule__BehaviorAnnex__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:3796:2: rule__BehaviorAnnex__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorAnnex__Group__3__Impl(); @@ -13094,31 +13725,31 @@ public final void rule__BehaviorAnnex__Group__3() throws RecognitionException { // $ANTLR start "rule__BehaviorAnnex__Group__3__Impl" - // InternalBehaviorAnnexParser.g:3626:1: rule__BehaviorAnnex__Group__3__Impl : ( ( rule__BehaviorAnnex__Group_3__0 )? ) ; + // InternalBehaviorAnnexParser.g:3802:1: rule__BehaviorAnnex__Group__3__Impl : ( ( rule__BehaviorAnnex__Group_3__0 )? ) ; public final void rule__BehaviorAnnex__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3630:1: ( ( ( rule__BehaviorAnnex__Group_3__0 )? ) ) - // InternalBehaviorAnnexParser.g:3631:1: ( ( rule__BehaviorAnnex__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:3806:1: ( ( ( rule__BehaviorAnnex__Group_3__0 )? ) ) + // InternalBehaviorAnnexParser.g:3807:1: ( ( rule__BehaviorAnnex__Group_3__0 )? ) { - // InternalBehaviorAnnexParser.g:3631:1: ( ( rule__BehaviorAnnex__Group_3__0 )? ) - // InternalBehaviorAnnexParser.g:3632:2: ( rule__BehaviorAnnex__Group_3__0 )? + // InternalBehaviorAnnexParser.g:3807:1: ( ( rule__BehaviorAnnex__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:3808:2: ( rule__BehaviorAnnex__Group_3__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getGroup_3()); } - // InternalBehaviorAnnexParser.g:3633:2: ( rule__BehaviorAnnex__Group_3__0 )? - int alt38=2; - int LA38_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3809:2: ( rule__BehaviorAnnex__Group_3__0 )? + int alt41=2; + int LA41_0 = input.LA(1); - if ( (LA38_0==Transitions) ) { - alt38=1; + if ( (LA41_0==Transitions) ) { + alt41=1; } - switch (alt38) { + switch (alt41) { case 1 : - // InternalBehaviorAnnexParser.g:3633:3: rule__BehaviorAnnex__Group_3__0 + // InternalBehaviorAnnexParser.g:3809:3: rule__BehaviorAnnex__Group_3__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorAnnex__Group_3__0(); @@ -13156,14 +13787,14 @@ public final void rule__BehaviorAnnex__Group__3__Impl() throws RecognitionExcept // $ANTLR start "rule__BehaviorAnnex__Group_1__0" - // InternalBehaviorAnnexParser.g:3642:1: rule__BehaviorAnnex__Group_1__0 : rule__BehaviorAnnex__Group_1__0__Impl rule__BehaviorAnnex__Group_1__1 ; + // InternalBehaviorAnnexParser.g:3818:1: rule__BehaviorAnnex__Group_1__0 : rule__BehaviorAnnex__Group_1__0__Impl rule__BehaviorAnnex__Group_1__1 ; public final void rule__BehaviorAnnex__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3646:1: ( rule__BehaviorAnnex__Group_1__0__Impl rule__BehaviorAnnex__Group_1__1 ) - // InternalBehaviorAnnexParser.g:3647:2: rule__BehaviorAnnex__Group_1__0__Impl rule__BehaviorAnnex__Group_1__1 + // InternalBehaviorAnnexParser.g:3822:1: ( rule__BehaviorAnnex__Group_1__0__Impl rule__BehaviorAnnex__Group_1__1 ) + // InternalBehaviorAnnexParser.g:3823:2: rule__BehaviorAnnex__Group_1__0__Impl rule__BehaviorAnnex__Group_1__1 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorAnnex__Group_1__0__Impl(); @@ -13194,17 +13825,17 @@ public final void rule__BehaviorAnnex__Group_1__0() throws RecognitionException // $ANTLR start "rule__BehaviorAnnex__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:3654:1: rule__BehaviorAnnex__Group_1__0__Impl : ( Variables ) ; + // InternalBehaviorAnnexParser.g:3830:1: rule__BehaviorAnnex__Group_1__0__Impl : ( Variables ) ; public final void rule__BehaviorAnnex__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3658:1: ( ( Variables ) ) - // InternalBehaviorAnnexParser.g:3659:1: ( Variables ) + // InternalBehaviorAnnexParser.g:3834:1: ( ( Variables ) ) + // InternalBehaviorAnnexParser.g:3835:1: ( Variables ) { - // InternalBehaviorAnnexParser.g:3659:1: ( Variables ) - // InternalBehaviorAnnexParser.g:3660:2: Variables + // InternalBehaviorAnnexParser.g:3835:1: ( Variables ) + // InternalBehaviorAnnexParser.g:3836:2: Variables { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getVariablesKeyword_1_0()); @@ -13235,14 +13866,14 @@ public final void rule__BehaviorAnnex__Group_1__0__Impl() throws RecognitionExce // $ANTLR start "rule__BehaviorAnnex__Group_1__1" - // InternalBehaviorAnnexParser.g:3669:1: rule__BehaviorAnnex__Group_1__1 : rule__BehaviorAnnex__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:3845:1: rule__BehaviorAnnex__Group_1__1 : rule__BehaviorAnnex__Group_1__1__Impl ; public final void rule__BehaviorAnnex__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3673:1: ( rule__BehaviorAnnex__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:3674:2: rule__BehaviorAnnex__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:3849:1: ( rule__BehaviorAnnex__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:3850:2: rule__BehaviorAnnex__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorAnnex__Group_1__1__Impl(); @@ -13268,26 +13899,26 @@ public final void rule__BehaviorAnnex__Group_1__1() throws RecognitionException // $ANTLR start "rule__BehaviorAnnex__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:3680:1: rule__BehaviorAnnex__Group_1__1__Impl : ( ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) ) ; + // InternalBehaviorAnnexParser.g:3856:1: rule__BehaviorAnnex__Group_1__1__Impl : ( ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) ) ; public final void rule__BehaviorAnnex__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3684:1: ( ( ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) ) ) - // InternalBehaviorAnnexParser.g:3685:1: ( ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) ) + // InternalBehaviorAnnexParser.g:3860:1: ( ( ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) ) ) + // InternalBehaviorAnnexParser.g:3861:1: ( ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) ) { - // InternalBehaviorAnnexParser.g:3685:1: ( ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) ) - // InternalBehaviorAnnexParser.g:3686:2: ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) + // InternalBehaviorAnnexParser.g:3861:1: ( ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) ) + // InternalBehaviorAnnexParser.g:3862:2: ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) { - // InternalBehaviorAnnexParser.g:3686:2: ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:3687:3: ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:3862:2: ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:3863:3: ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getVariableGroupsAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:3688:3: ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:3688:4: rule__BehaviorAnnex__VariableGroupsAssignment_1_1 + // InternalBehaviorAnnexParser.g:3864:3: ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:3864:4: rule__BehaviorAnnex__VariableGroupsAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_5); rule__BehaviorAnnex__VariableGroupsAssignment_1_1(); @@ -13303,26 +13934,26 @@ public final void rule__BehaviorAnnex__Group_1__1__Impl() throws RecognitionExce } - // InternalBehaviorAnnexParser.g:3691:2: ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) - // InternalBehaviorAnnexParser.g:3692:3: ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* + // InternalBehaviorAnnexParser.g:3867:2: ( ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* ) + // InternalBehaviorAnnexParser.g:3868:3: ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getVariableGroupsAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:3693:3: ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* - loop39: + // InternalBehaviorAnnexParser.g:3869:3: ( rule__BehaviorAnnex__VariableGroupsAssignment_1_1 )* + loop42: do { - int alt39=2; - int LA39_0 = input.LA(1); + int alt42=2; + int LA42_0 = input.LA(1); - if ( (LA39_0==RULE_ID) ) { - alt39=1; + if ( (LA42_0==RULE_ID) ) { + alt42=1; } - switch (alt39) { + switch (alt42) { case 1 : - // InternalBehaviorAnnexParser.g:3693:4: rule__BehaviorAnnex__VariableGroupsAssignment_1_1 + // InternalBehaviorAnnexParser.g:3869:4: rule__BehaviorAnnex__VariableGroupsAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_5); rule__BehaviorAnnex__VariableGroupsAssignment_1_1(); @@ -13334,7 +13965,7 @@ public final void rule__BehaviorAnnex__Group_1__1__Impl() throws RecognitionExce break; default : - break loop39; + break loop42; } } while (true); @@ -13366,14 +13997,14 @@ public final void rule__BehaviorAnnex__Group_1__1__Impl() throws RecognitionExce // $ANTLR start "rule__BehaviorAnnex__Group_2__0" - // InternalBehaviorAnnexParser.g:3703:1: rule__BehaviorAnnex__Group_2__0 : rule__BehaviorAnnex__Group_2__0__Impl rule__BehaviorAnnex__Group_2__1 ; + // InternalBehaviorAnnexParser.g:3879:1: rule__BehaviorAnnex__Group_2__0 : rule__BehaviorAnnex__Group_2__0__Impl rule__BehaviorAnnex__Group_2__1 ; public final void rule__BehaviorAnnex__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3707:1: ( rule__BehaviorAnnex__Group_2__0__Impl rule__BehaviorAnnex__Group_2__1 ) - // InternalBehaviorAnnexParser.g:3708:2: rule__BehaviorAnnex__Group_2__0__Impl rule__BehaviorAnnex__Group_2__1 + // InternalBehaviorAnnexParser.g:3883:1: ( rule__BehaviorAnnex__Group_2__0__Impl rule__BehaviorAnnex__Group_2__1 ) + // InternalBehaviorAnnexParser.g:3884:2: rule__BehaviorAnnex__Group_2__0__Impl rule__BehaviorAnnex__Group_2__1 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorAnnex__Group_2__0__Impl(); @@ -13404,17 +14035,17 @@ public final void rule__BehaviorAnnex__Group_2__0() throws RecognitionException // $ANTLR start "rule__BehaviorAnnex__Group_2__0__Impl" - // InternalBehaviorAnnexParser.g:3715:1: rule__BehaviorAnnex__Group_2__0__Impl : ( States ) ; + // InternalBehaviorAnnexParser.g:3891:1: rule__BehaviorAnnex__Group_2__0__Impl : ( States ) ; public final void rule__BehaviorAnnex__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3719:1: ( ( States ) ) - // InternalBehaviorAnnexParser.g:3720:1: ( States ) + // InternalBehaviorAnnexParser.g:3895:1: ( ( States ) ) + // InternalBehaviorAnnexParser.g:3896:1: ( States ) { - // InternalBehaviorAnnexParser.g:3720:1: ( States ) - // InternalBehaviorAnnexParser.g:3721:2: States + // InternalBehaviorAnnexParser.g:3896:1: ( States ) + // InternalBehaviorAnnexParser.g:3897:2: States { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getStatesKeyword_2_0()); @@ -13445,14 +14076,14 @@ public final void rule__BehaviorAnnex__Group_2__0__Impl() throws RecognitionExce // $ANTLR start "rule__BehaviorAnnex__Group_2__1" - // InternalBehaviorAnnexParser.g:3730:1: rule__BehaviorAnnex__Group_2__1 : rule__BehaviorAnnex__Group_2__1__Impl ; + // InternalBehaviorAnnexParser.g:3906:1: rule__BehaviorAnnex__Group_2__1 : rule__BehaviorAnnex__Group_2__1__Impl ; public final void rule__BehaviorAnnex__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3734:1: ( rule__BehaviorAnnex__Group_2__1__Impl ) - // InternalBehaviorAnnexParser.g:3735:2: rule__BehaviorAnnex__Group_2__1__Impl + // InternalBehaviorAnnexParser.g:3910:1: ( rule__BehaviorAnnex__Group_2__1__Impl ) + // InternalBehaviorAnnexParser.g:3911:2: rule__BehaviorAnnex__Group_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorAnnex__Group_2__1__Impl(); @@ -13478,26 +14109,26 @@ public final void rule__BehaviorAnnex__Group_2__1() throws RecognitionException // $ANTLR start "rule__BehaviorAnnex__Group_2__1__Impl" - // InternalBehaviorAnnexParser.g:3741:1: rule__BehaviorAnnex__Group_2__1__Impl : ( ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) ) ; + // InternalBehaviorAnnexParser.g:3917:1: rule__BehaviorAnnex__Group_2__1__Impl : ( ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) ) ; public final void rule__BehaviorAnnex__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3745:1: ( ( ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) ) ) - // InternalBehaviorAnnexParser.g:3746:1: ( ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) ) + // InternalBehaviorAnnexParser.g:3921:1: ( ( ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) ) ) + // InternalBehaviorAnnexParser.g:3922:1: ( ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) ) { - // InternalBehaviorAnnexParser.g:3746:1: ( ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) ) - // InternalBehaviorAnnexParser.g:3747:2: ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) + // InternalBehaviorAnnexParser.g:3922:1: ( ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) ) + // InternalBehaviorAnnexParser.g:3923:2: ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) { - // InternalBehaviorAnnexParser.g:3747:2: ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) - // InternalBehaviorAnnexParser.g:3748:3: ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) + // InternalBehaviorAnnexParser.g:3923:2: ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) ) + // InternalBehaviorAnnexParser.g:3924:3: ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getStateGroupsAssignment_2_1()); } - // InternalBehaviorAnnexParser.g:3749:3: ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) - // InternalBehaviorAnnexParser.g:3749:4: rule__BehaviorAnnex__StateGroupsAssignment_2_1 + // InternalBehaviorAnnexParser.g:3925:3: ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 ) + // InternalBehaviorAnnexParser.g:3925:4: rule__BehaviorAnnex__StateGroupsAssignment_2_1 { pushFollow(FollowSets000.FOLLOW_5); rule__BehaviorAnnex__StateGroupsAssignment_2_1(); @@ -13513,26 +14144,26 @@ public final void rule__BehaviorAnnex__Group_2__1__Impl() throws RecognitionExce } - // InternalBehaviorAnnexParser.g:3752:2: ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) - // InternalBehaviorAnnexParser.g:3753:3: ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* + // InternalBehaviorAnnexParser.g:3928:2: ( ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* ) + // InternalBehaviorAnnexParser.g:3929:3: ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getStateGroupsAssignment_2_1()); } - // InternalBehaviorAnnexParser.g:3754:3: ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* - loop40: + // InternalBehaviorAnnexParser.g:3930:3: ( rule__BehaviorAnnex__StateGroupsAssignment_2_1 )* + loop43: do { - int alt40=2; - int LA40_0 = input.LA(1); + int alt43=2; + int LA43_0 = input.LA(1); - if ( (LA40_0==RULE_ID) ) { - alt40=1; + if ( (LA43_0==RULE_ID) ) { + alt43=1; } - switch (alt40) { + switch (alt43) { case 1 : - // InternalBehaviorAnnexParser.g:3754:4: rule__BehaviorAnnex__StateGroupsAssignment_2_1 + // InternalBehaviorAnnexParser.g:3930:4: rule__BehaviorAnnex__StateGroupsAssignment_2_1 { pushFollow(FollowSets000.FOLLOW_5); rule__BehaviorAnnex__StateGroupsAssignment_2_1(); @@ -13544,7 +14175,7 @@ public final void rule__BehaviorAnnex__Group_2__1__Impl() throws RecognitionExce break; default : - break loop40; + break loop43; } } while (true); @@ -13576,14 +14207,14 @@ public final void rule__BehaviorAnnex__Group_2__1__Impl() throws RecognitionExce // $ANTLR start "rule__BehaviorAnnex__Group_3__0" - // InternalBehaviorAnnexParser.g:3764:1: rule__BehaviorAnnex__Group_3__0 : rule__BehaviorAnnex__Group_3__0__Impl rule__BehaviorAnnex__Group_3__1 ; + // InternalBehaviorAnnexParser.g:3940:1: rule__BehaviorAnnex__Group_3__0 : rule__BehaviorAnnex__Group_3__0__Impl rule__BehaviorAnnex__Group_3__1 ; public final void rule__BehaviorAnnex__Group_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3768:1: ( rule__BehaviorAnnex__Group_3__0__Impl rule__BehaviorAnnex__Group_3__1 ) - // InternalBehaviorAnnexParser.g:3769:2: rule__BehaviorAnnex__Group_3__0__Impl rule__BehaviorAnnex__Group_3__1 + // InternalBehaviorAnnexParser.g:3944:1: ( rule__BehaviorAnnex__Group_3__0__Impl rule__BehaviorAnnex__Group_3__1 ) + // InternalBehaviorAnnexParser.g:3945:2: rule__BehaviorAnnex__Group_3__0__Impl rule__BehaviorAnnex__Group_3__1 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorAnnex__Group_3__0__Impl(); @@ -13614,17 +14245,17 @@ public final void rule__BehaviorAnnex__Group_3__0() throws RecognitionException // $ANTLR start "rule__BehaviorAnnex__Group_3__0__Impl" - // InternalBehaviorAnnexParser.g:3776:1: rule__BehaviorAnnex__Group_3__0__Impl : ( Transitions ) ; + // InternalBehaviorAnnexParser.g:3952:1: rule__BehaviorAnnex__Group_3__0__Impl : ( Transitions ) ; public final void rule__BehaviorAnnex__Group_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3780:1: ( ( Transitions ) ) - // InternalBehaviorAnnexParser.g:3781:1: ( Transitions ) + // InternalBehaviorAnnexParser.g:3956:1: ( ( Transitions ) ) + // InternalBehaviorAnnexParser.g:3957:1: ( Transitions ) { - // InternalBehaviorAnnexParser.g:3781:1: ( Transitions ) - // InternalBehaviorAnnexParser.g:3782:2: Transitions + // InternalBehaviorAnnexParser.g:3957:1: ( Transitions ) + // InternalBehaviorAnnexParser.g:3958:2: Transitions { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getTransitionsKeyword_3_0()); @@ -13655,14 +14286,14 @@ public final void rule__BehaviorAnnex__Group_3__0__Impl() throws RecognitionExce // $ANTLR start "rule__BehaviorAnnex__Group_3__1" - // InternalBehaviorAnnexParser.g:3791:1: rule__BehaviorAnnex__Group_3__1 : rule__BehaviorAnnex__Group_3__1__Impl ; + // InternalBehaviorAnnexParser.g:3967:1: rule__BehaviorAnnex__Group_3__1 : rule__BehaviorAnnex__Group_3__1__Impl ; public final void rule__BehaviorAnnex__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3795:1: ( rule__BehaviorAnnex__Group_3__1__Impl ) - // InternalBehaviorAnnexParser.g:3796:2: rule__BehaviorAnnex__Group_3__1__Impl + // InternalBehaviorAnnexParser.g:3971:1: ( rule__BehaviorAnnex__Group_3__1__Impl ) + // InternalBehaviorAnnexParser.g:3972:2: rule__BehaviorAnnex__Group_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorAnnex__Group_3__1__Impl(); @@ -13688,26 +14319,26 @@ public final void rule__BehaviorAnnex__Group_3__1() throws RecognitionException // $ANTLR start "rule__BehaviorAnnex__Group_3__1__Impl" - // InternalBehaviorAnnexParser.g:3802:1: rule__BehaviorAnnex__Group_3__1__Impl : ( ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) ) ; + // InternalBehaviorAnnexParser.g:3978:1: rule__BehaviorAnnex__Group_3__1__Impl : ( ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) ) ; public final void rule__BehaviorAnnex__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3806:1: ( ( ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) ) ) - // InternalBehaviorAnnexParser.g:3807:1: ( ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) ) + // InternalBehaviorAnnexParser.g:3982:1: ( ( ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) ) ) + // InternalBehaviorAnnexParser.g:3983:1: ( ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) ) { - // InternalBehaviorAnnexParser.g:3807:1: ( ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) ) - // InternalBehaviorAnnexParser.g:3808:2: ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) + // InternalBehaviorAnnexParser.g:3983:1: ( ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) ) + // InternalBehaviorAnnexParser.g:3984:2: ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) { - // InternalBehaviorAnnexParser.g:3808:2: ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) - // InternalBehaviorAnnexParser.g:3809:3: ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:3984:2: ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:3985:3: ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getTransitionsAssignment_3_1()); } - // InternalBehaviorAnnexParser.g:3810:3: ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) - // InternalBehaviorAnnexParser.g:3810:4: rule__BehaviorAnnex__TransitionsAssignment_3_1 + // InternalBehaviorAnnexParser.g:3986:3: ( rule__BehaviorAnnex__TransitionsAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:3986:4: rule__BehaviorAnnex__TransitionsAssignment_3_1 { pushFollow(FollowSets000.FOLLOW_5); rule__BehaviorAnnex__TransitionsAssignment_3_1(); @@ -13723,26 +14354,26 @@ public final void rule__BehaviorAnnex__Group_3__1__Impl() throws RecognitionExce } - // InternalBehaviorAnnexParser.g:3813:2: ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) - // InternalBehaviorAnnexParser.g:3814:3: ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* + // InternalBehaviorAnnexParser.g:3989:2: ( ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* ) + // InternalBehaviorAnnexParser.g:3990:3: ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getTransitionsAssignment_3_1()); } - // InternalBehaviorAnnexParser.g:3815:3: ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* - loop41: + // InternalBehaviorAnnexParser.g:3991:3: ( rule__BehaviorAnnex__TransitionsAssignment_3_1 )* + loop44: do { - int alt41=2; - int LA41_0 = input.LA(1); + int alt44=2; + int LA44_0 = input.LA(1); - if ( (LA41_0==RULE_ID) ) { - alt41=1; + if ( (LA44_0==RULE_ID) ) { + alt44=1; } - switch (alt41) { + switch (alt44) { case 1 : - // InternalBehaviorAnnexParser.g:3815:4: rule__BehaviorAnnex__TransitionsAssignment_3_1 + // InternalBehaviorAnnexParser.g:3991:4: rule__BehaviorAnnex__TransitionsAssignment_3_1 { pushFollow(FollowSets000.FOLLOW_5); rule__BehaviorAnnex__TransitionsAssignment_3_1(); @@ -13754,7 +14385,7 @@ public final void rule__BehaviorAnnex__Group_3__1__Impl() throws RecognitionExce break; default : - break loop41; + break loop44; } } while (true); @@ -13786,14 +14417,14 @@ public final void rule__BehaviorAnnex__Group_3__1__Impl() throws RecognitionExce // $ANTLR start "rule__BehaviorVariableGroup__Group__0" - // InternalBehaviorAnnexParser.g:3825:1: rule__BehaviorVariableGroup__Group__0 : rule__BehaviorVariableGroup__Group__0__Impl rule__BehaviorVariableGroup__Group__1 ; + // InternalBehaviorAnnexParser.g:4001:1: rule__BehaviorVariableGroup__Group__0 : rule__BehaviorVariableGroup__Group__0__Impl rule__BehaviorVariableGroup__Group__1 ; public final void rule__BehaviorVariableGroup__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3829:1: ( rule__BehaviorVariableGroup__Group__0__Impl rule__BehaviorVariableGroup__Group__1 ) - // InternalBehaviorAnnexParser.g:3830:2: rule__BehaviorVariableGroup__Group__0__Impl rule__BehaviorVariableGroup__Group__1 + // InternalBehaviorAnnexParser.g:4005:1: ( rule__BehaviorVariableGroup__Group__0__Impl rule__BehaviorVariableGroup__Group__1 ) + // InternalBehaviorAnnexParser.g:4006:2: rule__BehaviorVariableGroup__Group__0__Impl rule__BehaviorVariableGroup__Group__1 { pushFollow(FollowSets000.FOLLOW_6); rule__BehaviorVariableGroup__Group__0__Impl(); @@ -13824,23 +14455,23 @@ public final void rule__BehaviorVariableGroup__Group__0() throws RecognitionExce // $ANTLR start "rule__BehaviorVariableGroup__Group__0__Impl" - // InternalBehaviorAnnexParser.g:3837:1: rule__BehaviorVariableGroup__Group__0__Impl : ( ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:4013:1: rule__BehaviorVariableGroup__Group__0__Impl : ( ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) ) ; public final void rule__BehaviorVariableGroup__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3841:1: ( ( ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:3842:1: ( ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:4017:1: ( ( ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:4018:1: ( ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:3842:1: ( ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:3843:2: ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) + // InternalBehaviorAnnexParser.g:4018:1: ( ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:4019:2: ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getVariablesAssignment_0()); } - // InternalBehaviorAnnexParser.g:3844:2: ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) - // InternalBehaviorAnnexParser.g:3844:3: rule__BehaviorVariableGroup__VariablesAssignment_0 + // InternalBehaviorAnnexParser.g:4020:2: ( rule__BehaviorVariableGroup__VariablesAssignment_0 ) + // InternalBehaviorAnnexParser.g:4020:3: rule__BehaviorVariableGroup__VariablesAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariableGroup__VariablesAssignment_0(); @@ -13875,14 +14506,14 @@ public final void rule__BehaviorVariableGroup__Group__0__Impl() throws Recogniti // $ANTLR start "rule__BehaviorVariableGroup__Group__1" - // InternalBehaviorAnnexParser.g:3852:1: rule__BehaviorVariableGroup__Group__1 : rule__BehaviorVariableGroup__Group__1__Impl rule__BehaviorVariableGroup__Group__2 ; + // InternalBehaviorAnnexParser.g:4028:1: rule__BehaviorVariableGroup__Group__1 : rule__BehaviorVariableGroup__Group__1__Impl rule__BehaviorVariableGroup__Group__2 ; public final void rule__BehaviorVariableGroup__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3856:1: ( rule__BehaviorVariableGroup__Group__1__Impl rule__BehaviorVariableGroup__Group__2 ) - // InternalBehaviorAnnexParser.g:3857:2: rule__BehaviorVariableGroup__Group__1__Impl rule__BehaviorVariableGroup__Group__2 + // InternalBehaviorAnnexParser.g:4032:1: ( rule__BehaviorVariableGroup__Group__1__Impl rule__BehaviorVariableGroup__Group__2 ) + // InternalBehaviorAnnexParser.g:4033:2: rule__BehaviorVariableGroup__Group__1__Impl rule__BehaviorVariableGroup__Group__2 { pushFollow(FollowSets000.FOLLOW_6); rule__BehaviorVariableGroup__Group__1__Impl(); @@ -13913,35 +14544,35 @@ public final void rule__BehaviorVariableGroup__Group__1() throws RecognitionExce // $ANTLR start "rule__BehaviorVariableGroup__Group__1__Impl" - // InternalBehaviorAnnexParser.g:3864:1: rule__BehaviorVariableGroup__Group__1__Impl : ( ( rule__BehaviorVariableGroup__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:4040:1: rule__BehaviorVariableGroup__Group__1__Impl : ( ( rule__BehaviorVariableGroup__Group_1__0 )* ) ; public final void rule__BehaviorVariableGroup__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3868:1: ( ( ( rule__BehaviorVariableGroup__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:3869:1: ( ( rule__BehaviorVariableGroup__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:4044:1: ( ( ( rule__BehaviorVariableGroup__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:4045:1: ( ( rule__BehaviorVariableGroup__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:3869:1: ( ( rule__BehaviorVariableGroup__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:3870:2: ( rule__BehaviorVariableGroup__Group_1__0 )* + // InternalBehaviorAnnexParser.g:4045:1: ( ( rule__BehaviorVariableGroup__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:4046:2: ( rule__BehaviorVariableGroup__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:3871:2: ( rule__BehaviorVariableGroup__Group_1__0 )* - loop42: + // InternalBehaviorAnnexParser.g:4047:2: ( rule__BehaviorVariableGroup__Group_1__0 )* + loop45: do { - int alt42=2; - int LA42_0 = input.LA(1); + int alt45=2; + int LA45_0 = input.LA(1); - if ( (LA42_0==Comma) ) { - alt42=1; + if ( (LA45_0==Comma) ) { + alt45=1; } - switch (alt42) { + switch (alt45) { case 1 : - // InternalBehaviorAnnexParser.g:3871:3: rule__BehaviorVariableGroup__Group_1__0 + // InternalBehaviorAnnexParser.g:4047:3: rule__BehaviorVariableGroup__Group_1__0 { pushFollow(FollowSets000.FOLLOW_7); rule__BehaviorVariableGroup__Group_1__0(); @@ -13953,7 +14584,7 @@ public final void rule__BehaviorVariableGroup__Group__1__Impl() throws Recogniti break; default : - break loop42; + break loop45; } } while (true); @@ -13982,14 +14613,14 @@ public final void rule__BehaviorVariableGroup__Group__1__Impl() throws Recogniti // $ANTLR start "rule__BehaviorVariableGroup__Group__2" - // InternalBehaviorAnnexParser.g:3879:1: rule__BehaviorVariableGroup__Group__2 : rule__BehaviorVariableGroup__Group__2__Impl rule__BehaviorVariableGroup__Group__3 ; + // InternalBehaviorAnnexParser.g:4055:1: rule__BehaviorVariableGroup__Group__2 : rule__BehaviorVariableGroup__Group__2__Impl rule__BehaviorVariableGroup__Group__3 ; public final void rule__BehaviorVariableGroup__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3883:1: ( rule__BehaviorVariableGroup__Group__2__Impl rule__BehaviorVariableGroup__Group__3 ) - // InternalBehaviorAnnexParser.g:3884:2: rule__BehaviorVariableGroup__Group__2__Impl rule__BehaviorVariableGroup__Group__3 + // InternalBehaviorAnnexParser.g:4059:1: ( rule__BehaviorVariableGroup__Group__2__Impl rule__BehaviorVariableGroup__Group__3 ) + // InternalBehaviorAnnexParser.g:4060:2: rule__BehaviorVariableGroup__Group__2__Impl rule__BehaviorVariableGroup__Group__3 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorVariableGroup__Group__2__Impl(); @@ -14020,17 +14651,17 @@ public final void rule__BehaviorVariableGroup__Group__2() throws RecognitionExce // $ANTLR start "rule__BehaviorVariableGroup__Group__2__Impl" - // InternalBehaviorAnnexParser.g:3891:1: rule__BehaviorVariableGroup__Group__2__Impl : ( Colon ) ; + // InternalBehaviorAnnexParser.g:4067:1: rule__BehaviorVariableGroup__Group__2__Impl : ( Colon ) ; public final void rule__BehaviorVariableGroup__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3895:1: ( ( Colon ) ) - // InternalBehaviorAnnexParser.g:3896:1: ( Colon ) + // InternalBehaviorAnnexParser.g:4071:1: ( ( Colon ) ) + // InternalBehaviorAnnexParser.g:4072:1: ( Colon ) { - // InternalBehaviorAnnexParser.g:3896:1: ( Colon ) - // InternalBehaviorAnnexParser.g:3897:2: Colon + // InternalBehaviorAnnexParser.g:4072:1: ( Colon ) + // InternalBehaviorAnnexParser.g:4073:2: Colon { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getColonKeyword_2()); @@ -14061,14 +14692,14 @@ public final void rule__BehaviorVariableGroup__Group__2__Impl() throws Recogniti // $ANTLR start "rule__BehaviorVariableGroup__Group__3" - // InternalBehaviorAnnexParser.g:3906:1: rule__BehaviorVariableGroup__Group__3 : rule__BehaviorVariableGroup__Group__3__Impl rule__BehaviorVariableGroup__Group__4 ; + // InternalBehaviorAnnexParser.g:4082:1: rule__BehaviorVariableGroup__Group__3 : rule__BehaviorVariableGroup__Group__3__Impl rule__BehaviorVariableGroup__Group__4 ; public final void rule__BehaviorVariableGroup__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3910:1: ( rule__BehaviorVariableGroup__Group__3__Impl rule__BehaviorVariableGroup__Group__4 ) - // InternalBehaviorAnnexParser.g:3911:2: rule__BehaviorVariableGroup__Group__3__Impl rule__BehaviorVariableGroup__Group__4 + // InternalBehaviorAnnexParser.g:4086:1: ( rule__BehaviorVariableGroup__Group__3__Impl rule__BehaviorVariableGroup__Group__4 ) + // InternalBehaviorAnnexParser.g:4087:2: rule__BehaviorVariableGroup__Group__3__Impl rule__BehaviorVariableGroup__Group__4 { pushFollow(FollowSets000.FOLLOW_8); rule__BehaviorVariableGroup__Group__3__Impl(); @@ -14099,23 +14730,23 @@ public final void rule__BehaviorVariableGroup__Group__3() throws RecognitionExce // $ANTLR start "rule__BehaviorVariableGroup__Group__3__Impl" - // InternalBehaviorAnnexParser.g:3918:1: rule__BehaviorVariableGroup__Group__3__Impl : ( ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) ) ; + // InternalBehaviorAnnexParser.g:4094:1: rule__BehaviorVariableGroup__Group__3__Impl : ( ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) ) ; public final void rule__BehaviorVariableGroup__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3922:1: ( ( ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) ) ) - // InternalBehaviorAnnexParser.g:3923:1: ( ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) ) + // InternalBehaviorAnnexParser.g:4098:1: ( ( ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) ) ) + // InternalBehaviorAnnexParser.g:4099:1: ( ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) ) { - // InternalBehaviorAnnexParser.g:3923:1: ( ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) ) - // InternalBehaviorAnnexParser.g:3924:2: ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) + // InternalBehaviorAnnexParser.g:4099:1: ( ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) ) + // InternalBehaviorAnnexParser.g:4100:2: ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getDataClassifierAssignment_3()); } - // InternalBehaviorAnnexParser.g:3925:2: ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) - // InternalBehaviorAnnexParser.g:3925:3: rule__BehaviorVariableGroup__DataClassifierAssignment_3 + // InternalBehaviorAnnexParser.g:4101:2: ( rule__BehaviorVariableGroup__DataClassifierAssignment_3 ) + // InternalBehaviorAnnexParser.g:4101:3: rule__BehaviorVariableGroup__DataClassifierAssignment_3 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariableGroup__DataClassifierAssignment_3(); @@ -14150,14 +14781,14 @@ public final void rule__BehaviorVariableGroup__Group__3__Impl() throws Recogniti // $ANTLR start "rule__BehaviorVariableGroup__Group__4" - // InternalBehaviorAnnexParser.g:3933:1: rule__BehaviorVariableGroup__Group__4 : rule__BehaviorVariableGroup__Group__4__Impl rule__BehaviorVariableGroup__Group__5 ; + // InternalBehaviorAnnexParser.g:4109:1: rule__BehaviorVariableGroup__Group__4 : rule__BehaviorVariableGroup__Group__4__Impl rule__BehaviorVariableGroup__Group__5 ; public final void rule__BehaviorVariableGroup__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3937:1: ( rule__BehaviorVariableGroup__Group__4__Impl rule__BehaviorVariableGroup__Group__5 ) - // InternalBehaviorAnnexParser.g:3938:2: rule__BehaviorVariableGroup__Group__4__Impl rule__BehaviorVariableGroup__Group__5 + // InternalBehaviorAnnexParser.g:4113:1: ( rule__BehaviorVariableGroup__Group__4__Impl rule__BehaviorVariableGroup__Group__5 ) + // InternalBehaviorAnnexParser.g:4114:2: rule__BehaviorVariableGroup__Group__4__Impl rule__BehaviorVariableGroup__Group__5 { pushFollow(FollowSets000.FOLLOW_8); rule__BehaviorVariableGroup__Group__4__Impl(); @@ -14188,31 +14819,31 @@ public final void rule__BehaviorVariableGroup__Group__4() throws RecognitionExce // $ANTLR start "rule__BehaviorVariableGroup__Group__4__Impl" - // InternalBehaviorAnnexParser.g:3945:1: rule__BehaviorVariableGroup__Group__4__Impl : ( ( rule__BehaviorVariableGroup__Group_4__0 )? ) ; + // InternalBehaviorAnnexParser.g:4121:1: rule__BehaviorVariableGroup__Group__4__Impl : ( ( rule__BehaviorVariableGroup__Group_4__0 )? ) ; public final void rule__BehaviorVariableGroup__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3949:1: ( ( ( rule__BehaviorVariableGroup__Group_4__0 )? ) ) - // InternalBehaviorAnnexParser.g:3950:1: ( ( rule__BehaviorVariableGroup__Group_4__0 )? ) + // InternalBehaviorAnnexParser.g:4125:1: ( ( ( rule__BehaviorVariableGroup__Group_4__0 )? ) ) + // InternalBehaviorAnnexParser.g:4126:1: ( ( rule__BehaviorVariableGroup__Group_4__0 )? ) { - // InternalBehaviorAnnexParser.g:3950:1: ( ( rule__BehaviorVariableGroup__Group_4__0 )? ) - // InternalBehaviorAnnexParser.g:3951:2: ( rule__BehaviorVariableGroup__Group_4__0 )? + // InternalBehaviorAnnexParser.g:4126:1: ( ( rule__BehaviorVariableGroup__Group_4__0 )? ) + // InternalBehaviorAnnexParser.g:4127:2: ( rule__BehaviorVariableGroup__Group_4__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getGroup_4()); } - // InternalBehaviorAnnexParser.g:3952:2: ( rule__BehaviorVariableGroup__Group_4__0 )? - int alt43=2; - int LA43_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:4128:2: ( rule__BehaviorVariableGroup__Group_4__0 )? + int alt46=2; + int LA46_0 = input.LA(1); - if ( (LA43_0==ColonEqualsSign) ) { - alt43=1; + if ( (LA46_0==ColonEqualsSign) ) { + alt46=1; } - switch (alt43) { + switch (alt46) { case 1 : - // InternalBehaviorAnnexParser.g:3952:3: rule__BehaviorVariableGroup__Group_4__0 + // InternalBehaviorAnnexParser.g:4128:3: rule__BehaviorVariableGroup__Group_4__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariableGroup__Group_4__0(); @@ -14250,14 +14881,14 @@ public final void rule__BehaviorVariableGroup__Group__4__Impl() throws Recogniti // $ANTLR start "rule__BehaviorVariableGroup__Group__5" - // InternalBehaviorAnnexParser.g:3960:1: rule__BehaviorVariableGroup__Group__5 : rule__BehaviorVariableGroup__Group__5__Impl rule__BehaviorVariableGroup__Group__6 ; + // InternalBehaviorAnnexParser.g:4136:1: rule__BehaviorVariableGroup__Group__5 : rule__BehaviorVariableGroup__Group__5__Impl rule__BehaviorVariableGroup__Group__6 ; public final void rule__BehaviorVariableGroup__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3964:1: ( rule__BehaviorVariableGroup__Group__5__Impl rule__BehaviorVariableGroup__Group__6 ) - // InternalBehaviorAnnexParser.g:3965:2: rule__BehaviorVariableGroup__Group__5__Impl rule__BehaviorVariableGroup__Group__6 + // InternalBehaviorAnnexParser.g:4140:1: ( rule__BehaviorVariableGroup__Group__5__Impl rule__BehaviorVariableGroup__Group__6 ) + // InternalBehaviorAnnexParser.g:4141:2: rule__BehaviorVariableGroup__Group__5__Impl rule__BehaviorVariableGroup__Group__6 { pushFollow(FollowSets000.FOLLOW_8); rule__BehaviorVariableGroup__Group__5__Impl(); @@ -14288,31 +14919,31 @@ public final void rule__BehaviorVariableGroup__Group__5() throws RecognitionExce // $ANTLR start "rule__BehaviorVariableGroup__Group__5__Impl" - // InternalBehaviorAnnexParser.g:3972:1: rule__BehaviorVariableGroup__Group__5__Impl : ( ( rule__BehaviorVariableGroup__Group_5__0 )? ) ; + // InternalBehaviorAnnexParser.g:4148:1: rule__BehaviorVariableGroup__Group__5__Impl : ( ( rule__BehaviorVariableGroup__Group_5__0 )? ) ; public final void rule__BehaviorVariableGroup__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3976:1: ( ( ( rule__BehaviorVariableGroup__Group_5__0 )? ) ) - // InternalBehaviorAnnexParser.g:3977:1: ( ( rule__BehaviorVariableGroup__Group_5__0 )? ) + // InternalBehaviorAnnexParser.g:4152:1: ( ( ( rule__BehaviorVariableGroup__Group_5__0 )? ) ) + // InternalBehaviorAnnexParser.g:4153:1: ( ( rule__BehaviorVariableGroup__Group_5__0 )? ) { - // InternalBehaviorAnnexParser.g:3977:1: ( ( rule__BehaviorVariableGroup__Group_5__0 )? ) - // InternalBehaviorAnnexParser.g:3978:2: ( rule__BehaviorVariableGroup__Group_5__0 )? + // InternalBehaviorAnnexParser.g:4153:1: ( ( rule__BehaviorVariableGroup__Group_5__0 )? ) + // InternalBehaviorAnnexParser.g:4154:2: ( rule__BehaviorVariableGroup__Group_5__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getGroup_5()); } - // InternalBehaviorAnnexParser.g:3979:2: ( rule__BehaviorVariableGroup__Group_5__0 )? - int alt44=2; - int LA44_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:4155:2: ( rule__BehaviorVariableGroup__Group_5__0 )? + int alt47=2; + int LA47_0 = input.LA(1); - if ( (LA44_0==LeftCurlyBracket) ) { - alt44=1; + if ( (LA47_0==LeftCurlyBracket) ) { + alt47=1; } - switch (alt44) { + switch (alt47) { case 1 : - // InternalBehaviorAnnexParser.g:3979:3: rule__BehaviorVariableGroup__Group_5__0 + // InternalBehaviorAnnexParser.g:4155:3: rule__BehaviorVariableGroup__Group_5__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariableGroup__Group_5__0(); @@ -14350,14 +14981,14 @@ public final void rule__BehaviorVariableGroup__Group__5__Impl() throws Recogniti // $ANTLR start "rule__BehaviorVariableGroup__Group__6" - // InternalBehaviorAnnexParser.g:3987:1: rule__BehaviorVariableGroup__Group__6 : rule__BehaviorVariableGroup__Group__6__Impl ; + // InternalBehaviorAnnexParser.g:4163:1: rule__BehaviorVariableGroup__Group__6 : rule__BehaviorVariableGroup__Group__6__Impl ; public final void rule__BehaviorVariableGroup__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:3991:1: ( rule__BehaviorVariableGroup__Group__6__Impl ) - // InternalBehaviorAnnexParser.g:3992:2: rule__BehaviorVariableGroup__Group__6__Impl + // InternalBehaviorAnnexParser.g:4167:1: ( rule__BehaviorVariableGroup__Group__6__Impl ) + // InternalBehaviorAnnexParser.g:4168:2: rule__BehaviorVariableGroup__Group__6__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariableGroup__Group__6__Impl(); @@ -14383,17 +15014,17 @@ public final void rule__BehaviorVariableGroup__Group__6() throws RecognitionExce // $ANTLR start "rule__BehaviorVariableGroup__Group__6__Impl" - // InternalBehaviorAnnexParser.g:3998:1: rule__BehaviorVariableGroup__Group__6__Impl : ( Semicolon ) ; + // InternalBehaviorAnnexParser.g:4174:1: rule__BehaviorVariableGroup__Group__6__Impl : ( Semicolon ) ; public final void rule__BehaviorVariableGroup__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4002:1: ( ( Semicolon ) ) - // InternalBehaviorAnnexParser.g:4003:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:4178:1: ( ( Semicolon ) ) + // InternalBehaviorAnnexParser.g:4179:1: ( Semicolon ) { - // InternalBehaviorAnnexParser.g:4003:1: ( Semicolon ) - // InternalBehaviorAnnexParser.g:4004:2: Semicolon + // InternalBehaviorAnnexParser.g:4179:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:4180:2: Semicolon { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getSemicolonKeyword_6()); @@ -14424,14 +15055,14 @@ public final void rule__BehaviorVariableGroup__Group__6__Impl() throws Recogniti // $ANTLR start "rule__BehaviorVariableGroup__Group_1__0" - // InternalBehaviorAnnexParser.g:4014:1: rule__BehaviorVariableGroup__Group_1__0 : rule__BehaviorVariableGroup__Group_1__0__Impl rule__BehaviorVariableGroup__Group_1__1 ; + // InternalBehaviorAnnexParser.g:4190:1: rule__BehaviorVariableGroup__Group_1__0 : rule__BehaviorVariableGroup__Group_1__0__Impl rule__BehaviorVariableGroup__Group_1__1 ; public final void rule__BehaviorVariableGroup__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4018:1: ( rule__BehaviorVariableGroup__Group_1__0__Impl rule__BehaviorVariableGroup__Group_1__1 ) - // InternalBehaviorAnnexParser.g:4019:2: rule__BehaviorVariableGroup__Group_1__0__Impl rule__BehaviorVariableGroup__Group_1__1 + // InternalBehaviorAnnexParser.g:4194:1: ( rule__BehaviorVariableGroup__Group_1__0__Impl rule__BehaviorVariableGroup__Group_1__1 ) + // InternalBehaviorAnnexParser.g:4195:2: rule__BehaviorVariableGroup__Group_1__0__Impl rule__BehaviorVariableGroup__Group_1__1 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorVariableGroup__Group_1__0__Impl(); @@ -14462,17 +15093,17 @@ public final void rule__BehaviorVariableGroup__Group_1__0() throws RecognitionEx // $ANTLR start "rule__BehaviorVariableGroup__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:4026:1: rule__BehaviorVariableGroup__Group_1__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:4202:1: rule__BehaviorVariableGroup__Group_1__0__Impl : ( Comma ) ; public final void rule__BehaviorVariableGroup__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4030:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:4031:1: ( Comma ) + // InternalBehaviorAnnexParser.g:4206:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:4207:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:4031:1: ( Comma ) - // InternalBehaviorAnnexParser.g:4032:2: Comma + // InternalBehaviorAnnexParser.g:4207:1: ( Comma ) + // InternalBehaviorAnnexParser.g:4208:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getCommaKeyword_1_0()); @@ -14503,14 +15134,14 @@ public final void rule__BehaviorVariableGroup__Group_1__0__Impl() throws Recogni // $ANTLR start "rule__BehaviorVariableGroup__Group_1__1" - // InternalBehaviorAnnexParser.g:4041:1: rule__BehaviorVariableGroup__Group_1__1 : rule__BehaviorVariableGroup__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:4217:1: rule__BehaviorVariableGroup__Group_1__1 : rule__BehaviorVariableGroup__Group_1__1__Impl ; public final void rule__BehaviorVariableGroup__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4045:1: ( rule__BehaviorVariableGroup__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:4046:2: rule__BehaviorVariableGroup__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:4221:1: ( rule__BehaviorVariableGroup__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:4222:2: rule__BehaviorVariableGroup__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariableGroup__Group_1__1__Impl(); @@ -14536,23 +15167,23 @@ public final void rule__BehaviorVariableGroup__Group_1__1() throws RecognitionEx // $ANTLR start "rule__BehaviorVariableGroup__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:4052:1: rule__BehaviorVariableGroup__Group_1__1__Impl : ( ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:4228:1: rule__BehaviorVariableGroup__Group_1__1__Impl : ( ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) ) ; public final void rule__BehaviorVariableGroup__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4056:1: ( ( ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:4057:1: ( ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:4232:1: ( ( ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:4233:1: ( ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:4057:1: ( ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:4058:2: ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:4233:1: ( ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:4234:2: ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getVariablesAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:4059:2: ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:4059:3: rule__BehaviorVariableGroup__VariablesAssignment_1_1 + // InternalBehaviorAnnexParser.g:4235:2: ( rule__BehaviorVariableGroup__VariablesAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:4235:3: rule__BehaviorVariableGroup__VariablesAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariableGroup__VariablesAssignment_1_1(); @@ -14587,14 +15218,14 @@ public final void rule__BehaviorVariableGroup__Group_1__1__Impl() throws Recogni // $ANTLR start "rule__BehaviorVariableGroup__Group_4__0" - // InternalBehaviorAnnexParser.g:4068:1: rule__BehaviorVariableGroup__Group_4__0 : rule__BehaviorVariableGroup__Group_4__0__Impl rule__BehaviorVariableGroup__Group_4__1 ; + // InternalBehaviorAnnexParser.g:4244:1: rule__BehaviorVariableGroup__Group_4__0 : rule__BehaviorVariableGroup__Group_4__0__Impl rule__BehaviorVariableGroup__Group_4__1 ; public final void rule__BehaviorVariableGroup__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4072:1: ( rule__BehaviorVariableGroup__Group_4__0__Impl rule__BehaviorVariableGroup__Group_4__1 ) - // InternalBehaviorAnnexParser.g:4073:2: rule__BehaviorVariableGroup__Group_4__0__Impl rule__BehaviorVariableGroup__Group_4__1 + // InternalBehaviorAnnexParser.g:4248:1: ( rule__BehaviorVariableGroup__Group_4__0__Impl rule__BehaviorVariableGroup__Group_4__1 ) + // InternalBehaviorAnnexParser.g:4249:2: rule__BehaviorVariableGroup__Group_4__0__Impl rule__BehaviorVariableGroup__Group_4__1 { pushFollow(FollowSets000.FOLLOW_9); rule__BehaviorVariableGroup__Group_4__0__Impl(); @@ -14625,17 +15256,17 @@ public final void rule__BehaviorVariableGroup__Group_4__0() throws RecognitionEx // $ANTLR start "rule__BehaviorVariableGroup__Group_4__0__Impl" - // InternalBehaviorAnnexParser.g:4080:1: rule__BehaviorVariableGroup__Group_4__0__Impl : ( ColonEqualsSign ) ; + // InternalBehaviorAnnexParser.g:4256:1: rule__BehaviorVariableGroup__Group_4__0__Impl : ( ColonEqualsSign ) ; public final void rule__BehaviorVariableGroup__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4084:1: ( ( ColonEqualsSign ) ) - // InternalBehaviorAnnexParser.g:4085:1: ( ColonEqualsSign ) + // InternalBehaviorAnnexParser.g:4260:1: ( ( ColonEqualsSign ) ) + // InternalBehaviorAnnexParser.g:4261:1: ( ColonEqualsSign ) { - // InternalBehaviorAnnexParser.g:4085:1: ( ColonEqualsSign ) - // InternalBehaviorAnnexParser.g:4086:2: ColonEqualsSign + // InternalBehaviorAnnexParser.g:4261:1: ( ColonEqualsSign ) + // InternalBehaviorAnnexParser.g:4262:2: ColonEqualsSign { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getColonEqualsSignKeyword_4_0()); @@ -14666,14 +15297,14 @@ public final void rule__BehaviorVariableGroup__Group_4__0__Impl() throws Recogni // $ANTLR start "rule__BehaviorVariableGroup__Group_4__1" - // InternalBehaviorAnnexParser.g:4095:1: rule__BehaviorVariableGroup__Group_4__1 : rule__BehaviorVariableGroup__Group_4__1__Impl ; + // InternalBehaviorAnnexParser.g:4271:1: rule__BehaviorVariableGroup__Group_4__1 : rule__BehaviorVariableGroup__Group_4__1__Impl ; public final void rule__BehaviorVariableGroup__Group_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4099:1: ( rule__BehaviorVariableGroup__Group_4__1__Impl ) - // InternalBehaviorAnnexParser.g:4100:2: rule__BehaviorVariableGroup__Group_4__1__Impl + // InternalBehaviorAnnexParser.g:4275:1: ( rule__BehaviorVariableGroup__Group_4__1__Impl ) + // InternalBehaviorAnnexParser.g:4276:2: rule__BehaviorVariableGroup__Group_4__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariableGroup__Group_4__1__Impl(); @@ -14699,23 +15330,23 @@ public final void rule__BehaviorVariableGroup__Group_4__1() throws RecognitionEx // $ANTLR start "rule__BehaviorVariableGroup__Group_4__1__Impl" - // InternalBehaviorAnnexParser.g:4106:1: rule__BehaviorVariableGroup__Group_4__1__Impl : ( ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) ) ; + // InternalBehaviorAnnexParser.g:4282:1: rule__BehaviorVariableGroup__Group_4__1__Impl : ( ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) ) ; public final void rule__BehaviorVariableGroup__Group_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4110:1: ( ( ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) ) ) - // InternalBehaviorAnnexParser.g:4111:1: ( ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) ) + // InternalBehaviorAnnexParser.g:4286:1: ( ( ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) ) ) + // InternalBehaviorAnnexParser.g:4287:1: ( ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) ) { - // InternalBehaviorAnnexParser.g:4111:1: ( ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) ) - // InternalBehaviorAnnexParser.g:4112:2: ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) + // InternalBehaviorAnnexParser.g:4287:1: ( ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) ) + // InternalBehaviorAnnexParser.g:4288:2: ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getInitialValueAssignment_4_1()); } - // InternalBehaviorAnnexParser.g:4113:2: ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) - // InternalBehaviorAnnexParser.g:4113:3: rule__BehaviorVariableGroup__InitialValueAssignment_4_1 + // InternalBehaviorAnnexParser.g:4289:2: ( rule__BehaviorVariableGroup__InitialValueAssignment_4_1 ) + // InternalBehaviorAnnexParser.g:4289:3: rule__BehaviorVariableGroup__InitialValueAssignment_4_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariableGroup__InitialValueAssignment_4_1(); @@ -14750,14 +15381,14 @@ public final void rule__BehaviorVariableGroup__Group_4__1__Impl() throws Recogni // $ANTLR start "rule__BehaviorVariableGroup__Group_5__0" - // InternalBehaviorAnnexParser.g:4122:1: rule__BehaviorVariableGroup__Group_5__0 : rule__BehaviorVariableGroup__Group_5__0__Impl rule__BehaviorVariableGroup__Group_5__1 ; + // InternalBehaviorAnnexParser.g:4298:1: rule__BehaviorVariableGroup__Group_5__0 : rule__BehaviorVariableGroup__Group_5__0__Impl rule__BehaviorVariableGroup__Group_5__1 ; public final void rule__BehaviorVariableGroup__Group_5__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4126:1: ( rule__BehaviorVariableGroup__Group_5__0__Impl rule__BehaviorVariableGroup__Group_5__1 ) - // InternalBehaviorAnnexParser.g:4127:2: rule__BehaviorVariableGroup__Group_5__0__Impl rule__BehaviorVariableGroup__Group_5__1 + // InternalBehaviorAnnexParser.g:4302:1: ( rule__BehaviorVariableGroup__Group_5__0__Impl rule__BehaviorVariableGroup__Group_5__1 ) + // InternalBehaviorAnnexParser.g:4303:2: rule__BehaviorVariableGroup__Group_5__0__Impl rule__BehaviorVariableGroup__Group_5__1 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorVariableGroup__Group_5__0__Impl(); @@ -14788,17 +15419,17 @@ public final void rule__BehaviorVariableGroup__Group_5__0() throws RecognitionEx // $ANTLR start "rule__BehaviorVariableGroup__Group_5__0__Impl" - // InternalBehaviorAnnexParser.g:4134:1: rule__BehaviorVariableGroup__Group_5__0__Impl : ( LeftCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:4310:1: rule__BehaviorVariableGroup__Group_5__0__Impl : ( LeftCurlyBracket ) ; public final void rule__BehaviorVariableGroup__Group_5__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4138:1: ( ( LeftCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:4139:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:4314:1: ( ( LeftCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:4315:1: ( LeftCurlyBracket ) { - // InternalBehaviorAnnexParser.g:4139:1: ( LeftCurlyBracket ) - // InternalBehaviorAnnexParser.g:4140:2: LeftCurlyBracket + // InternalBehaviorAnnexParser.g:4315:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:4316:2: LeftCurlyBracket { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getLeftCurlyBracketKeyword_5_0()); @@ -14829,14 +15460,14 @@ public final void rule__BehaviorVariableGroup__Group_5__0__Impl() throws Recogni // $ANTLR start "rule__BehaviorVariableGroup__Group_5__1" - // InternalBehaviorAnnexParser.g:4149:1: rule__BehaviorVariableGroup__Group_5__1 : rule__BehaviorVariableGroup__Group_5__1__Impl rule__BehaviorVariableGroup__Group_5__2 ; + // InternalBehaviorAnnexParser.g:4325:1: rule__BehaviorVariableGroup__Group_5__1 : rule__BehaviorVariableGroup__Group_5__1__Impl rule__BehaviorVariableGroup__Group_5__2 ; public final void rule__BehaviorVariableGroup__Group_5__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4153:1: ( rule__BehaviorVariableGroup__Group_5__1__Impl rule__BehaviorVariableGroup__Group_5__2 ) - // InternalBehaviorAnnexParser.g:4154:2: rule__BehaviorVariableGroup__Group_5__1__Impl rule__BehaviorVariableGroup__Group_5__2 + // InternalBehaviorAnnexParser.g:4329:1: ( rule__BehaviorVariableGroup__Group_5__1__Impl rule__BehaviorVariableGroup__Group_5__2 ) + // InternalBehaviorAnnexParser.g:4330:2: rule__BehaviorVariableGroup__Group_5__1__Impl rule__BehaviorVariableGroup__Group_5__2 { pushFollow(FollowSets000.FOLLOW_10); rule__BehaviorVariableGroup__Group_5__1__Impl(); @@ -14867,26 +15498,26 @@ public final void rule__BehaviorVariableGroup__Group_5__1() throws RecognitionEx // $ANTLR start "rule__BehaviorVariableGroup__Group_5__1__Impl" - // InternalBehaviorAnnexParser.g:4161:1: rule__BehaviorVariableGroup__Group_5__1__Impl : ( ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) ) ; + // InternalBehaviorAnnexParser.g:4337:1: rule__BehaviorVariableGroup__Group_5__1__Impl : ( ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) ) ; public final void rule__BehaviorVariableGroup__Group_5__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4165:1: ( ( ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) ) ) - // InternalBehaviorAnnexParser.g:4166:1: ( ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) ) + // InternalBehaviorAnnexParser.g:4341:1: ( ( ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) ) ) + // InternalBehaviorAnnexParser.g:4342:1: ( ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) ) { - // InternalBehaviorAnnexParser.g:4166:1: ( ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) ) - // InternalBehaviorAnnexParser.g:4167:2: ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) + // InternalBehaviorAnnexParser.g:4342:1: ( ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) ) + // InternalBehaviorAnnexParser.g:4343:2: ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) { - // InternalBehaviorAnnexParser.g:4167:2: ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) - // InternalBehaviorAnnexParser.g:4168:3: ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) + // InternalBehaviorAnnexParser.g:4343:2: ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) ) + // InternalBehaviorAnnexParser.g:4344:3: ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getPropertyAssociationsAssignment_5_1()); } - // InternalBehaviorAnnexParser.g:4169:3: ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) - // InternalBehaviorAnnexParser.g:4169:4: rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 + // InternalBehaviorAnnexParser.g:4345:3: ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 ) + // InternalBehaviorAnnexParser.g:4345:4: rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 { pushFollow(FollowSets000.FOLLOW_5); rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1(); @@ -14902,26 +15533,26 @@ public final void rule__BehaviorVariableGroup__Group_5__1__Impl() throws Recogni } - // InternalBehaviorAnnexParser.g:4172:2: ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) - // InternalBehaviorAnnexParser.g:4173:3: ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* + // InternalBehaviorAnnexParser.g:4348:2: ( ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* ) + // InternalBehaviorAnnexParser.g:4349:3: ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getPropertyAssociationsAssignment_5_1()); } - // InternalBehaviorAnnexParser.g:4174:3: ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* - loop45: + // InternalBehaviorAnnexParser.g:4350:3: ( rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 )* + loop48: do { - int alt45=2; - int LA45_0 = input.LA(1); + int alt48=2; + int LA48_0 = input.LA(1); - if ( (LA45_0==RULE_ID) ) { - alt45=1; + if ( (LA48_0==RULE_ID) ) { + alt48=1; } - switch (alt45) { + switch (alt48) { case 1 : - // InternalBehaviorAnnexParser.g:4174:4: rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 + // InternalBehaviorAnnexParser.g:4350:4: rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 { pushFollow(FollowSets000.FOLLOW_5); rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1(); @@ -14933,7 +15564,7 @@ public final void rule__BehaviorVariableGroup__Group_5__1__Impl() throws Recogni break; default : - break loop45; + break loop48; } } while (true); @@ -14965,14 +15596,14 @@ public final void rule__BehaviorVariableGroup__Group_5__1__Impl() throws Recogni // $ANTLR start "rule__BehaviorVariableGroup__Group_5__2" - // InternalBehaviorAnnexParser.g:4183:1: rule__BehaviorVariableGroup__Group_5__2 : rule__BehaviorVariableGroup__Group_5__2__Impl ; + // InternalBehaviorAnnexParser.g:4359:1: rule__BehaviorVariableGroup__Group_5__2 : rule__BehaviorVariableGroup__Group_5__2__Impl ; public final void rule__BehaviorVariableGroup__Group_5__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4187:1: ( rule__BehaviorVariableGroup__Group_5__2__Impl ) - // InternalBehaviorAnnexParser.g:4188:2: rule__BehaviorVariableGroup__Group_5__2__Impl + // InternalBehaviorAnnexParser.g:4363:1: ( rule__BehaviorVariableGroup__Group_5__2__Impl ) + // InternalBehaviorAnnexParser.g:4364:2: rule__BehaviorVariableGroup__Group_5__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariableGroup__Group_5__2__Impl(); @@ -14998,17 +15629,17 @@ public final void rule__BehaviorVariableGroup__Group_5__2() throws RecognitionEx // $ANTLR start "rule__BehaviorVariableGroup__Group_5__2__Impl" - // InternalBehaviorAnnexParser.g:4194:1: rule__BehaviorVariableGroup__Group_5__2__Impl : ( RightCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:4370:1: rule__BehaviorVariableGroup__Group_5__2__Impl : ( RightCurlyBracket ) ; public final void rule__BehaviorVariableGroup__Group_5__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4198:1: ( ( RightCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:4199:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:4374:1: ( ( RightCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:4375:1: ( RightCurlyBracket ) { - // InternalBehaviorAnnexParser.g:4199:1: ( RightCurlyBracket ) - // InternalBehaviorAnnexParser.g:4200:2: RightCurlyBracket + // InternalBehaviorAnnexParser.g:4375:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:4376:2: RightCurlyBracket { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getRightCurlyBracketKeyword_5_2()); @@ -15039,14 +15670,14 @@ public final void rule__BehaviorVariableGroup__Group_5__2__Impl() throws Recogni // $ANTLR start "rule__BehaviorVariable__Group__0" - // InternalBehaviorAnnexParser.g:4210:1: rule__BehaviorVariable__Group__0 : rule__BehaviorVariable__Group__0__Impl rule__BehaviorVariable__Group__1 ; + // InternalBehaviorAnnexParser.g:4386:1: rule__BehaviorVariable__Group__0 : rule__BehaviorVariable__Group__0__Impl rule__BehaviorVariable__Group__1 ; public final void rule__BehaviorVariable__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4214:1: ( rule__BehaviorVariable__Group__0__Impl rule__BehaviorVariable__Group__1 ) - // InternalBehaviorAnnexParser.g:4215:2: rule__BehaviorVariable__Group__0__Impl rule__BehaviorVariable__Group__1 + // InternalBehaviorAnnexParser.g:4390:1: ( rule__BehaviorVariable__Group__0__Impl rule__BehaviorVariable__Group__1 ) + // InternalBehaviorAnnexParser.g:4391:2: rule__BehaviorVariable__Group__0__Impl rule__BehaviorVariable__Group__1 { pushFollow(FollowSets000.FOLLOW_11); rule__BehaviorVariable__Group__0__Impl(); @@ -15077,23 +15708,23 @@ public final void rule__BehaviorVariable__Group__0() throws RecognitionException // $ANTLR start "rule__BehaviorVariable__Group__0__Impl" - // InternalBehaviorAnnexParser.g:4222:1: rule__BehaviorVariable__Group__0__Impl : ( ( rule__BehaviorVariable__NameAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:4398:1: rule__BehaviorVariable__Group__0__Impl : ( ( rule__BehaviorVariable__NameAssignment_0 ) ) ; public final void rule__BehaviorVariable__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4226:1: ( ( ( rule__BehaviorVariable__NameAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:4227:1: ( ( rule__BehaviorVariable__NameAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:4402:1: ( ( ( rule__BehaviorVariable__NameAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:4403:1: ( ( rule__BehaviorVariable__NameAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:4227:1: ( ( rule__BehaviorVariable__NameAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:4228:2: ( rule__BehaviorVariable__NameAssignment_0 ) + // InternalBehaviorAnnexParser.g:4403:1: ( ( rule__BehaviorVariable__NameAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:4404:2: ( rule__BehaviorVariable__NameAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableAccess().getNameAssignment_0()); } - // InternalBehaviorAnnexParser.g:4229:2: ( rule__BehaviorVariable__NameAssignment_0 ) - // InternalBehaviorAnnexParser.g:4229:3: rule__BehaviorVariable__NameAssignment_0 + // InternalBehaviorAnnexParser.g:4405:2: ( rule__BehaviorVariable__NameAssignment_0 ) + // InternalBehaviorAnnexParser.g:4405:3: rule__BehaviorVariable__NameAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariable__NameAssignment_0(); @@ -15128,14 +15759,14 @@ public final void rule__BehaviorVariable__Group__0__Impl() throws RecognitionExc // $ANTLR start "rule__BehaviorVariable__Group__1" - // InternalBehaviorAnnexParser.g:4237:1: rule__BehaviorVariable__Group__1 : rule__BehaviorVariable__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:4413:1: rule__BehaviorVariable__Group__1 : rule__BehaviorVariable__Group__1__Impl ; public final void rule__BehaviorVariable__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4241:1: ( rule__BehaviorVariable__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:4242:2: rule__BehaviorVariable__Group__1__Impl + // InternalBehaviorAnnexParser.g:4417:1: ( rule__BehaviorVariable__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:4418:2: rule__BehaviorVariable__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorVariable__Group__1__Impl(); @@ -15161,35 +15792,35 @@ public final void rule__BehaviorVariable__Group__1() throws RecognitionException // $ANTLR start "rule__BehaviorVariable__Group__1__Impl" - // InternalBehaviorAnnexParser.g:4248:1: rule__BehaviorVariable__Group__1__Impl : ( ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* ) ; + // InternalBehaviorAnnexParser.g:4424:1: rule__BehaviorVariable__Group__1__Impl : ( ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* ) ; public final void rule__BehaviorVariable__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4252:1: ( ( ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* ) ) - // InternalBehaviorAnnexParser.g:4253:1: ( ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:4428:1: ( ( ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* ) ) + // InternalBehaviorAnnexParser.g:4429:1: ( ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* ) { - // InternalBehaviorAnnexParser.g:4253:1: ( ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* ) - // InternalBehaviorAnnexParser.g:4254:2: ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* + // InternalBehaviorAnnexParser.g:4429:1: ( ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:4430:2: ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableAccess().getArrayDimensionsAssignment_1()); } - // InternalBehaviorAnnexParser.g:4255:2: ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* - loop46: + // InternalBehaviorAnnexParser.g:4431:2: ( rule__BehaviorVariable__ArrayDimensionsAssignment_1 )* + loop49: do { - int alt46=2; - int LA46_0 = input.LA(1); + int alt49=2; + int LA49_0 = input.LA(1); - if ( (LA46_0==LeftSquareBracket) ) { - alt46=1; + if ( (LA49_0==LeftSquareBracket) ) { + alt49=1; } - switch (alt46) { + switch (alt49) { case 1 : - // InternalBehaviorAnnexParser.g:4255:3: rule__BehaviorVariable__ArrayDimensionsAssignment_1 + // InternalBehaviorAnnexParser.g:4431:3: rule__BehaviorVariable__ArrayDimensionsAssignment_1 { pushFollow(FollowSets000.FOLLOW_12); rule__BehaviorVariable__ArrayDimensionsAssignment_1(); @@ -15201,7 +15832,7 @@ public final void rule__BehaviorVariable__Group__1__Impl() throws RecognitionExc break; default : - break loop46; + break loop49; } } while (true); @@ -15230,14 +15861,14 @@ public final void rule__BehaviorVariable__Group__1__Impl() throws RecognitionExc // $ANTLR start "rule__ArrayDimension__Group__0" - // InternalBehaviorAnnexParser.g:4264:1: rule__ArrayDimension__Group__0 : rule__ArrayDimension__Group__0__Impl rule__ArrayDimension__Group__1 ; + // InternalBehaviorAnnexParser.g:4440:1: rule__ArrayDimension__Group__0 : rule__ArrayDimension__Group__0__Impl rule__ArrayDimension__Group__1 ; public final void rule__ArrayDimension__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4268:1: ( rule__ArrayDimension__Group__0__Impl rule__ArrayDimension__Group__1 ) - // InternalBehaviorAnnexParser.g:4269:2: rule__ArrayDimension__Group__0__Impl rule__ArrayDimension__Group__1 + // InternalBehaviorAnnexParser.g:4444:1: ( rule__ArrayDimension__Group__0__Impl rule__ArrayDimension__Group__1 ) + // InternalBehaviorAnnexParser.g:4445:2: rule__ArrayDimension__Group__0__Impl rule__ArrayDimension__Group__1 { pushFollow(FollowSets000.FOLLOW_13); rule__ArrayDimension__Group__0__Impl(); @@ -15268,17 +15899,17 @@ public final void rule__ArrayDimension__Group__0() throws RecognitionException { // $ANTLR start "rule__ArrayDimension__Group__0__Impl" - // InternalBehaviorAnnexParser.g:4276:1: rule__ArrayDimension__Group__0__Impl : ( LeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:4452:1: rule__ArrayDimension__Group__0__Impl : ( LeftSquareBracket ) ; public final void rule__ArrayDimension__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4280:1: ( ( LeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:4281:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:4456:1: ( ( LeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:4457:1: ( LeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:4281:1: ( LeftSquareBracket ) - // InternalBehaviorAnnexParser.g:4282:2: LeftSquareBracket + // InternalBehaviorAnnexParser.g:4457:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:4458:2: LeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getArrayDimensionAccess().getLeftSquareBracketKeyword_0()); @@ -15309,14 +15940,14 @@ public final void rule__ArrayDimension__Group__0__Impl() throws RecognitionExcep // $ANTLR start "rule__ArrayDimension__Group__1" - // InternalBehaviorAnnexParser.g:4291:1: rule__ArrayDimension__Group__1 : rule__ArrayDimension__Group__1__Impl rule__ArrayDimension__Group__2 ; + // InternalBehaviorAnnexParser.g:4467:1: rule__ArrayDimension__Group__1 : rule__ArrayDimension__Group__1__Impl rule__ArrayDimension__Group__2 ; public final void rule__ArrayDimension__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4295:1: ( rule__ArrayDimension__Group__1__Impl rule__ArrayDimension__Group__2 ) - // InternalBehaviorAnnexParser.g:4296:2: rule__ArrayDimension__Group__1__Impl rule__ArrayDimension__Group__2 + // InternalBehaviorAnnexParser.g:4471:1: ( rule__ArrayDimension__Group__1__Impl rule__ArrayDimension__Group__2 ) + // InternalBehaviorAnnexParser.g:4472:2: rule__ArrayDimension__Group__1__Impl rule__ArrayDimension__Group__2 { pushFollow(FollowSets000.FOLLOW_14); rule__ArrayDimension__Group__1__Impl(); @@ -15347,23 +15978,23 @@ public final void rule__ArrayDimension__Group__1() throws RecognitionException { // $ANTLR start "rule__ArrayDimension__Group__1__Impl" - // InternalBehaviorAnnexParser.g:4303:1: rule__ArrayDimension__Group__1__Impl : ( ( rule__ArrayDimension__SizeAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:4479:1: rule__ArrayDimension__Group__1__Impl : ( ( rule__ArrayDimension__SizeAssignment_1 ) ) ; public final void rule__ArrayDimension__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4307:1: ( ( ( rule__ArrayDimension__SizeAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:4308:1: ( ( rule__ArrayDimension__SizeAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:4483:1: ( ( ( rule__ArrayDimension__SizeAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:4484:1: ( ( rule__ArrayDimension__SizeAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:4308:1: ( ( rule__ArrayDimension__SizeAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:4309:2: ( rule__ArrayDimension__SizeAssignment_1 ) + // InternalBehaviorAnnexParser.g:4484:1: ( ( rule__ArrayDimension__SizeAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:4485:2: ( rule__ArrayDimension__SizeAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getArrayDimensionAccess().getSizeAssignment_1()); } - // InternalBehaviorAnnexParser.g:4310:2: ( rule__ArrayDimension__SizeAssignment_1 ) - // InternalBehaviorAnnexParser.g:4310:3: rule__ArrayDimension__SizeAssignment_1 + // InternalBehaviorAnnexParser.g:4486:2: ( rule__ArrayDimension__SizeAssignment_1 ) + // InternalBehaviorAnnexParser.g:4486:3: rule__ArrayDimension__SizeAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayDimension__SizeAssignment_1(); @@ -15398,14 +16029,14 @@ public final void rule__ArrayDimension__Group__1__Impl() throws RecognitionExcep // $ANTLR start "rule__ArrayDimension__Group__2" - // InternalBehaviorAnnexParser.g:4318:1: rule__ArrayDimension__Group__2 : rule__ArrayDimension__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:4494:1: rule__ArrayDimension__Group__2 : rule__ArrayDimension__Group__2__Impl ; public final void rule__ArrayDimension__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4322:1: ( rule__ArrayDimension__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:4323:2: rule__ArrayDimension__Group__2__Impl + // InternalBehaviorAnnexParser.g:4498:1: ( rule__ArrayDimension__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:4499:2: rule__ArrayDimension__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayDimension__Group__2__Impl(); @@ -15431,17 +16062,17 @@ public final void rule__ArrayDimension__Group__2() throws RecognitionException { // $ANTLR start "rule__ArrayDimension__Group__2__Impl" - // InternalBehaviorAnnexParser.g:4329:1: rule__ArrayDimension__Group__2__Impl : ( RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:4505:1: rule__ArrayDimension__Group__2__Impl : ( RightSquareBracket ) ; public final void rule__ArrayDimension__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4333:1: ( ( RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:4334:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:4509:1: ( ( RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:4510:1: ( RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:4334:1: ( RightSquareBracket ) - // InternalBehaviorAnnexParser.g:4335:2: RightSquareBracket + // InternalBehaviorAnnexParser.g:4510:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:4511:2: RightSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getArrayDimensionAccess().getRightSquareBracketKeyword_2()); @@ -15472,14 +16103,14 @@ public final void rule__ArrayDimension__Group__2__Impl() throws RecognitionExcep // $ANTLR start "rule__BehaviorPropertyAssociation__Group__0" - // InternalBehaviorAnnexParser.g:4345:1: rule__BehaviorPropertyAssociation__Group__0 : rule__BehaviorPropertyAssociation__Group__0__Impl rule__BehaviorPropertyAssociation__Group__1 ; + // InternalBehaviorAnnexParser.g:4521:1: rule__BehaviorPropertyAssociation__Group__0 : rule__BehaviorPropertyAssociation__Group__0__Impl rule__BehaviorPropertyAssociation__Group__1 ; public final void rule__BehaviorPropertyAssociation__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4349:1: ( rule__BehaviorPropertyAssociation__Group__0__Impl rule__BehaviorPropertyAssociation__Group__1 ) - // InternalBehaviorAnnexParser.g:4350:2: rule__BehaviorPropertyAssociation__Group__0__Impl rule__BehaviorPropertyAssociation__Group__1 + // InternalBehaviorAnnexParser.g:4525:1: ( rule__BehaviorPropertyAssociation__Group__0__Impl rule__BehaviorPropertyAssociation__Group__1 ) + // InternalBehaviorAnnexParser.g:4526:2: rule__BehaviorPropertyAssociation__Group__0__Impl rule__BehaviorPropertyAssociation__Group__1 { pushFollow(FollowSets000.FOLLOW_15); rule__BehaviorPropertyAssociation__Group__0__Impl(); @@ -15510,23 +16141,23 @@ public final void rule__BehaviorPropertyAssociation__Group__0() throws Recogniti // $ANTLR start "rule__BehaviorPropertyAssociation__Group__0__Impl" - // InternalBehaviorAnnexParser.g:4357:1: rule__BehaviorPropertyAssociation__Group__0__Impl : ( ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:4533:1: rule__BehaviorPropertyAssociation__Group__0__Impl : ( ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) ) ; public final void rule__BehaviorPropertyAssociation__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4361:1: ( ( ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:4362:1: ( ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:4537:1: ( ( ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:4538:1: ( ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:4362:1: ( ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:4363:2: ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) + // InternalBehaviorAnnexParser.g:4538:1: ( ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:4539:2: ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorPropertyAssociationAccess().getPropertyAssignment_0()); } - // InternalBehaviorAnnexParser.g:4364:2: ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) - // InternalBehaviorAnnexParser.g:4364:3: rule__BehaviorPropertyAssociation__PropertyAssignment_0 + // InternalBehaviorAnnexParser.g:4540:2: ( rule__BehaviorPropertyAssociation__PropertyAssignment_0 ) + // InternalBehaviorAnnexParser.g:4540:3: rule__BehaviorPropertyAssociation__PropertyAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorPropertyAssociation__PropertyAssignment_0(); @@ -15561,14 +16192,14 @@ public final void rule__BehaviorPropertyAssociation__Group__0__Impl() throws Rec // $ANTLR start "rule__BehaviorPropertyAssociation__Group__1" - // InternalBehaviorAnnexParser.g:4372:1: rule__BehaviorPropertyAssociation__Group__1 : rule__BehaviorPropertyAssociation__Group__1__Impl rule__BehaviorPropertyAssociation__Group__2 ; + // InternalBehaviorAnnexParser.g:4548:1: rule__BehaviorPropertyAssociation__Group__1 : rule__BehaviorPropertyAssociation__Group__1__Impl rule__BehaviorPropertyAssociation__Group__2 ; public final void rule__BehaviorPropertyAssociation__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4376:1: ( rule__BehaviorPropertyAssociation__Group__1__Impl rule__BehaviorPropertyAssociation__Group__2 ) - // InternalBehaviorAnnexParser.g:4377:2: rule__BehaviorPropertyAssociation__Group__1__Impl rule__BehaviorPropertyAssociation__Group__2 + // InternalBehaviorAnnexParser.g:4552:1: ( rule__BehaviorPropertyAssociation__Group__1__Impl rule__BehaviorPropertyAssociation__Group__2 ) + // InternalBehaviorAnnexParser.g:4553:2: rule__BehaviorPropertyAssociation__Group__1__Impl rule__BehaviorPropertyAssociation__Group__2 { pushFollow(FollowSets000.FOLLOW_16); rule__BehaviorPropertyAssociation__Group__1__Impl(); @@ -15599,17 +16230,17 @@ public final void rule__BehaviorPropertyAssociation__Group__1() throws Recogniti // $ANTLR start "rule__BehaviorPropertyAssociation__Group__1__Impl" - // InternalBehaviorAnnexParser.g:4384:1: rule__BehaviorPropertyAssociation__Group__1__Impl : ( EqualsSignGreaterThanSign ) ; + // InternalBehaviorAnnexParser.g:4560:1: rule__BehaviorPropertyAssociation__Group__1__Impl : ( EqualsSignGreaterThanSign ) ; public final void rule__BehaviorPropertyAssociation__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4388:1: ( ( EqualsSignGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:4389:1: ( EqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:4564:1: ( ( EqualsSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:4565:1: ( EqualsSignGreaterThanSign ) { - // InternalBehaviorAnnexParser.g:4389:1: ( EqualsSignGreaterThanSign ) - // InternalBehaviorAnnexParser.g:4390:2: EqualsSignGreaterThanSign + // InternalBehaviorAnnexParser.g:4565:1: ( EqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:4566:2: EqualsSignGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorPropertyAssociationAccess().getEqualsSignGreaterThanSignKeyword_1()); @@ -15640,14 +16271,14 @@ public final void rule__BehaviorPropertyAssociation__Group__1__Impl() throws Rec // $ANTLR start "rule__BehaviorPropertyAssociation__Group__2" - // InternalBehaviorAnnexParser.g:4399:1: rule__BehaviorPropertyAssociation__Group__2 : rule__BehaviorPropertyAssociation__Group__2__Impl rule__BehaviorPropertyAssociation__Group__3 ; + // InternalBehaviorAnnexParser.g:4575:1: rule__BehaviorPropertyAssociation__Group__2 : rule__BehaviorPropertyAssociation__Group__2__Impl rule__BehaviorPropertyAssociation__Group__3 ; public final void rule__BehaviorPropertyAssociation__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4403:1: ( rule__BehaviorPropertyAssociation__Group__2__Impl rule__BehaviorPropertyAssociation__Group__3 ) - // InternalBehaviorAnnexParser.g:4404:2: rule__BehaviorPropertyAssociation__Group__2__Impl rule__BehaviorPropertyAssociation__Group__3 + // InternalBehaviorAnnexParser.g:4579:1: ( rule__BehaviorPropertyAssociation__Group__2__Impl rule__BehaviorPropertyAssociation__Group__3 ) + // InternalBehaviorAnnexParser.g:4580:2: rule__BehaviorPropertyAssociation__Group__2__Impl rule__BehaviorPropertyAssociation__Group__3 { pushFollow(FollowSets000.FOLLOW_17); rule__BehaviorPropertyAssociation__Group__2__Impl(); @@ -15678,23 +16309,23 @@ public final void rule__BehaviorPropertyAssociation__Group__2() throws Recogniti // $ANTLR start "rule__BehaviorPropertyAssociation__Group__2__Impl" - // InternalBehaviorAnnexParser.g:4411:1: rule__BehaviorPropertyAssociation__Group__2__Impl : ( ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:4587:1: rule__BehaviorPropertyAssociation__Group__2__Impl : ( ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) ) ; public final void rule__BehaviorPropertyAssociation__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4415:1: ( ( ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:4416:1: ( ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:4591:1: ( ( ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:4592:1: ( ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:4416:1: ( ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:4417:2: ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) + // InternalBehaviorAnnexParser.g:4592:1: ( ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:4593:2: ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorPropertyAssociationAccess().getOwnedValueAssignment_2()); } - // InternalBehaviorAnnexParser.g:4418:2: ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) - // InternalBehaviorAnnexParser.g:4418:3: rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 + // InternalBehaviorAnnexParser.g:4594:2: ( rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 ) + // InternalBehaviorAnnexParser.g:4594:3: rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorPropertyAssociation__OwnedValueAssignment_2(); @@ -15729,14 +16360,14 @@ public final void rule__BehaviorPropertyAssociation__Group__2__Impl() throws Rec // $ANTLR start "rule__BehaviorPropertyAssociation__Group__3" - // InternalBehaviorAnnexParser.g:4426:1: rule__BehaviorPropertyAssociation__Group__3 : rule__BehaviorPropertyAssociation__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:4602:1: rule__BehaviorPropertyAssociation__Group__3 : rule__BehaviorPropertyAssociation__Group__3__Impl ; public final void rule__BehaviorPropertyAssociation__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4430:1: ( rule__BehaviorPropertyAssociation__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:4431:2: rule__BehaviorPropertyAssociation__Group__3__Impl + // InternalBehaviorAnnexParser.g:4606:1: ( rule__BehaviorPropertyAssociation__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:4607:2: rule__BehaviorPropertyAssociation__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorPropertyAssociation__Group__3__Impl(); @@ -15762,17 +16393,17 @@ public final void rule__BehaviorPropertyAssociation__Group__3() throws Recogniti // $ANTLR start "rule__BehaviorPropertyAssociation__Group__3__Impl" - // InternalBehaviorAnnexParser.g:4437:1: rule__BehaviorPropertyAssociation__Group__3__Impl : ( Semicolon ) ; + // InternalBehaviorAnnexParser.g:4613:1: rule__BehaviorPropertyAssociation__Group__3__Impl : ( Semicolon ) ; public final void rule__BehaviorPropertyAssociation__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4441:1: ( ( Semicolon ) ) - // InternalBehaviorAnnexParser.g:4442:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:4617:1: ( ( Semicolon ) ) + // InternalBehaviorAnnexParser.g:4618:1: ( Semicolon ) { - // InternalBehaviorAnnexParser.g:4442:1: ( Semicolon ) - // InternalBehaviorAnnexParser.g:4443:2: Semicolon + // InternalBehaviorAnnexParser.g:4618:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:4619:2: Semicolon { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorPropertyAssociationAccess().getSemicolonKeyword_3()); @@ -15803,14 +16434,14 @@ public final void rule__BehaviorPropertyAssociation__Group__3__Impl() throws Rec // $ANTLR start "rule__BehaviorStateGroup__Group__0" - // InternalBehaviorAnnexParser.g:4453:1: rule__BehaviorStateGroup__Group__0 : rule__BehaviorStateGroup__Group__0__Impl rule__BehaviorStateGroup__Group__1 ; + // InternalBehaviorAnnexParser.g:4629:1: rule__BehaviorStateGroup__Group__0 : rule__BehaviorStateGroup__Group__0__Impl rule__BehaviorStateGroup__Group__1 ; public final void rule__BehaviorStateGroup__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4457:1: ( rule__BehaviorStateGroup__Group__0__Impl rule__BehaviorStateGroup__Group__1 ) - // InternalBehaviorAnnexParser.g:4458:2: rule__BehaviorStateGroup__Group__0__Impl rule__BehaviorStateGroup__Group__1 + // InternalBehaviorAnnexParser.g:4633:1: ( rule__BehaviorStateGroup__Group__0__Impl rule__BehaviorStateGroup__Group__1 ) + // InternalBehaviorAnnexParser.g:4634:2: rule__BehaviorStateGroup__Group__0__Impl rule__BehaviorStateGroup__Group__1 { pushFollow(FollowSets000.FOLLOW_6); rule__BehaviorStateGroup__Group__0__Impl(); @@ -15841,23 +16472,23 @@ public final void rule__BehaviorStateGroup__Group__0() throws RecognitionExcepti // $ANTLR start "rule__BehaviorStateGroup__Group__0__Impl" - // InternalBehaviorAnnexParser.g:4465:1: rule__BehaviorStateGroup__Group__0__Impl : ( ( rule__BehaviorStateGroup__StatesAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:4641:1: rule__BehaviorStateGroup__Group__0__Impl : ( ( rule__BehaviorStateGroup__StatesAssignment_0 ) ) ; public final void rule__BehaviorStateGroup__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4469:1: ( ( ( rule__BehaviorStateGroup__StatesAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:4470:1: ( ( rule__BehaviorStateGroup__StatesAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:4645:1: ( ( ( rule__BehaviorStateGroup__StatesAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:4646:1: ( ( rule__BehaviorStateGroup__StatesAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:4470:1: ( ( rule__BehaviorStateGroup__StatesAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:4471:2: ( rule__BehaviorStateGroup__StatesAssignment_0 ) + // InternalBehaviorAnnexParser.g:4646:1: ( ( rule__BehaviorStateGroup__StatesAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:4647:2: ( rule__BehaviorStateGroup__StatesAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getStatesAssignment_0()); } - // InternalBehaviorAnnexParser.g:4472:2: ( rule__BehaviorStateGroup__StatesAssignment_0 ) - // InternalBehaviorAnnexParser.g:4472:3: rule__BehaviorStateGroup__StatesAssignment_0 + // InternalBehaviorAnnexParser.g:4648:2: ( rule__BehaviorStateGroup__StatesAssignment_0 ) + // InternalBehaviorAnnexParser.g:4648:3: rule__BehaviorStateGroup__StatesAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorStateGroup__StatesAssignment_0(); @@ -15892,14 +16523,14 @@ public final void rule__BehaviorStateGroup__Group__0__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorStateGroup__Group__1" - // InternalBehaviorAnnexParser.g:4480:1: rule__BehaviorStateGroup__Group__1 : rule__BehaviorStateGroup__Group__1__Impl rule__BehaviorStateGroup__Group__2 ; + // InternalBehaviorAnnexParser.g:4656:1: rule__BehaviorStateGroup__Group__1 : rule__BehaviorStateGroup__Group__1__Impl rule__BehaviorStateGroup__Group__2 ; public final void rule__BehaviorStateGroup__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4484:1: ( rule__BehaviorStateGroup__Group__1__Impl rule__BehaviorStateGroup__Group__2 ) - // InternalBehaviorAnnexParser.g:4485:2: rule__BehaviorStateGroup__Group__1__Impl rule__BehaviorStateGroup__Group__2 + // InternalBehaviorAnnexParser.g:4660:1: ( rule__BehaviorStateGroup__Group__1__Impl rule__BehaviorStateGroup__Group__2 ) + // InternalBehaviorAnnexParser.g:4661:2: rule__BehaviorStateGroup__Group__1__Impl rule__BehaviorStateGroup__Group__2 { pushFollow(FollowSets000.FOLLOW_6); rule__BehaviorStateGroup__Group__1__Impl(); @@ -15930,35 +16561,35 @@ public final void rule__BehaviorStateGroup__Group__1() throws RecognitionExcepti // $ANTLR start "rule__BehaviorStateGroup__Group__1__Impl" - // InternalBehaviorAnnexParser.g:4492:1: rule__BehaviorStateGroup__Group__1__Impl : ( ( rule__BehaviorStateGroup__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:4668:1: rule__BehaviorStateGroup__Group__1__Impl : ( ( rule__BehaviorStateGroup__Group_1__0 )* ) ; public final void rule__BehaviorStateGroup__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4496:1: ( ( ( rule__BehaviorStateGroup__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:4497:1: ( ( rule__BehaviorStateGroup__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:4672:1: ( ( ( rule__BehaviorStateGroup__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:4673:1: ( ( rule__BehaviorStateGroup__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:4497:1: ( ( rule__BehaviorStateGroup__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:4498:2: ( rule__BehaviorStateGroup__Group_1__0 )* + // InternalBehaviorAnnexParser.g:4673:1: ( ( rule__BehaviorStateGroup__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:4674:2: ( rule__BehaviorStateGroup__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:4499:2: ( rule__BehaviorStateGroup__Group_1__0 )* - loop47: + // InternalBehaviorAnnexParser.g:4675:2: ( rule__BehaviorStateGroup__Group_1__0 )* + loop50: do { - int alt47=2; - int LA47_0 = input.LA(1); + int alt50=2; + int LA50_0 = input.LA(1); - if ( (LA47_0==Comma) ) { - alt47=1; + if ( (LA50_0==Comma) ) { + alt50=1; } - switch (alt47) { + switch (alt50) { case 1 : - // InternalBehaviorAnnexParser.g:4499:3: rule__BehaviorStateGroup__Group_1__0 + // InternalBehaviorAnnexParser.g:4675:3: rule__BehaviorStateGroup__Group_1__0 { pushFollow(FollowSets000.FOLLOW_7); rule__BehaviorStateGroup__Group_1__0(); @@ -15970,7 +16601,7 @@ public final void rule__BehaviorStateGroup__Group__1__Impl() throws RecognitionE break; default : - break loop47; + break loop50; } } while (true); @@ -15999,14 +16630,14 @@ public final void rule__BehaviorStateGroup__Group__1__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorStateGroup__Group__2" - // InternalBehaviorAnnexParser.g:4507:1: rule__BehaviorStateGroup__Group__2 : rule__BehaviorStateGroup__Group__2__Impl rule__BehaviorStateGroup__Group__3 ; + // InternalBehaviorAnnexParser.g:4683:1: rule__BehaviorStateGroup__Group__2 : rule__BehaviorStateGroup__Group__2__Impl rule__BehaviorStateGroup__Group__3 ; public final void rule__BehaviorStateGroup__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4511:1: ( rule__BehaviorStateGroup__Group__2__Impl rule__BehaviorStateGroup__Group__3 ) - // InternalBehaviorAnnexParser.g:4512:2: rule__BehaviorStateGroup__Group__2__Impl rule__BehaviorStateGroup__Group__3 + // InternalBehaviorAnnexParser.g:4687:1: ( rule__BehaviorStateGroup__Group__2__Impl rule__BehaviorStateGroup__Group__3 ) + // InternalBehaviorAnnexParser.g:4688:2: rule__BehaviorStateGroup__Group__2__Impl rule__BehaviorStateGroup__Group__3 { pushFollow(FollowSets000.FOLLOW_18); rule__BehaviorStateGroup__Group__2__Impl(); @@ -16037,17 +16668,17 @@ public final void rule__BehaviorStateGroup__Group__2() throws RecognitionExcepti // $ANTLR start "rule__BehaviorStateGroup__Group__2__Impl" - // InternalBehaviorAnnexParser.g:4519:1: rule__BehaviorStateGroup__Group__2__Impl : ( Colon ) ; + // InternalBehaviorAnnexParser.g:4695:1: rule__BehaviorStateGroup__Group__2__Impl : ( Colon ) ; public final void rule__BehaviorStateGroup__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4523:1: ( ( Colon ) ) - // InternalBehaviorAnnexParser.g:4524:1: ( Colon ) + // InternalBehaviorAnnexParser.g:4699:1: ( ( Colon ) ) + // InternalBehaviorAnnexParser.g:4700:1: ( Colon ) { - // InternalBehaviorAnnexParser.g:4524:1: ( Colon ) - // InternalBehaviorAnnexParser.g:4525:2: Colon + // InternalBehaviorAnnexParser.g:4700:1: ( Colon ) + // InternalBehaviorAnnexParser.g:4701:2: Colon { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getColonKeyword_2()); @@ -16078,14 +16709,14 @@ public final void rule__BehaviorStateGroup__Group__2__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorStateGroup__Group__3" - // InternalBehaviorAnnexParser.g:4534:1: rule__BehaviorStateGroup__Group__3 : rule__BehaviorStateGroup__Group__3__Impl rule__BehaviorStateGroup__Group__4 ; + // InternalBehaviorAnnexParser.g:4710:1: rule__BehaviorStateGroup__Group__3 : rule__BehaviorStateGroup__Group__3__Impl rule__BehaviorStateGroup__Group__4 ; public final void rule__BehaviorStateGroup__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4538:1: ( rule__BehaviorStateGroup__Group__3__Impl rule__BehaviorStateGroup__Group__4 ) - // InternalBehaviorAnnexParser.g:4539:2: rule__BehaviorStateGroup__Group__3__Impl rule__BehaviorStateGroup__Group__4 + // InternalBehaviorAnnexParser.g:4714:1: ( rule__BehaviorStateGroup__Group__3__Impl rule__BehaviorStateGroup__Group__4 ) + // InternalBehaviorAnnexParser.g:4715:2: rule__BehaviorStateGroup__Group__3__Impl rule__BehaviorStateGroup__Group__4 { pushFollow(FollowSets000.FOLLOW_18); rule__BehaviorStateGroup__Group__3__Impl(); @@ -16116,31 +16747,31 @@ public final void rule__BehaviorStateGroup__Group__3() throws RecognitionExcepti // $ANTLR start "rule__BehaviorStateGroup__Group__3__Impl" - // InternalBehaviorAnnexParser.g:4546:1: rule__BehaviorStateGroup__Group__3__Impl : ( ( rule__BehaviorStateGroup__InitialAssignment_3 )? ) ; + // InternalBehaviorAnnexParser.g:4722:1: rule__BehaviorStateGroup__Group__3__Impl : ( ( rule__BehaviorStateGroup__InitialAssignment_3 )? ) ; public final void rule__BehaviorStateGroup__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4550:1: ( ( ( rule__BehaviorStateGroup__InitialAssignment_3 )? ) ) - // InternalBehaviorAnnexParser.g:4551:1: ( ( rule__BehaviorStateGroup__InitialAssignment_3 )? ) + // InternalBehaviorAnnexParser.g:4726:1: ( ( ( rule__BehaviorStateGroup__InitialAssignment_3 )? ) ) + // InternalBehaviorAnnexParser.g:4727:1: ( ( rule__BehaviorStateGroup__InitialAssignment_3 )? ) { - // InternalBehaviorAnnexParser.g:4551:1: ( ( rule__BehaviorStateGroup__InitialAssignment_3 )? ) - // InternalBehaviorAnnexParser.g:4552:2: ( rule__BehaviorStateGroup__InitialAssignment_3 )? + // InternalBehaviorAnnexParser.g:4727:1: ( ( rule__BehaviorStateGroup__InitialAssignment_3 )? ) + // InternalBehaviorAnnexParser.g:4728:2: ( rule__BehaviorStateGroup__InitialAssignment_3 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getInitialAssignment_3()); } - // InternalBehaviorAnnexParser.g:4553:2: ( rule__BehaviorStateGroup__InitialAssignment_3 )? - int alt48=2; - int LA48_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:4729:2: ( rule__BehaviorStateGroup__InitialAssignment_3 )? + int alt51=2; + int LA51_0 = input.LA(1); - if ( (LA48_0==Initial) ) { - alt48=1; + if ( (LA51_0==Initial) ) { + alt51=1; } - switch (alt48) { + switch (alt51) { case 1 : - // InternalBehaviorAnnexParser.g:4553:3: rule__BehaviorStateGroup__InitialAssignment_3 + // InternalBehaviorAnnexParser.g:4729:3: rule__BehaviorStateGroup__InitialAssignment_3 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorStateGroup__InitialAssignment_3(); @@ -16178,14 +16809,14 @@ public final void rule__BehaviorStateGroup__Group__3__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorStateGroup__Group__4" - // InternalBehaviorAnnexParser.g:4561:1: rule__BehaviorStateGroup__Group__4 : rule__BehaviorStateGroup__Group__4__Impl rule__BehaviorStateGroup__Group__5 ; + // InternalBehaviorAnnexParser.g:4737:1: rule__BehaviorStateGroup__Group__4 : rule__BehaviorStateGroup__Group__4__Impl rule__BehaviorStateGroup__Group__5 ; public final void rule__BehaviorStateGroup__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4565:1: ( rule__BehaviorStateGroup__Group__4__Impl rule__BehaviorStateGroup__Group__5 ) - // InternalBehaviorAnnexParser.g:4566:2: rule__BehaviorStateGroup__Group__4__Impl rule__BehaviorStateGroup__Group__5 + // InternalBehaviorAnnexParser.g:4741:1: ( rule__BehaviorStateGroup__Group__4__Impl rule__BehaviorStateGroup__Group__5 ) + // InternalBehaviorAnnexParser.g:4742:2: rule__BehaviorStateGroup__Group__4__Impl rule__BehaviorStateGroup__Group__5 { pushFollow(FollowSets000.FOLLOW_18); rule__BehaviorStateGroup__Group__4__Impl(); @@ -16216,31 +16847,31 @@ public final void rule__BehaviorStateGroup__Group__4() throws RecognitionExcepti // $ANTLR start "rule__BehaviorStateGroup__Group__4__Impl" - // InternalBehaviorAnnexParser.g:4573:1: rule__BehaviorStateGroup__Group__4__Impl : ( ( rule__BehaviorStateGroup__CompleteAssignment_4 )? ) ; + // InternalBehaviorAnnexParser.g:4749:1: rule__BehaviorStateGroup__Group__4__Impl : ( ( rule__BehaviorStateGroup__CompleteAssignment_4 )? ) ; public final void rule__BehaviorStateGroup__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4577:1: ( ( ( rule__BehaviorStateGroup__CompleteAssignment_4 )? ) ) - // InternalBehaviorAnnexParser.g:4578:1: ( ( rule__BehaviorStateGroup__CompleteAssignment_4 )? ) + // InternalBehaviorAnnexParser.g:4753:1: ( ( ( rule__BehaviorStateGroup__CompleteAssignment_4 )? ) ) + // InternalBehaviorAnnexParser.g:4754:1: ( ( rule__BehaviorStateGroup__CompleteAssignment_4 )? ) { - // InternalBehaviorAnnexParser.g:4578:1: ( ( rule__BehaviorStateGroup__CompleteAssignment_4 )? ) - // InternalBehaviorAnnexParser.g:4579:2: ( rule__BehaviorStateGroup__CompleteAssignment_4 )? + // InternalBehaviorAnnexParser.g:4754:1: ( ( rule__BehaviorStateGroup__CompleteAssignment_4 )? ) + // InternalBehaviorAnnexParser.g:4755:2: ( rule__BehaviorStateGroup__CompleteAssignment_4 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getCompleteAssignment_4()); } - // InternalBehaviorAnnexParser.g:4580:2: ( rule__BehaviorStateGroup__CompleteAssignment_4 )? - int alt49=2; - int LA49_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:4756:2: ( rule__BehaviorStateGroup__CompleteAssignment_4 )? + int alt52=2; + int LA52_0 = input.LA(1); - if ( (LA49_0==Complete) ) { - alt49=1; + if ( (LA52_0==Complete) ) { + alt52=1; } - switch (alt49) { + switch (alt52) { case 1 : - // InternalBehaviorAnnexParser.g:4580:3: rule__BehaviorStateGroup__CompleteAssignment_4 + // InternalBehaviorAnnexParser.g:4756:3: rule__BehaviorStateGroup__CompleteAssignment_4 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorStateGroup__CompleteAssignment_4(); @@ -16278,14 +16909,14 @@ public final void rule__BehaviorStateGroup__Group__4__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorStateGroup__Group__5" - // InternalBehaviorAnnexParser.g:4588:1: rule__BehaviorStateGroup__Group__5 : rule__BehaviorStateGroup__Group__5__Impl rule__BehaviorStateGroup__Group__6 ; + // InternalBehaviorAnnexParser.g:4764:1: rule__BehaviorStateGroup__Group__5 : rule__BehaviorStateGroup__Group__5__Impl rule__BehaviorStateGroup__Group__6 ; public final void rule__BehaviorStateGroup__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4592:1: ( rule__BehaviorStateGroup__Group__5__Impl rule__BehaviorStateGroup__Group__6 ) - // InternalBehaviorAnnexParser.g:4593:2: rule__BehaviorStateGroup__Group__5__Impl rule__BehaviorStateGroup__Group__6 + // InternalBehaviorAnnexParser.g:4768:1: ( rule__BehaviorStateGroup__Group__5__Impl rule__BehaviorStateGroup__Group__6 ) + // InternalBehaviorAnnexParser.g:4769:2: rule__BehaviorStateGroup__Group__5__Impl rule__BehaviorStateGroup__Group__6 { pushFollow(FollowSets000.FOLLOW_18); rule__BehaviorStateGroup__Group__5__Impl(); @@ -16316,31 +16947,31 @@ public final void rule__BehaviorStateGroup__Group__5() throws RecognitionExcepti // $ANTLR start "rule__BehaviorStateGroup__Group__5__Impl" - // InternalBehaviorAnnexParser.g:4600:1: rule__BehaviorStateGroup__Group__5__Impl : ( ( rule__BehaviorStateGroup__FinalAssignment_5 )? ) ; + // InternalBehaviorAnnexParser.g:4776:1: rule__BehaviorStateGroup__Group__5__Impl : ( ( rule__BehaviorStateGroup__FinalAssignment_5 )? ) ; public final void rule__BehaviorStateGroup__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4604:1: ( ( ( rule__BehaviorStateGroup__FinalAssignment_5 )? ) ) - // InternalBehaviorAnnexParser.g:4605:1: ( ( rule__BehaviorStateGroup__FinalAssignment_5 )? ) + // InternalBehaviorAnnexParser.g:4780:1: ( ( ( rule__BehaviorStateGroup__FinalAssignment_5 )? ) ) + // InternalBehaviorAnnexParser.g:4781:1: ( ( rule__BehaviorStateGroup__FinalAssignment_5 )? ) { - // InternalBehaviorAnnexParser.g:4605:1: ( ( rule__BehaviorStateGroup__FinalAssignment_5 )? ) - // InternalBehaviorAnnexParser.g:4606:2: ( rule__BehaviorStateGroup__FinalAssignment_5 )? + // InternalBehaviorAnnexParser.g:4781:1: ( ( rule__BehaviorStateGroup__FinalAssignment_5 )? ) + // InternalBehaviorAnnexParser.g:4782:2: ( rule__BehaviorStateGroup__FinalAssignment_5 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getFinalAssignment_5()); } - // InternalBehaviorAnnexParser.g:4607:2: ( rule__BehaviorStateGroup__FinalAssignment_5 )? - int alt50=2; - int LA50_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:4783:2: ( rule__BehaviorStateGroup__FinalAssignment_5 )? + int alt53=2; + int LA53_0 = input.LA(1); - if ( (LA50_0==Final) ) { - alt50=1; + if ( (LA53_0==Final) ) { + alt53=1; } - switch (alt50) { + switch (alt53) { case 1 : - // InternalBehaviorAnnexParser.g:4607:3: rule__BehaviorStateGroup__FinalAssignment_5 + // InternalBehaviorAnnexParser.g:4783:3: rule__BehaviorStateGroup__FinalAssignment_5 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorStateGroup__FinalAssignment_5(); @@ -16378,14 +17009,14 @@ public final void rule__BehaviorStateGroup__Group__5__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorStateGroup__Group__6" - // InternalBehaviorAnnexParser.g:4615:1: rule__BehaviorStateGroup__Group__6 : rule__BehaviorStateGroup__Group__6__Impl rule__BehaviorStateGroup__Group__7 ; + // InternalBehaviorAnnexParser.g:4791:1: rule__BehaviorStateGroup__Group__6 : rule__BehaviorStateGroup__Group__6__Impl rule__BehaviorStateGroup__Group__7 ; public final void rule__BehaviorStateGroup__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4619:1: ( rule__BehaviorStateGroup__Group__6__Impl rule__BehaviorStateGroup__Group__7 ) - // InternalBehaviorAnnexParser.g:4620:2: rule__BehaviorStateGroup__Group__6__Impl rule__BehaviorStateGroup__Group__7 + // InternalBehaviorAnnexParser.g:4795:1: ( rule__BehaviorStateGroup__Group__6__Impl rule__BehaviorStateGroup__Group__7 ) + // InternalBehaviorAnnexParser.g:4796:2: rule__BehaviorStateGroup__Group__6__Impl rule__BehaviorStateGroup__Group__7 { pushFollow(FollowSets000.FOLLOW_17); rule__BehaviorStateGroup__Group__6__Impl(); @@ -16416,17 +17047,17 @@ public final void rule__BehaviorStateGroup__Group__6() throws RecognitionExcepti // $ANTLR start "rule__BehaviorStateGroup__Group__6__Impl" - // InternalBehaviorAnnexParser.g:4627:1: rule__BehaviorStateGroup__Group__6__Impl : ( State ) ; + // InternalBehaviorAnnexParser.g:4803:1: rule__BehaviorStateGroup__Group__6__Impl : ( State ) ; public final void rule__BehaviorStateGroup__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4631:1: ( ( State ) ) - // InternalBehaviorAnnexParser.g:4632:1: ( State ) + // InternalBehaviorAnnexParser.g:4807:1: ( ( State ) ) + // InternalBehaviorAnnexParser.g:4808:1: ( State ) { - // InternalBehaviorAnnexParser.g:4632:1: ( State ) - // InternalBehaviorAnnexParser.g:4633:2: State + // InternalBehaviorAnnexParser.g:4808:1: ( State ) + // InternalBehaviorAnnexParser.g:4809:2: State { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getStateKeyword_6()); @@ -16457,14 +17088,14 @@ public final void rule__BehaviorStateGroup__Group__6__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorStateGroup__Group__7" - // InternalBehaviorAnnexParser.g:4642:1: rule__BehaviorStateGroup__Group__7 : rule__BehaviorStateGroup__Group__7__Impl ; + // InternalBehaviorAnnexParser.g:4818:1: rule__BehaviorStateGroup__Group__7 : rule__BehaviorStateGroup__Group__7__Impl ; public final void rule__BehaviorStateGroup__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4646:1: ( rule__BehaviorStateGroup__Group__7__Impl ) - // InternalBehaviorAnnexParser.g:4647:2: rule__BehaviorStateGroup__Group__7__Impl + // InternalBehaviorAnnexParser.g:4822:1: ( rule__BehaviorStateGroup__Group__7__Impl ) + // InternalBehaviorAnnexParser.g:4823:2: rule__BehaviorStateGroup__Group__7__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorStateGroup__Group__7__Impl(); @@ -16490,17 +17121,17 @@ public final void rule__BehaviorStateGroup__Group__7() throws RecognitionExcepti // $ANTLR start "rule__BehaviorStateGroup__Group__7__Impl" - // InternalBehaviorAnnexParser.g:4653:1: rule__BehaviorStateGroup__Group__7__Impl : ( Semicolon ) ; + // InternalBehaviorAnnexParser.g:4829:1: rule__BehaviorStateGroup__Group__7__Impl : ( Semicolon ) ; public final void rule__BehaviorStateGroup__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4657:1: ( ( Semicolon ) ) - // InternalBehaviorAnnexParser.g:4658:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:4833:1: ( ( Semicolon ) ) + // InternalBehaviorAnnexParser.g:4834:1: ( Semicolon ) { - // InternalBehaviorAnnexParser.g:4658:1: ( Semicolon ) - // InternalBehaviorAnnexParser.g:4659:2: Semicolon + // InternalBehaviorAnnexParser.g:4834:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:4835:2: Semicolon { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getSemicolonKeyword_7()); @@ -16531,14 +17162,14 @@ public final void rule__BehaviorStateGroup__Group__7__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorStateGroup__Group_1__0" - // InternalBehaviorAnnexParser.g:4669:1: rule__BehaviorStateGroup__Group_1__0 : rule__BehaviorStateGroup__Group_1__0__Impl rule__BehaviorStateGroup__Group_1__1 ; + // InternalBehaviorAnnexParser.g:4845:1: rule__BehaviorStateGroup__Group_1__0 : rule__BehaviorStateGroup__Group_1__0__Impl rule__BehaviorStateGroup__Group_1__1 ; public final void rule__BehaviorStateGroup__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4673:1: ( rule__BehaviorStateGroup__Group_1__0__Impl rule__BehaviorStateGroup__Group_1__1 ) - // InternalBehaviorAnnexParser.g:4674:2: rule__BehaviorStateGroup__Group_1__0__Impl rule__BehaviorStateGroup__Group_1__1 + // InternalBehaviorAnnexParser.g:4849:1: ( rule__BehaviorStateGroup__Group_1__0__Impl rule__BehaviorStateGroup__Group_1__1 ) + // InternalBehaviorAnnexParser.g:4850:2: rule__BehaviorStateGroup__Group_1__0__Impl rule__BehaviorStateGroup__Group_1__1 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorStateGroup__Group_1__0__Impl(); @@ -16569,17 +17200,17 @@ public final void rule__BehaviorStateGroup__Group_1__0() throws RecognitionExcep // $ANTLR start "rule__BehaviorStateGroup__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:4681:1: rule__BehaviorStateGroup__Group_1__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:4857:1: rule__BehaviorStateGroup__Group_1__0__Impl : ( Comma ) ; public final void rule__BehaviorStateGroup__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4685:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:4686:1: ( Comma ) + // InternalBehaviorAnnexParser.g:4861:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:4862:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:4686:1: ( Comma ) - // InternalBehaviorAnnexParser.g:4687:2: Comma + // InternalBehaviorAnnexParser.g:4862:1: ( Comma ) + // InternalBehaviorAnnexParser.g:4863:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getCommaKeyword_1_0()); @@ -16610,14 +17241,14 @@ public final void rule__BehaviorStateGroup__Group_1__0__Impl() throws Recognitio // $ANTLR start "rule__BehaviorStateGroup__Group_1__1" - // InternalBehaviorAnnexParser.g:4696:1: rule__BehaviorStateGroup__Group_1__1 : rule__BehaviorStateGroup__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:4872:1: rule__BehaviorStateGroup__Group_1__1 : rule__BehaviorStateGroup__Group_1__1__Impl ; public final void rule__BehaviorStateGroup__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4700:1: ( rule__BehaviorStateGroup__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:4701:2: rule__BehaviorStateGroup__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:4876:1: ( rule__BehaviorStateGroup__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:4877:2: rule__BehaviorStateGroup__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorStateGroup__Group_1__1__Impl(); @@ -16643,23 +17274,23 @@ public final void rule__BehaviorStateGroup__Group_1__1() throws RecognitionExcep // $ANTLR start "rule__BehaviorStateGroup__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:4707:1: rule__BehaviorStateGroup__Group_1__1__Impl : ( ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:4883:1: rule__BehaviorStateGroup__Group_1__1__Impl : ( ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) ) ; public final void rule__BehaviorStateGroup__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4711:1: ( ( ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:4712:1: ( ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:4887:1: ( ( ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:4888:1: ( ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:4712:1: ( ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:4713:2: ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:4888:1: ( ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:4889:2: ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getStatesAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:4714:2: ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:4714:3: rule__BehaviorStateGroup__StatesAssignment_1_1 + // InternalBehaviorAnnexParser.g:4890:2: ( rule__BehaviorStateGroup__StatesAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:4890:3: rule__BehaviorStateGroup__StatesAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorStateGroup__StatesAssignment_1_1(); @@ -16694,14 +17325,14 @@ public final void rule__BehaviorStateGroup__Group_1__1__Impl() throws Recognitio // $ANTLR start "rule__BehaviorTransition__Group__0" - // InternalBehaviorAnnexParser.g:4723:1: rule__BehaviorTransition__Group__0 : rule__BehaviorTransition__Group__0__Impl rule__BehaviorTransition__Group__1 ; + // InternalBehaviorAnnexParser.g:4899:1: rule__BehaviorTransition__Group__0 : rule__BehaviorTransition__Group__0__Impl rule__BehaviorTransition__Group__1 ; public final void rule__BehaviorTransition__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4727:1: ( rule__BehaviorTransition__Group__0__Impl rule__BehaviorTransition__Group__1 ) - // InternalBehaviorAnnexParser.g:4728:2: rule__BehaviorTransition__Group__0__Impl rule__BehaviorTransition__Group__1 + // InternalBehaviorAnnexParser.g:4903:1: ( rule__BehaviorTransition__Group__0__Impl rule__BehaviorTransition__Group__1 ) + // InternalBehaviorAnnexParser.g:4904:2: rule__BehaviorTransition__Group__0__Impl rule__BehaviorTransition__Group__1 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorTransition__Group__0__Impl(); @@ -16732,35 +17363,35 @@ public final void rule__BehaviorTransition__Group__0() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTransition__Group__0__Impl" - // InternalBehaviorAnnexParser.g:4735:1: rule__BehaviorTransition__Group__0__Impl : ( ( rule__BehaviorTransition__Group_0__0 )? ) ; + // InternalBehaviorAnnexParser.g:4911:1: rule__BehaviorTransition__Group__0__Impl : ( ( rule__BehaviorTransition__Group_0__0 )? ) ; public final void rule__BehaviorTransition__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4739:1: ( ( ( rule__BehaviorTransition__Group_0__0 )? ) ) - // InternalBehaviorAnnexParser.g:4740:1: ( ( rule__BehaviorTransition__Group_0__0 )? ) + // InternalBehaviorAnnexParser.g:4915:1: ( ( ( rule__BehaviorTransition__Group_0__0 )? ) ) + // InternalBehaviorAnnexParser.g:4916:1: ( ( rule__BehaviorTransition__Group_0__0 )? ) { - // InternalBehaviorAnnexParser.g:4740:1: ( ( rule__BehaviorTransition__Group_0__0 )? ) - // InternalBehaviorAnnexParser.g:4741:2: ( rule__BehaviorTransition__Group_0__0 )? + // InternalBehaviorAnnexParser.g:4916:1: ( ( rule__BehaviorTransition__Group_0__0 )? ) + // InternalBehaviorAnnexParser.g:4917:2: ( rule__BehaviorTransition__Group_0__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getGroup_0()); } - // InternalBehaviorAnnexParser.g:4742:2: ( rule__BehaviorTransition__Group_0__0 )? - int alt51=2; - int LA51_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:4918:2: ( rule__BehaviorTransition__Group_0__0 )? + int alt54=2; + int LA54_0 = input.LA(1); - if ( (LA51_0==RULE_ID) ) { - int LA51_1 = input.LA(2); + if ( (LA54_0==RULE_ID) ) { + int LA54_1 = input.LA(2); - if ( (LA51_1==Colon||LA51_1==LeftSquareBracket) ) { - alt51=1; + if ( (LA54_1==Colon||LA54_1==LeftSquareBracket) ) { + alt54=1; } } - switch (alt51) { + switch (alt54) { case 1 : - // InternalBehaviorAnnexParser.g:4742:3: rule__BehaviorTransition__Group_0__0 + // InternalBehaviorAnnexParser.g:4918:3: rule__BehaviorTransition__Group_0__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__Group_0__0(); @@ -16798,14 +17429,14 @@ public final void rule__BehaviorTransition__Group__0__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorTransition__Group__1" - // InternalBehaviorAnnexParser.g:4750:1: rule__BehaviorTransition__Group__1 : rule__BehaviorTransition__Group__1__Impl rule__BehaviorTransition__Group__2 ; + // InternalBehaviorAnnexParser.g:4926:1: rule__BehaviorTransition__Group__1 : rule__BehaviorTransition__Group__1__Impl rule__BehaviorTransition__Group__2 ; public final void rule__BehaviorTransition__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4754:1: ( rule__BehaviorTransition__Group__1__Impl rule__BehaviorTransition__Group__2 ) - // InternalBehaviorAnnexParser.g:4755:2: rule__BehaviorTransition__Group__1__Impl rule__BehaviorTransition__Group__2 + // InternalBehaviorAnnexParser.g:4930:1: ( rule__BehaviorTransition__Group__1__Impl rule__BehaviorTransition__Group__2 ) + // InternalBehaviorAnnexParser.g:4931:2: rule__BehaviorTransition__Group__1__Impl rule__BehaviorTransition__Group__2 { pushFollow(FollowSets000.FOLLOW_19); rule__BehaviorTransition__Group__1__Impl(); @@ -16836,23 +17467,23 @@ public final void rule__BehaviorTransition__Group__1() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTransition__Group__1__Impl" - // InternalBehaviorAnnexParser.g:4762:1: rule__BehaviorTransition__Group__1__Impl : ( ( rule__BehaviorTransition__SourceStatesAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:4938:1: rule__BehaviorTransition__Group__1__Impl : ( ( rule__BehaviorTransition__SourceStatesAssignment_1 ) ) ; public final void rule__BehaviorTransition__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4766:1: ( ( ( rule__BehaviorTransition__SourceStatesAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:4767:1: ( ( rule__BehaviorTransition__SourceStatesAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:4942:1: ( ( ( rule__BehaviorTransition__SourceStatesAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:4943:1: ( ( rule__BehaviorTransition__SourceStatesAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:4767:1: ( ( rule__BehaviorTransition__SourceStatesAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:4768:2: ( rule__BehaviorTransition__SourceStatesAssignment_1 ) + // InternalBehaviorAnnexParser.g:4943:1: ( ( rule__BehaviorTransition__SourceStatesAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:4944:2: ( rule__BehaviorTransition__SourceStatesAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSourceStatesAssignment_1()); } - // InternalBehaviorAnnexParser.g:4769:2: ( rule__BehaviorTransition__SourceStatesAssignment_1 ) - // InternalBehaviorAnnexParser.g:4769:3: rule__BehaviorTransition__SourceStatesAssignment_1 + // InternalBehaviorAnnexParser.g:4945:2: ( rule__BehaviorTransition__SourceStatesAssignment_1 ) + // InternalBehaviorAnnexParser.g:4945:3: rule__BehaviorTransition__SourceStatesAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__SourceStatesAssignment_1(); @@ -16887,14 +17518,14 @@ public final void rule__BehaviorTransition__Group__1__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorTransition__Group__2" - // InternalBehaviorAnnexParser.g:4777:1: rule__BehaviorTransition__Group__2 : rule__BehaviorTransition__Group__2__Impl rule__BehaviorTransition__Group__3 ; + // InternalBehaviorAnnexParser.g:4953:1: rule__BehaviorTransition__Group__2 : rule__BehaviorTransition__Group__2__Impl rule__BehaviorTransition__Group__3 ; public final void rule__BehaviorTransition__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4781:1: ( rule__BehaviorTransition__Group__2__Impl rule__BehaviorTransition__Group__3 ) - // InternalBehaviorAnnexParser.g:4782:2: rule__BehaviorTransition__Group__2__Impl rule__BehaviorTransition__Group__3 + // InternalBehaviorAnnexParser.g:4957:1: ( rule__BehaviorTransition__Group__2__Impl rule__BehaviorTransition__Group__3 ) + // InternalBehaviorAnnexParser.g:4958:2: rule__BehaviorTransition__Group__2__Impl rule__BehaviorTransition__Group__3 { pushFollow(FollowSets000.FOLLOW_19); rule__BehaviorTransition__Group__2__Impl(); @@ -16925,35 +17556,35 @@ public final void rule__BehaviorTransition__Group__2() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTransition__Group__2__Impl" - // InternalBehaviorAnnexParser.g:4789:1: rule__BehaviorTransition__Group__2__Impl : ( ( rule__BehaviorTransition__Group_2__0 )* ) ; + // InternalBehaviorAnnexParser.g:4965:1: rule__BehaviorTransition__Group__2__Impl : ( ( rule__BehaviorTransition__Group_2__0 )* ) ; public final void rule__BehaviorTransition__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4793:1: ( ( ( rule__BehaviorTransition__Group_2__0 )* ) ) - // InternalBehaviorAnnexParser.g:4794:1: ( ( rule__BehaviorTransition__Group_2__0 )* ) + // InternalBehaviorAnnexParser.g:4969:1: ( ( ( rule__BehaviorTransition__Group_2__0 )* ) ) + // InternalBehaviorAnnexParser.g:4970:1: ( ( rule__BehaviorTransition__Group_2__0 )* ) { - // InternalBehaviorAnnexParser.g:4794:1: ( ( rule__BehaviorTransition__Group_2__0 )* ) - // InternalBehaviorAnnexParser.g:4795:2: ( rule__BehaviorTransition__Group_2__0 )* + // InternalBehaviorAnnexParser.g:4970:1: ( ( rule__BehaviorTransition__Group_2__0 )* ) + // InternalBehaviorAnnexParser.g:4971:2: ( rule__BehaviorTransition__Group_2__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getGroup_2()); } - // InternalBehaviorAnnexParser.g:4796:2: ( rule__BehaviorTransition__Group_2__0 )* - loop52: + // InternalBehaviorAnnexParser.g:4972:2: ( rule__BehaviorTransition__Group_2__0 )* + loop55: do { - int alt52=2; - int LA52_0 = input.LA(1); + int alt55=2; + int LA55_0 = input.LA(1); - if ( (LA52_0==Comma) ) { - alt52=1; + if ( (LA55_0==Comma) ) { + alt55=1; } - switch (alt52) { + switch (alt55) { case 1 : - // InternalBehaviorAnnexParser.g:4796:3: rule__BehaviorTransition__Group_2__0 + // InternalBehaviorAnnexParser.g:4972:3: rule__BehaviorTransition__Group_2__0 { pushFollow(FollowSets000.FOLLOW_7); rule__BehaviorTransition__Group_2__0(); @@ -16965,7 +17596,7 @@ public final void rule__BehaviorTransition__Group__2__Impl() throws RecognitionE break; default : - break loop52; + break loop55; } } while (true); @@ -16994,14 +17625,14 @@ public final void rule__BehaviorTransition__Group__2__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorTransition__Group__3" - // InternalBehaviorAnnexParser.g:4804:1: rule__BehaviorTransition__Group__3 : rule__BehaviorTransition__Group__3__Impl rule__BehaviorTransition__Group__4 ; + // InternalBehaviorAnnexParser.g:4980:1: rule__BehaviorTransition__Group__3 : rule__BehaviorTransition__Group__3__Impl rule__BehaviorTransition__Group__4 ; public final void rule__BehaviorTransition__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4808:1: ( rule__BehaviorTransition__Group__3__Impl rule__BehaviorTransition__Group__4 ) - // InternalBehaviorAnnexParser.g:4809:2: rule__BehaviorTransition__Group__3__Impl rule__BehaviorTransition__Group__4 + // InternalBehaviorAnnexParser.g:4984:1: ( rule__BehaviorTransition__Group__3__Impl rule__BehaviorTransition__Group__4 ) + // InternalBehaviorAnnexParser.g:4985:2: rule__BehaviorTransition__Group__3__Impl rule__BehaviorTransition__Group__4 { pushFollow(FollowSets000.FOLLOW_20); rule__BehaviorTransition__Group__3__Impl(); @@ -17032,17 +17663,17 @@ public final void rule__BehaviorTransition__Group__3() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTransition__Group__3__Impl" - // InternalBehaviorAnnexParser.g:4816:1: rule__BehaviorTransition__Group__3__Impl : ( HyphenMinusLeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:4992:1: rule__BehaviorTransition__Group__3__Impl : ( HyphenMinusLeftSquareBracket ) ; public final void rule__BehaviorTransition__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4820:1: ( ( HyphenMinusLeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:4821:1: ( HyphenMinusLeftSquareBracket ) + // InternalBehaviorAnnexParser.g:4996:1: ( ( HyphenMinusLeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:4997:1: ( HyphenMinusLeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:4821:1: ( HyphenMinusLeftSquareBracket ) - // InternalBehaviorAnnexParser.g:4822:2: HyphenMinusLeftSquareBracket + // InternalBehaviorAnnexParser.g:4997:1: ( HyphenMinusLeftSquareBracket ) + // InternalBehaviorAnnexParser.g:4998:2: HyphenMinusLeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getHyphenMinusLeftSquareBracketKeyword_3()); @@ -17073,14 +17704,14 @@ public final void rule__BehaviorTransition__Group__3__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorTransition__Group__4" - // InternalBehaviorAnnexParser.g:4831:1: rule__BehaviorTransition__Group__4 : rule__BehaviorTransition__Group__4__Impl rule__BehaviorTransition__Group__5 ; + // InternalBehaviorAnnexParser.g:5007:1: rule__BehaviorTransition__Group__4 : rule__BehaviorTransition__Group__4__Impl rule__BehaviorTransition__Group__5 ; public final void rule__BehaviorTransition__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4835:1: ( rule__BehaviorTransition__Group__4__Impl rule__BehaviorTransition__Group__5 ) - // InternalBehaviorAnnexParser.g:4836:2: rule__BehaviorTransition__Group__4__Impl rule__BehaviorTransition__Group__5 + // InternalBehaviorAnnexParser.g:5011:1: ( rule__BehaviorTransition__Group__4__Impl rule__BehaviorTransition__Group__5 ) + // InternalBehaviorAnnexParser.g:5012:2: rule__BehaviorTransition__Group__4__Impl rule__BehaviorTransition__Group__5 { pushFollow(FollowSets000.FOLLOW_20); rule__BehaviorTransition__Group__4__Impl(); @@ -17111,31 +17742,31 @@ public final void rule__BehaviorTransition__Group__4() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTransition__Group__4__Impl" - // InternalBehaviorAnnexParser.g:4843:1: rule__BehaviorTransition__Group__4__Impl : ( ( rule__BehaviorTransition__ConditionAssignment_4 )? ) ; + // InternalBehaviorAnnexParser.g:5019:1: rule__BehaviorTransition__Group__4__Impl : ( ( rule__BehaviorTransition__ConditionAssignment_4 )? ) ; public final void rule__BehaviorTransition__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4847:1: ( ( ( rule__BehaviorTransition__ConditionAssignment_4 )? ) ) - // InternalBehaviorAnnexParser.g:4848:1: ( ( rule__BehaviorTransition__ConditionAssignment_4 )? ) + // InternalBehaviorAnnexParser.g:5023:1: ( ( ( rule__BehaviorTransition__ConditionAssignment_4 )? ) ) + // InternalBehaviorAnnexParser.g:5024:1: ( ( rule__BehaviorTransition__ConditionAssignment_4 )? ) { - // InternalBehaviorAnnexParser.g:4848:1: ( ( rule__BehaviorTransition__ConditionAssignment_4 )? ) - // InternalBehaviorAnnexParser.g:4849:2: ( rule__BehaviorTransition__ConditionAssignment_4 )? + // InternalBehaviorAnnexParser.g:5024:1: ( ( rule__BehaviorTransition__ConditionAssignment_4 )? ) + // InternalBehaviorAnnexParser.g:5025:2: ( rule__BehaviorTransition__ConditionAssignment_4 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getConditionAssignment_4()); } - // InternalBehaviorAnnexParser.g:4850:2: ( rule__BehaviorTransition__ConditionAssignment_4 )? - int alt53=2; - int LA53_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5026:2: ( rule__BehaviorTransition__ConditionAssignment_4 )? + int alt56=2; + int LA56_0 = input.LA(1); - if ( (LA53_0==Otherwise||LA53_0==Timeout||LA53_0==False||LA53_0==True||LA53_0==Abs||LA53_0==Not||LA53_0==On||LA53_0==NumberSign||LA53_0==LeftParenthesis||LA53_0==PlusSign||LA53_0==HyphenMinus||LA53_0==RULE_REAL_LIT||LA53_0==RULE_INTEGER_LIT||(LA53_0>=RULE_STRING && LA53_0<=RULE_ID)) ) { - alt53=1; + if ( (LA56_0==Otherwise||LA56_0==Timeout||LA56_0==False||LA56_0==True||LA56_0==Abs||LA56_0==Not||LA56_0==On||LA56_0==NumberSign||LA56_0==LeftParenthesis||LA56_0==PlusSign||LA56_0==HyphenMinus||LA56_0==RULE_REAL_LIT||LA56_0==RULE_INTEGER_LIT||(LA56_0>=RULE_STRING && LA56_0<=RULE_ID)) ) { + alt56=1; } - switch (alt53) { + switch (alt56) { case 1 : - // InternalBehaviorAnnexParser.g:4850:3: rule__BehaviorTransition__ConditionAssignment_4 + // InternalBehaviorAnnexParser.g:5026:3: rule__BehaviorTransition__ConditionAssignment_4 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__ConditionAssignment_4(); @@ -17173,14 +17804,14 @@ public final void rule__BehaviorTransition__Group__4__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorTransition__Group__5" - // InternalBehaviorAnnexParser.g:4858:1: rule__BehaviorTransition__Group__5 : rule__BehaviorTransition__Group__5__Impl rule__BehaviorTransition__Group__6 ; + // InternalBehaviorAnnexParser.g:5034:1: rule__BehaviorTransition__Group__5 : rule__BehaviorTransition__Group__5__Impl rule__BehaviorTransition__Group__6 ; public final void rule__BehaviorTransition__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4862:1: ( rule__BehaviorTransition__Group__5__Impl rule__BehaviorTransition__Group__6 ) - // InternalBehaviorAnnexParser.g:4863:2: rule__BehaviorTransition__Group__5__Impl rule__BehaviorTransition__Group__6 + // InternalBehaviorAnnexParser.g:5038:1: ( rule__BehaviorTransition__Group__5__Impl rule__BehaviorTransition__Group__6 ) + // InternalBehaviorAnnexParser.g:5039:2: rule__BehaviorTransition__Group__5__Impl rule__BehaviorTransition__Group__6 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorTransition__Group__5__Impl(); @@ -17211,17 +17842,17 @@ public final void rule__BehaviorTransition__Group__5() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTransition__Group__5__Impl" - // InternalBehaviorAnnexParser.g:4870:1: rule__BehaviorTransition__Group__5__Impl : ( RightSquareBracketHyphenMinusGreaterThanSign ) ; + // InternalBehaviorAnnexParser.g:5046:1: rule__BehaviorTransition__Group__5__Impl : ( RightSquareBracketHyphenMinusGreaterThanSign ) ; public final void rule__BehaviorTransition__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4874:1: ( ( RightSquareBracketHyphenMinusGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:4875:1: ( RightSquareBracketHyphenMinusGreaterThanSign ) + // InternalBehaviorAnnexParser.g:5050:1: ( ( RightSquareBracketHyphenMinusGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:5051:1: ( RightSquareBracketHyphenMinusGreaterThanSign ) { - // InternalBehaviorAnnexParser.g:4875:1: ( RightSquareBracketHyphenMinusGreaterThanSign ) - // InternalBehaviorAnnexParser.g:4876:2: RightSquareBracketHyphenMinusGreaterThanSign + // InternalBehaviorAnnexParser.g:5051:1: ( RightSquareBracketHyphenMinusGreaterThanSign ) + // InternalBehaviorAnnexParser.g:5052:2: RightSquareBracketHyphenMinusGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getRightSquareBracketHyphenMinusGreaterThanSignKeyword_5()); @@ -17252,14 +17883,14 @@ public final void rule__BehaviorTransition__Group__5__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorTransition__Group__6" - // InternalBehaviorAnnexParser.g:4885:1: rule__BehaviorTransition__Group__6 : rule__BehaviorTransition__Group__6__Impl rule__BehaviorTransition__Group__7 ; + // InternalBehaviorAnnexParser.g:5061:1: rule__BehaviorTransition__Group__6 : rule__BehaviorTransition__Group__6__Impl rule__BehaviorTransition__Group__7 ; public final void rule__BehaviorTransition__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4889:1: ( rule__BehaviorTransition__Group__6__Impl rule__BehaviorTransition__Group__7 ) - // InternalBehaviorAnnexParser.g:4890:2: rule__BehaviorTransition__Group__6__Impl rule__BehaviorTransition__Group__7 + // InternalBehaviorAnnexParser.g:5065:1: ( rule__BehaviorTransition__Group__6__Impl rule__BehaviorTransition__Group__7 ) + // InternalBehaviorAnnexParser.g:5066:2: rule__BehaviorTransition__Group__6__Impl rule__BehaviorTransition__Group__7 { pushFollow(FollowSets000.FOLLOW_21); rule__BehaviorTransition__Group__6__Impl(); @@ -17290,23 +17921,23 @@ public final void rule__BehaviorTransition__Group__6() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTransition__Group__6__Impl" - // InternalBehaviorAnnexParser.g:4897:1: rule__BehaviorTransition__Group__6__Impl : ( ( rule__BehaviorTransition__DestinationStateAssignment_6 ) ) ; + // InternalBehaviorAnnexParser.g:5073:1: rule__BehaviorTransition__Group__6__Impl : ( ( rule__BehaviorTransition__DestinationStateAssignment_6 ) ) ; public final void rule__BehaviorTransition__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4901:1: ( ( ( rule__BehaviorTransition__DestinationStateAssignment_6 ) ) ) - // InternalBehaviorAnnexParser.g:4902:1: ( ( rule__BehaviorTransition__DestinationStateAssignment_6 ) ) + // InternalBehaviorAnnexParser.g:5077:1: ( ( ( rule__BehaviorTransition__DestinationStateAssignment_6 ) ) ) + // InternalBehaviorAnnexParser.g:5078:1: ( ( rule__BehaviorTransition__DestinationStateAssignment_6 ) ) { - // InternalBehaviorAnnexParser.g:4902:1: ( ( rule__BehaviorTransition__DestinationStateAssignment_6 ) ) - // InternalBehaviorAnnexParser.g:4903:2: ( rule__BehaviorTransition__DestinationStateAssignment_6 ) + // InternalBehaviorAnnexParser.g:5078:1: ( ( rule__BehaviorTransition__DestinationStateAssignment_6 ) ) + // InternalBehaviorAnnexParser.g:5079:2: ( rule__BehaviorTransition__DestinationStateAssignment_6 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getDestinationStateAssignment_6()); } - // InternalBehaviorAnnexParser.g:4904:2: ( rule__BehaviorTransition__DestinationStateAssignment_6 ) - // InternalBehaviorAnnexParser.g:4904:3: rule__BehaviorTransition__DestinationStateAssignment_6 + // InternalBehaviorAnnexParser.g:5080:2: ( rule__BehaviorTransition__DestinationStateAssignment_6 ) + // InternalBehaviorAnnexParser.g:5080:3: rule__BehaviorTransition__DestinationStateAssignment_6 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__DestinationStateAssignment_6(); @@ -17341,14 +17972,14 @@ public final void rule__BehaviorTransition__Group__6__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorTransition__Group__7" - // InternalBehaviorAnnexParser.g:4912:1: rule__BehaviorTransition__Group__7 : rule__BehaviorTransition__Group__7__Impl rule__BehaviorTransition__Group__8 ; + // InternalBehaviorAnnexParser.g:5088:1: rule__BehaviorTransition__Group__7 : rule__BehaviorTransition__Group__7__Impl rule__BehaviorTransition__Group__8 ; public final void rule__BehaviorTransition__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4916:1: ( rule__BehaviorTransition__Group__7__Impl rule__BehaviorTransition__Group__8 ) - // InternalBehaviorAnnexParser.g:4917:2: rule__BehaviorTransition__Group__7__Impl rule__BehaviorTransition__Group__8 + // InternalBehaviorAnnexParser.g:5092:1: ( rule__BehaviorTransition__Group__7__Impl rule__BehaviorTransition__Group__8 ) + // InternalBehaviorAnnexParser.g:5093:2: rule__BehaviorTransition__Group__7__Impl rule__BehaviorTransition__Group__8 { pushFollow(FollowSets000.FOLLOW_21); rule__BehaviorTransition__Group__7__Impl(); @@ -17379,31 +18010,31 @@ public final void rule__BehaviorTransition__Group__7() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTransition__Group__7__Impl" - // InternalBehaviorAnnexParser.g:4924:1: rule__BehaviorTransition__Group__7__Impl : ( ( rule__BehaviorTransition__ActionBlockAssignment_7 )? ) ; + // InternalBehaviorAnnexParser.g:5100:1: rule__BehaviorTransition__Group__7__Impl : ( ( rule__BehaviorTransition__ActionBlockAssignment_7 )? ) ; public final void rule__BehaviorTransition__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4928:1: ( ( ( rule__BehaviorTransition__ActionBlockAssignment_7 )? ) ) - // InternalBehaviorAnnexParser.g:4929:1: ( ( rule__BehaviorTransition__ActionBlockAssignment_7 )? ) + // InternalBehaviorAnnexParser.g:5104:1: ( ( ( rule__BehaviorTransition__ActionBlockAssignment_7 )? ) ) + // InternalBehaviorAnnexParser.g:5105:1: ( ( rule__BehaviorTransition__ActionBlockAssignment_7 )? ) { - // InternalBehaviorAnnexParser.g:4929:1: ( ( rule__BehaviorTransition__ActionBlockAssignment_7 )? ) - // InternalBehaviorAnnexParser.g:4930:2: ( rule__BehaviorTransition__ActionBlockAssignment_7 )? + // InternalBehaviorAnnexParser.g:5105:1: ( ( rule__BehaviorTransition__ActionBlockAssignment_7 )? ) + // InternalBehaviorAnnexParser.g:5106:2: ( rule__BehaviorTransition__ActionBlockAssignment_7 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getActionBlockAssignment_7()); } - // InternalBehaviorAnnexParser.g:4931:2: ( rule__BehaviorTransition__ActionBlockAssignment_7 )? - int alt54=2; - int LA54_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5107:2: ( rule__BehaviorTransition__ActionBlockAssignment_7 )? + int alt57=2; + int LA57_0 = input.LA(1); - if ( (LA54_0==LeftCurlyBracket) ) { - alt54=1; + if ( (LA57_0==LeftCurlyBracket) ) { + alt57=1; } - switch (alt54) { + switch (alt57) { case 1 : - // InternalBehaviorAnnexParser.g:4931:3: rule__BehaviorTransition__ActionBlockAssignment_7 + // InternalBehaviorAnnexParser.g:5107:3: rule__BehaviorTransition__ActionBlockAssignment_7 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__ActionBlockAssignment_7(); @@ -17441,14 +18072,14 @@ public final void rule__BehaviorTransition__Group__7__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorTransition__Group__8" - // InternalBehaviorAnnexParser.g:4939:1: rule__BehaviorTransition__Group__8 : rule__BehaviorTransition__Group__8__Impl ; + // InternalBehaviorAnnexParser.g:5115:1: rule__BehaviorTransition__Group__8 : rule__BehaviorTransition__Group__8__Impl ; public final void rule__BehaviorTransition__Group__8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4943:1: ( rule__BehaviorTransition__Group__8__Impl ) - // InternalBehaviorAnnexParser.g:4944:2: rule__BehaviorTransition__Group__8__Impl + // InternalBehaviorAnnexParser.g:5119:1: ( rule__BehaviorTransition__Group__8__Impl ) + // InternalBehaviorAnnexParser.g:5120:2: rule__BehaviorTransition__Group__8__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__Group__8__Impl(); @@ -17474,17 +18105,17 @@ public final void rule__BehaviorTransition__Group__8() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTransition__Group__8__Impl" - // InternalBehaviorAnnexParser.g:4950:1: rule__BehaviorTransition__Group__8__Impl : ( Semicolon ) ; + // InternalBehaviorAnnexParser.g:5126:1: rule__BehaviorTransition__Group__8__Impl : ( Semicolon ) ; public final void rule__BehaviorTransition__Group__8__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4954:1: ( ( Semicolon ) ) - // InternalBehaviorAnnexParser.g:4955:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:5130:1: ( ( Semicolon ) ) + // InternalBehaviorAnnexParser.g:5131:1: ( Semicolon ) { - // InternalBehaviorAnnexParser.g:4955:1: ( Semicolon ) - // InternalBehaviorAnnexParser.g:4956:2: Semicolon + // InternalBehaviorAnnexParser.g:5131:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:5132:2: Semicolon { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSemicolonKeyword_8()); @@ -17515,14 +18146,14 @@ public final void rule__BehaviorTransition__Group__8__Impl() throws RecognitionE // $ANTLR start "rule__BehaviorTransition__Group_0__0" - // InternalBehaviorAnnexParser.g:4966:1: rule__BehaviorTransition__Group_0__0 : rule__BehaviorTransition__Group_0__0__Impl rule__BehaviorTransition__Group_0__1 ; + // InternalBehaviorAnnexParser.g:5142:1: rule__BehaviorTransition__Group_0__0 : rule__BehaviorTransition__Group_0__0__Impl rule__BehaviorTransition__Group_0__1 ; public final void rule__BehaviorTransition__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4970:1: ( rule__BehaviorTransition__Group_0__0__Impl rule__BehaviorTransition__Group_0__1 ) - // InternalBehaviorAnnexParser.g:4971:2: rule__BehaviorTransition__Group_0__0__Impl rule__BehaviorTransition__Group_0__1 + // InternalBehaviorAnnexParser.g:5146:1: ( rule__BehaviorTransition__Group_0__0__Impl rule__BehaviorTransition__Group_0__1 ) + // InternalBehaviorAnnexParser.g:5147:2: rule__BehaviorTransition__Group_0__0__Impl rule__BehaviorTransition__Group_0__1 { pushFollow(FollowSets000.FOLLOW_22); rule__BehaviorTransition__Group_0__0__Impl(); @@ -17553,23 +18184,23 @@ public final void rule__BehaviorTransition__Group_0__0() throws RecognitionExcep // $ANTLR start "rule__BehaviorTransition__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:4978:1: rule__BehaviorTransition__Group_0__0__Impl : ( ( rule__BehaviorTransition__NameAssignment_0_0 ) ) ; + // InternalBehaviorAnnexParser.g:5154:1: rule__BehaviorTransition__Group_0__0__Impl : ( ( rule__BehaviorTransition__NameAssignment_0_0 ) ) ; public final void rule__BehaviorTransition__Group_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4982:1: ( ( ( rule__BehaviorTransition__NameAssignment_0_0 ) ) ) - // InternalBehaviorAnnexParser.g:4983:1: ( ( rule__BehaviorTransition__NameAssignment_0_0 ) ) + // InternalBehaviorAnnexParser.g:5158:1: ( ( ( rule__BehaviorTransition__NameAssignment_0_0 ) ) ) + // InternalBehaviorAnnexParser.g:5159:1: ( ( rule__BehaviorTransition__NameAssignment_0_0 ) ) { - // InternalBehaviorAnnexParser.g:4983:1: ( ( rule__BehaviorTransition__NameAssignment_0_0 ) ) - // InternalBehaviorAnnexParser.g:4984:2: ( rule__BehaviorTransition__NameAssignment_0_0 ) + // InternalBehaviorAnnexParser.g:5159:1: ( ( rule__BehaviorTransition__NameAssignment_0_0 ) ) + // InternalBehaviorAnnexParser.g:5160:2: ( rule__BehaviorTransition__NameAssignment_0_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getNameAssignment_0_0()); } - // InternalBehaviorAnnexParser.g:4985:2: ( rule__BehaviorTransition__NameAssignment_0_0 ) - // InternalBehaviorAnnexParser.g:4985:3: rule__BehaviorTransition__NameAssignment_0_0 + // InternalBehaviorAnnexParser.g:5161:2: ( rule__BehaviorTransition__NameAssignment_0_0 ) + // InternalBehaviorAnnexParser.g:5161:3: rule__BehaviorTransition__NameAssignment_0_0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__NameAssignment_0_0(); @@ -17604,14 +18235,14 @@ public final void rule__BehaviorTransition__Group_0__0__Impl() throws Recognitio // $ANTLR start "rule__BehaviorTransition__Group_0__1" - // InternalBehaviorAnnexParser.g:4993:1: rule__BehaviorTransition__Group_0__1 : rule__BehaviorTransition__Group_0__1__Impl rule__BehaviorTransition__Group_0__2 ; + // InternalBehaviorAnnexParser.g:5169:1: rule__BehaviorTransition__Group_0__1 : rule__BehaviorTransition__Group_0__1__Impl rule__BehaviorTransition__Group_0__2 ; public final void rule__BehaviorTransition__Group_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:4997:1: ( rule__BehaviorTransition__Group_0__1__Impl rule__BehaviorTransition__Group_0__2 ) - // InternalBehaviorAnnexParser.g:4998:2: rule__BehaviorTransition__Group_0__1__Impl rule__BehaviorTransition__Group_0__2 + // InternalBehaviorAnnexParser.g:5173:1: ( rule__BehaviorTransition__Group_0__1__Impl rule__BehaviorTransition__Group_0__2 ) + // InternalBehaviorAnnexParser.g:5174:2: rule__BehaviorTransition__Group_0__1__Impl rule__BehaviorTransition__Group_0__2 { pushFollow(FollowSets000.FOLLOW_22); rule__BehaviorTransition__Group_0__1__Impl(); @@ -17642,31 +18273,31 @@ public final void rule__BehaviorTransition__Group_0__1() throws RecognitionExcep // $ANTLR start "rule__BehaviorTransition__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:5005:1: rule__BehaviorTransition__Group_0__1__Impl : ( ( rule__BehaviorTransition__Group_0_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:5181:1: rule__BehaviorTransition__Group_0__1__Impl : ( ( rule__BehaviorTransition__Group_0_1__0 )? ) ; public final void rule__BehaviorTransition__Group_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5009:1: ( ( ( rule__BehaviorTransition__Group_0_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:5010:1: ( ( rule__BehaviorTransition__Group_0_1__0 )? ) + // InternalBehaviorAnnexParser.g:5185:1: ( ( ( rule__BehaviorTransition__Group_0_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:5186:1: ( ( rule__BehaviorTransition__Group_0_1__0 )? ) { - // InternalBehaviorAnnexParser.g:5010:1: ( ( rule__BehaviorTransition__Group_0_1__0 )? ) - // InternalBehaviorAnnexParser.g:5011:2: ( rule__BehaviorTransition__Group_0_1__0 )? + // InternalBehaviorAnnexParser.g:5186:1: ( ( rule__BehaviorTransition__Group_0_1__0 )? ) + // InternalBehaviorAnnexParser.g:5187:2: ( rule__BehaviorTransition__Group_0_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getGroup_0_1()); } - // InternalBehaviorAnnexParser.g:5012:2: ( rule__BehaviorTransition__Group_0_1__0 )? - int alt55=2; - int LA55_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5188:2: ( rule__BehaviorTransition__Group_0_1__0 )? + int alt58=2; + int LA58_0 = input.LA(1); - if ( (LA55_0==LeftSquareBracket) ) { - alt55=1; + if ( (LA58_0==LeftSquareBracket) ) { + alt58=1; } - switch (alt55) { + switch (alt58) { case 1 : - // InternalBehaviorAnnexParser.g:5012:3: rule__BehaviorTransition__Group_0_1__0 + // InternalBehaviorAnnexParser.g:5188:3: rule__BehaviorTransition__Group_0_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__Group_0_1__0(); @@ -17704,14 +18335,14 @@ public final void rule__BehaviorTransition__Group_0__1__Impl() throws Recognitio // $ANTLR start "rule__BehaviorTransition__Group_0__2" - // InternalBehaviorAnnexParser.g:5020:1: rule__BehaviorTransition__Group_0__2 : rule__BehaviorTransition__Group_0__2__Impl ; + // InternalBehaviorAnnexParser.g:5196:1: rule__BehaviorTransition__Group_0__2 : rule__BehaviorTransition__Group_0__2__Impl ; public final void rule__BehaviorTransition__Group_0__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5024:1: ( rule__BehaviorTransition__Group_0__2__Impl ) - // InternalBehaviorAnnexParser.g:5025:2: rule__BehaviorTransition__Group_0__2__Impl + // InternalBehaviorAnnexParser.g:5200:1: ( rule__BehaviorTransition__Group_0__2__Impl ) + // InternalBehaviorAnnexParser.g:5201:2: rule__BehaviorTransition__Group_0__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__Group_0__2__Impl(); @@ -17737,17 +18368,17 @@ public final void rule__BehaviorTransition__Group_0__2() throws RecognitionExcep // $ANTLR start "rule__BehaviorTransition__Group_0__2__Impl" - // InternalBehaviorAnnexParser.g:5031:1: rule__BehaviorTransition__Group_0__2__Impl : ( Colon ) ; + // InternalBehaviorAnnexParser.g:5207:1: rule__BehaviorTransition__Group_0__2__Impl : ( Colon ) ; public final void rule__BehaviorTransition__Group_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5035:1: ( ( Colon ) ) - // InternalBehaviorAnnexParser.g:5036:1: ( Colon ) + // InternalBehaviorAnnexParser.g:5211:1: ( ( Colon ) ) + // InternalBehaviorAnnexParser.g:5212:1: ( Colon ) { - // InternalBehaviorAnnexParser.g:5036:1: ( Colon ) - // InternalBehaviorAnnexParser.g:5037:2: Colon + // InternalBehaviorAnnexParser.g:5212:1: ( Colon ) + // InternalBehaviorAnnexParser.g:5213:2: Colon { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getColonKeyword_0_2()); @@ -17778,14 +18409,14 @@ public final void rule__BehaviorTransition__Group_0__2__Impl() throws Recognitio // $ANTLR start "rule__BehaviorTransition__Group_0_1__0" - // InternalBehaviorAnnexParser.g:5047:1: rule__BehaviorTransition__Group_0_1__0 : rule__BehaviorTransition__Group_0_1__0__Impl rule__BehaviorTransition__Group_0_1__1 ; + // InternalBehaviorAnnexParser.g:5223:1: rule__BehaviorTransition__Group_0_1__0 : rule__BehaviorTransition__Group_0_1__0__Impl rule__BehaviorTransition__Group_0_1__1 ; public final void rule__BehaviorTransition__Group_0_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5051:1: ( rule__BehaviorTransition__Group_0_1__0__Impl rule__BehaviorTransition__Group_0_1__1 ) - // InternalBehaviorAnnexParser.g:5052:2: rule__BehaviorTransition__Group_0_1__0__Impl rule__BehaviorTransition__Group_0_1__1 + // InternalBehaviorAnnexParser.g:5227:1: ( rule__BehaviorTransition__Group_0_1__0__Impl rule__BehaviorTransition__Group_0_1__1 ) + // InternalBehaviorAnnexParser.g:5228:2: rule__BehaviorTransition__Group_0_1__0__Impl rule__BehaviorTransition__Group_0_1__1 { pushFollow(FollowSets000.FOLLOW_23); rule__BehaviorTransition__Group_0_1__0__Impl(); @@ -17816,17 +18447,17 @@ public final void rule__BehaviorTransition__Group_0_1__0() throws RecognitionExc // $ANTLR start "rule__BehaviorTransition__Group_0_1__0__Impl" - // InternalBehaviorAnnexParser.g:5059:1: rule__BehaviorTransition__Group_0_1__0__Impl : ( LeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:5235:1: rule__BehaviorTransition__Group_0_1__0__Impl : ( LeftSquareBracket ) ; public final void rule__BehaviorTransition__Group_0_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5063:1: ( ( LeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:5064:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:5239:1: ( ( LeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:5240:1: ( LeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:5064:1: ( LeftSquareBracket ) - // InternalBehaviorAnnexParser.g:5065:2: LeftSquareBracket + // InternalBehaviorAnnexParser.g:5240:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:5241:2: LeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getLeftSquareBracketKeyword_0_1_0()); @@ -17857,14 +18488,14 @@ public final void rule__BehaviorTransition__Group_0_1__0__Impl() throws Recognit // $ANTLR start "rule__BehaviorTransition__Group_0_1__1" - // InternalBehaviorAnnexParser.g:5074:1: rule__BehaviorTransition__Group_0_1__1 : rule__BehaviorTransition__Group_0_1__1__Impl rule__BehaviorTransition__Group_0_1__2 ; + // InternalBehaviorAnnexParser.g:5250:1: rule__BehaviorTransition__Group_0_1__1 : rule__BehaviorTransition__Group_0_1__1__Impl rule__BehaviorTransition__Group_0_1__2 ; public final void rule__BehaviorTransition__Group_0_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5078:1: ( rule__BehaviorTransition__Group_0_1__1__Impl rule__BehaviorTransition__Group_0_1__2 ) - // InternalBehaviorAnnexParser.g:5079:2: rule__BehaviorTransition__Group_0_1__1__Impl rule__BehaviorTransition__Group_0_1__2 + // InternalBehaviorAnnexParser.g:5254:1: ( rule__BehaviorTransition__Group_0_1__1__Impl rule__BehaviorTransition__Group_0_1__2 ) + // InternalBehaviorAnnexParser.g:5255:2: rule__BehaviorTransition__Group_0_1__1__Impl rule__BehaviorTransition__Group_0_1__2 { pushFollow(FollowSets000.FOLLOW_14); rule__BehaviorTransition__Group_0_1__1__Impl(); @@ -17895,23 +18526,23 @@ public final void rule__BehaviorTransition__Group_0_1__1() throws RecognitionExc // $ANTLR start "rule__BehaviorTransition__Group_0_1__1__Impl" - // InternalBehaviorAnnexParser.g:5086:1: rule__BehaviorTransition__Group_0_1__1__Impl : ( ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:5262:1: rule__BehaviorTransition__Group_0_1__1__Impl : ( ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) ) ; public final void rule__BehaviorTransition__Group_0_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5090:1: ( ( ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:5091:1: ( ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) ) + // InternalBehaviorAnnexParser.g:5266:1: ( ( ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:5267:1: ( ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) ) { - // InternalBehaviorAnnexParser.g:5091:1: ( ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) ) - // InternalBehaviorAnnexParser.g:5092:2: ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) + // InternalBehaviorAnnexParser.g:5267:1: ( ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) ) + // InternalBehaviorAnnexParser.g:5268:2: ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getPriorityAssignment_0_1_1()); } - // InternalBehaviorAnnexParser.g:5093:2: ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) - // InternalBehaviorAnnexParser.g:5093:3: rule__BehaviorTransition__PriorityAssignment_0_1_1 + // InternalBehaviorAnnexParser.g:5269:2: ( rule__BehaviorTransition__PriorityAssignment_0_1_1 ) + // InternalBehaviorAnnexParser.g:5269:3: rule__BehaviorTransition__PriorityAssignment_0_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__PriorityAssignment_0_1_1(); @@ -17946,14 +18577,14 @@ public final void rule__BehaviorTransition__Group_0_1__1__Impl() throws Recognit // $ANTLR start "rule__BehaviorTransition__Group_0_1__2" - // InternalBehaviorAnnexParser.g:5101:1: rule__BehaviorTransition__Group_0_1__2 : rule__BehaviorTransition__Group_0_1__2__Impl ; + // InternalBehaviorAnnexParser.g:5277:1: rule__BehaviorTransition__Group_0_1__2 : rule__BehaviorTransition__Group_0_1__2__Impl ; public final void rule__BehaviorTransition__Group_0_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5105:1: ( rule__BehaviorTransition__Group_0_1__2__Impl ) - // InternalBehaviorAnnexParser.g:5106:2: rule__BehaviorTransition__Group_0_1__2__Impl + // InternalBehaviorAnnexParser.g:5281:1: ( rule__BehaviorTransition__Group_0_1__2__Impl ) + // InternalBehaviorAnnexParser.g:5282:2: rule__BehaviorTransition__Group_0_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__Group_0_1__2__Impl(); @@ -17979,17 +18610,17 @@ public final void rule__BehaviorTransition__Group_0_1__2() throws RecognitionExc // $ANTLR start "rule__BehaviorTransition__Group_0_1__2__Impl" - // InternalBehaviorAnnexParser.g:5112:1: rule__BehaviorTransition__Group_0_1__2__Impl : ( RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:5288:1: rule__BehaviorTransition__Group_0_1__2__Impl : ( RightSquareBracket ) ; public final void rule__BehaviorTransition__Group_0_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5116:1: ( ( RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:5117:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:5292:1: ( ( RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:5293:1: ( RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:5117:1: ( RightSquareBracket ) - // InternalBehaviorAnnexParser.g:5118:2: RightSquareBracket + // InternalBehaviorAnnexParser.g:5293:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:5294:2: RightSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getRightSquareBracketKeyword_0_1_2()); @@ -18020,14 +18651,14 @@ public final void rule__BehaviorTransition__Group_0_1__2__Impl() throws Recognit // $ANTLR start "rule__BehaviorTransition__Group_2__0" - // InternalBehaviorAnnexParser.g:5128:1: rule__BehaviorTransition__Group_2__0 : rule__BehaviorTransition__Group_2__0__Impl rule__BehaviorTransition__Group_2__1 ; + // InternalBehaviorAnnexParser.g:5304:1: rule__BehaviorTransition__Group_2__0 : rule__BehaviorTransition__Group_2__0__Impl rule__BehaviorTransition__Group_2__1 ; public final void rule__BehaviorTransition__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5132:1: ( rule__BehaviorTransition__Group_2__0__Impl rule__BehaviorTransition__Group_2__1 ) - // InternalBehaviorAnnexParser.g:5133:2: rule__BehaviorTransition__Group_2__0__Impl rule__BehaviorTransition__Group_2__1 + // InternalBehaviorAnnexParser.g:5308:1: ( rule__BehaviorTransition__Group_2__0__Impl rule__BehaviorTransition__Group_2__1 ) + // InternalBehaviorAnnexParser.g:5309:2: rule__BehaviorTransition__Group_2__0__Impl rule__BehaviorTransition__Group_2__1 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorTransition__Group_2__0__Impl(); @@ -18058,17 +18689,17 @@ public final void rule__BehaviorTransition__Group_2__0() throws RecognitionExcep // $ANTLR start "rule__BehaviorTransition__Group_2__0__Impl" - // InternalBehaviorAnnexParser.g:5140:1: rule__BehaviorTransition__Group_2__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:5316:1: rule__BehaviorTransition__Group_2__0__Impl : ( Comma ) ; public final void rule__BehaviorTransition__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5144:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:5145:1: ( Comma ) + // InternalBehaviorAnnexParser.g:5320:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:5321:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:5145:1: ( Comma ) - // InternalBehaviorAnnexParser.g:5146:2: Comma + // InternalBehaviorAnnexParser.g:5321:1: ( Comma ) + // InternalBehaviorAnnexParser.g:5322:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getCommaKeyword_2_0()); @@ -18099,14 +18730,14 @@ public final void rule__BehaviorTransition__Group_2__0__Impl() throws Recognitio // $ANTLR start "rule__BehaviorTransition__Group_2__1" - // InternalBehaviorAnnexParser.g:5155:1: rule__BehaviorTransition__Group_2__1 : rule__BehaviorTransition__Group_2__1__Impl ; + // InternalBehaviorAnnexParser.g:5331:1: rule__BehaviorTransition__Group_2__1 : rule__BehaviorTransition__Group_2__1__Impl ; public final void rule__BehaviorTransition__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5159:1: ( rule__BehaviorTransition__Group_2__1__Impl ) - // InternalBehaviorAnnexParser.g:5160:2: rule__BehaviorTransition__Group_2__1__Impl + // InternalBehaviorAnnexParser.g:5335:1: ( rule__BehaviorTransition__Group_2__1__Impl ) + // InternalBehaviorAnnexParser.g:5336:2: rule__BehaviorTransition__Group_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__Group_2__1__Impl(); @@ -18132,23 +18763,23 @@ public final void rule__BehaviorTransition__Group_2__1() throws RecognitionExcep // $ANTLR start "rule__BehaviorTransition__Group_2__1__Impl" - // InternalBehaviorAnnexParser.g:5166:1: rule__BehaviorTransition__Group_2__1__Impl : ( ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) ) ; + // InternalBehaviorAnnexParser.g:5342:1: rule__BehaviorTransition__Group_2__1__Impl : ( ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) ) ; public final void rule__BehaviorTransition__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5170:1: ( ( ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) ) ) - // InternalBehaviorAnnexParser.g:5171:1: ( ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) ) + // InternalBehaviorAnnexParser.g:5346:1: ( ( ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) ) ) + // InternalBehaviorAnnexParser.g:5347:1: ( ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) ) { - // InternalBehaviorAnnexParser.g:5171:1: ( ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) ) - // InternalBehaviorAnnexParser.g:5172:2: ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) + // InternalBehaviorAnnexParser.g:5347:1: ( ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) ) + // InternalBehaviorAnnexParser.g:5348:2: ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSourceStatesAssignment_2_1()); } - // InternalBehaviorAnnexParser.g:5173:2: ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) - // InternalBehaviorAnnexParser.g:5173:3: rule__BehaviorTransition__SourceStatesAssignment_2_1 + // InternalBehaviorAnnexParser.g:5349:2: ( rule__BehaviorTransition__SourceStatesAssignment_2_1 ) + // InternalBehaviorAnnexParser.g:5349:3: rule__BehaviorTransition__SourceStatesAssignment_2_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTransition__SourceStatesAssignment_2_1(); @@ -18183,14 +18814,14 @@ public final void rule__BehaviorTransition__Group_2__1__Impl() throws Recognitio // $ANTLR start "rule__BehaviorCondition__Group_0__0" - // InternalBehaviorAnnexParser.g:5182:1: rule__BehaviorCondition__Group_0__0 : rule__BehaviorCondition__Group_0__0__Impl rule__BehaviorCondition__Group_0__1 ; + // InternalBehaviorAnnexParser.g:5358:1: rule__BehaviorCondition__Group_0__0 : rule__BehaviorCondition__Group_0__0__Impl rule__BehaviorCondition__Group_0__1 ; public final void rule__BehaviorCondition__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5186:1: ( rule__BehaviorCondition__Group_0__0__Impl rule__BehaviorCondition__Group_0__1 ) - // InternalBehaviorAnnexParser.g:5187:2: rule__BehaviorCondition__Group_0__0__Impl rule__BehaviorCondition__Group_0__1 + // InternalBehaviorAnnexParser.g:5362:1: ( rule__BehaviorCondition__Group_0__0__Impl rule__BehaviorCondition__Group_0__1 ) + // InternalBehaviorAnnexParser.g:5363:2: rule__BehaviorCondition__Group_0__0__Impl rule__BehaviorCondition__Group_0__1 { pushFollow(FollowSets000.FOLLOW_24); rule__BehaviorCondition__Group_0__0__Impl(); @@ -18221,17 +18852,17 @@ public final void rule__BehaviorCondition__Group_0__0() throws RecognitionExcept // $ANTLR start "rule__BehaviorCondition__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:5194:1: rule__BehaviorCondition__Group_0__0__Impl : ( On ) ; + // InternalBehaviorAnnexParser.g:5370:1: rule__BehaviorCondition__Group_0__0__Impl : ( On ) ; public final void rule__BehaviorCondition__Group_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5198:1: ( ( On ) ) - // InternalBehaviorAnnexParser.g:5199:1: ( On ) + // InternalBehaviorAnnexParser.g:5374:1: ( ( On ) ) + // InternalBehaviorAnnexParser.g:5375:1: ( On ) { - // InternalBehaviorAnnexParser.g:5199:1: ( On ) - // InternalBehaviorAnnexParser.g:5200:2: On + // InternalBehaviorAnnexParser.g:5375:1: ( On ) + // InternalBehaviorAnnexParser.g:5376:2: On { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getOnKeyword_0_0()); @@ -18262,14 +18893,14 @@ public final void rule__BehaviorCondition__Group_0__0__Impl() throws Recognition // $ANTLR start "rule__BehaviorCondition__Group_0__1" - // InternalBehaviorAnnexParser.g:5209:1: rule__BehaviorCondition__Group_0__1 : rule__BehaviorCondition__Group_0__1__Impl ; + // InternalBehaviorAnnexParser.g:5385:1: rule__BehaviorCondition__Group_0__1 : rule__BehaviorCondition__Group_0__1__Impl ; public final void rule__BehaviorCondition__Group_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5213:1: ( rule__BehaviorCondition__Group_0__1__Impl ) - // InternalBehaviorAnnexParser.g:5214:2: rule__BehaviorCondition__Group_0__1__Impl + // InternalBehaviorAnnexParser.g:5389:1: ( rule__BehaviorCondition__Group_0__1__Impl ) + // InternalBehaviorAnnexParser.g:5390:2: rule__BehaviorCondition__Group_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorCondition__Group_0__1__Impl(); @@ -18295,23 +18926,23 @@ public final void rule__BehaviorCondition__Group_0__1() throws RecognitionExcept // $ANTLR start "rule__BehaviorCondition__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:5220:1: rule__BehaviorCondition__Group_0__1__Impl : ( ( rule__BehaviorCondition__Alternatives_0_1 ) ) ; + // InternalBehaviorAnnexParser.g:5396:1: rule__BehaviorCondition__Group_0__1__Impl : ( ( rule__BehaviorCondition__Alternatives_0_1 ) ) ; public final void rule__BehaviorCondition__Group_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5224:1: ( ( ( rule__BehaviorCondition__Alternatives_0_1 ) ) ) - // InternalBehaviorAnnexParser.g:5225:1: ( ( rule__BehaviorCondition__Alternatives_0_1 ) ) + // InternalBehaviorAnnexParser.g:5400:1: ( ( ( rule__BehaviorCondition__Alternatives_0_1 ) ) ) + // InternalBehaviorAnnexParser.g:5401:1: ( ( rule__BehaviorCondition__Alternatives_0_1 ) ) { - // InternalBehaviorAnnexParser.g:5225:1: ( ( rule__BehaviorCondition__Alternatives_0_1 ) ) - // InternalBehaviorAnnexParser.g:5226:2: ( rule__BehaviorCondition__Alternatives_0_1 ) + // InternalBehaviorAnnexParser.g:5401:1: ( ( rule__BehaviorCondition__Alternatives_0_1 ) ) + // InternalBehaviorAnnexParser.g:5402:2: ( rule__BehaviorCondition__Alternatives_0_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getAlternatives_0_1()); } - // InternalBehaviorAnnexParser.g:5227:2: ( rule__BehaviorCondition__Alternatives_0_1 ) - // InternalBehaviorAnnexParser.g:5227:3: rule__BehaviorCondition__Alternatives_0_1 + // InternalBehaviorAnnexParser.g:5403:2: ( rule__BehaviorCondition__Alternatives_0_1 ) + // InternalBehaviorAnnexParser.g:5403:3: rule__BehaviorCondition__Alternatives_0_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorCondition__Alternatives_0_1(); @@ -18346,14 +18977,14 @@ public final void rule__BehaviorCondition__Group_0__1__Impl() throws Recognition // $ANTLR start "rule__DispatchCondition__Group__0" - // InternalBehaviorAnnexParser.g:5236:1: rule__DispatchCondition__Group__0 : rule__DispatchCondition__Group__0__Impl rule__DispatchCondition__Group__1 ; + // InternalBehaviorAnnexParser.g:5412:1: rule__DispatchCondition__Group__0 : rule__DispatchCondition__Group__0__Impl rule__DispatchCondition__Group__1 ; public final void rule__DispatchCondition__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5240:1: ( rule__DispatchCondition__Group__0__Impl rule__DispatchCondition__Group__1 ) - // InternalBehaviorAnnexParser.g:5241:2: rule__DispatchCondition__Group__0__Impl rule__DispatchCondition__Group__1 + // InternalBehaviorAnnexParser.g:5416:1: ( rule__DispatchCondition__Group__0__Impl rule__DispatchCondition__Group__1 ) + // InternalBehaviorAnnexParser.g:5417:2: rule__DispatchCondition__Group__0__Impl rule__DispatchCondition__Group__1 { pushFollow(FollowSets000.FOLLOW_25); rule__DispatchCondition__Group__0__Impl(); @@ -18384,23 +19015,23 @@ public final void rule__DispatchCondition__Group__0() throws RecognitionExceptio // $ANTLR start "rule__DispatchCondition__Group__0__Impl" - // InternalBehaviorAnnexParser.g:5248:1: rule__DispatchCondition__Group__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:5424:1: rule__DispatchCondition__Group__0__Impl : ( () ) ; public final void rule__DispatchCondition__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5252:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:5253:1: ( () ) + // InternalBehaviorAnnexParser.g:5428:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:5429:1: ( () ) { - // InternalBehaviorAnnexParser.g:5253:1: ( () ) - // InternalBehaviorAnnexParser.g:5254:2: () + // InternalBehaviorAnnexParser.g:5429:1: ( () ) + // InternalBehaviorAnnexParser.g:5430:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getDispatchConditionAction_0()); } - // InternalBehaviorAnnexParser.g:5255:2: () - // InternalBehaviorAnnexParser.g:5255:3: + // InternalBehaviorAnnexParser.g:5431:2: () + // InternalBehaviorAnnexParser.g:5431:3: { } @@ -18425,14 +19056,14 @@ public final void rule__DispatchCondition__Group__0__Impl() throws RecognitionEx // $ANTLR start "rule__DispatchCondition__Group__1" - // InternalBehaviorAnnexParser.g:5263:1: rule__DispatchCondition__Group__1 : rule__DispatchCondition__Group__1__Impl rule__DispatchCondition__Group__2 ; + // InternalBehaviorAnnexParser.g:5439:1: rule__DispatchCondition__Group__1 : rule__DispatchCondition__Group__1__Impl rule__DispatchCondition__Group__2 ; public final void rule__DispatchCondition__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5267:1: ( rule__DispatchCondition__Group__1__Impl rule__DispatchCondition__Group__2 ) - // InternalBehaviorAnnexParser.g:5268:2: rule__DispatchCondition__Group__1__Impl rule__DispatchCondition__Group__2 + // InternalBehaviorAnnexParser.g:5443:1: ( rule__DispatchCondition__Group__1__Impl rule__DispatchCondition__Group__2 ) + // InternalBehaviorAnnexParser.g:5444:2: rule__DispatchCondition__Group__1__Impl rule__DispatchCondition__Group__2 { pushFollow(FollowSets000.FOLLOW_26); rule__DispatchCondition__Group__1__Impl(); @@ -18463,17 +19094,17 @@ public final void rule__DispatchCondition__Group__1() throws RecognitionExceptio // $ANTLR start "rule__DispatchCondition__Group__1__Impl" - // InternalBehaviorAnnexParser.g:5275:1: rule__DispatchCondition__Group__1__Impl : ( Dispatch ) ; + // InternalBehaviorAnnexParser.g:5451:1: rule__DispatchCondition__Group__1__Impl : ( Dispatch ) ; public final void rule__DispatchCondition__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5279:1: ( ( Dispatch ) ) - // InternalBehaviorAnnexParser.g:5280:1: ( Dispatch ) + // InternalBehaviorAnnexParser.g:5455:1: ( ( Dispatch ) ) + // InternalBehaviorAnnexParser.g:5456:1: ( Dispatch ) { - // InternalBehaviorAnnexParser.g:5280:1: ( Dispatch ) - // InternalBehaviorAnnexParser.g:5281:2: Dispatch + // InternalBehaviorAnnexParser.g:5456:1: ( Dispatch ) + // InternalBehaviorAnnexParser.g:5457:2: Dispatch { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getDispatchKeyword_1()); @@ -18504,14 +19135,14 @@ public final void rule__DispatchCondition__Group__1__Impl() throws RecognitionEx // $ANTLR start "rule__DispatchCondition__Group__2" - // InternalBehaviorAnnexParser.g:5290:1: rule__DispatchCondition__Group__2 : rule__DispatchCondition__Group__2__Impl rule__DispatchCondition__Group__3 ; + // InternalBehaviorAnnexParser.g:5466:1: rule__DispatchCondition__Group__2 : rule__DispatchCondition__Group__2__Impl rule__DispatchCondition__Group__3 ; public final void rule__DispatchCondition__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5294:1: ( rule__DispatchCondition__Group__2__Impl rule__DispatchCondition__Group__3 ) - // InternalBehaviorAnnexParser.g:5295:2: rule__DispatchCondition__Group__2__Impl rule__DispatchCondition__Group__3 + // InternalBehaviorAnnexParser.g:5470:1: ( rule__DispatchCondition__Group__2__Impl rule__DispatchCondition__Group__3 ) + // InternalBehaviorAnnexParser.g:5471:2: rule__DispatchCondition__Group__2__Impl rule__DispatchCondition__Group__3 { pushFollow(FollowSets000.FOLLOW_26); rule__DispatchCondition__Group__2__Impl(); @@ -18542,31 +19173,31 @@ public final void rule__DispatchCondition__Group__2() throws RecognitionExceptio // $ANTLR start "rule__DispatchCondition__Group__2__Impl" - // InternalBehaviorAnnexParser.g:5302:1: rule__DispatchCondition__Group__2__Impl : ( ( rule__DispatchCondition__TriggerAssignment_2 )? ) ; + // InternalBehaviorAnnexParser.g:5478:1: rule__DispatchCondition__Group__2__Impl : ( ( rule__DispatchCondition__TriggerAssignment_2 )? ) ; public final void rule__DispatchCondition__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5306:1: ( ( ( rule__DispatchCondition__TriggerAssignment_2 )? ) ) - // InternalBehaviorAnnexParser.g:5307:1: ( ( rule__DispatchCondition__TriggerAssignment_2 )? ) + // InternalBehaviorAnnexParser.g:5482:1: ( ( ( rule__DispatchCondition__TriggerAssignment_2 )? ) ) + // InternalBehaviorAnnexParser.g:5483:1: ( ( rule__DispatchCondition__TriggerAssignment_2 )? ) { - // InternalBehaviorAnnexParser.g:5307:1: ( ( rule__DispatchCondition__TriggerAssignment_2 )? ) - // InternalBehaviorAnnexParser.g:5308:2: ( rule__DispatchCondition__TriggerAssignment_2 )? + // InternalBehaviorAnnexParser.g:5483:1: ( ( rule__DispatchCondition__TriggerAssignment_2 )? ) + // InternalBehaviorAnnexParser.g:5484:2: ( rule__DispatchCondition__TriggerAssignment_2 )? { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getTriggerAssignment_2()); } - // InternalBehaviorAnnexParser.g:5309:2: ( rule__DispatchCondition__TriggerAssignment_2 )? - int alt56=2; - int LA56_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5485:2: ( rule__DispatchCondition__TriggerAssignment_2 )? + int alt59=2; + int LA59_0 = input.LA(1); - if ( (LA56_0==Timeout||LA56_0==Stop||LA56_0==RULE_ID) ) { - alt56=1; + if ( (LA59_0==Timeout||LA59_0==Stop||LA59_0==RULE_ID) ) { + alt59=1; } - switch (alt56) { + switch (alt59) { case 1 : - // InternalBehaviorAnnexParser.g:5309:3: rule__DispatchCondition__TriggerAssignment_2 + // InternalBehaviorAnnexParser.g:5485:3: rule__DispatchCondition__TriggerAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchCondition__TriggerAssignment_2(); @@ -18604,14 +19235,14 @@ public final void rule__DispatchCondition__Group__2__Impl() throws RecognitionEx // $ANTLR start "rule__DispatchCondition__Group__3" - // InternalBehaviorAnnexParser.g:5317:1: rule__DispatchCondition__Group__3 : rule__DispatchCondition__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:5493:1: rule__DispatchCondition__Group__3 : rule__DispatchCondition__Group__3__Impl ; public final void rule__DispatchCondition__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5321:1: ( rule__DispatchCondition__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:5322:2: rule__DispatchCondition__Group__3__Impl + // InternalBehaviorAnnexParser.g:5497:1: ( rule__DispatchCondition__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:5498:2: rule__DispatchCondition__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchCondition__Group__3__Impl(); @@ -18637,31 +19268,31 @@ public final void rule__DispatchCondition__Group__3() throws RecognitionExceptio // $ANTLR start "rule__DispatchCondition__Group__3__Impl" - // InternalBehaviorAnnexParser.g:5328:1: rule__DispatchCondition__Group__3__Impl : ( ( rule__DispatchCondition__Group_3__0 )? ) ; + // InternalBehaviorAnnexParser.g:5504:1: rule__DispatchCondition__Group__3__Impl : ( ( rule__DispatchCondition__Group_3__0 )? ) ; public final void rule__DispatchCondition__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5332:1: ( ( ( rule__DispatchCondition__Group_3__0 )? ) ) - // InternalBehaviorAnnexParser.g:5333:1: ( ( rule__DispatchCondition__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:5508:1: ( ( ( rule__DispatchCondition__Group_3__0 )? ) ) + // InternalBehaviorAnnexParser.g:5509:1: ( ( rule__DispatchCondition__Group_3__0 )? ) { - // InternalBehaviorAnnexParser.g:5333:1: ( ( rule__DispatchCondition__Group_3__0 )? ) - // InternalBehaviorAnnexParser.g:5334:2: ( rule__DispatchCondition__Group_3__0 )? + // InternalBehaviorAnnexParser.g:5509:1: ( ( rule__DispatchCondition__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:5510:2: ( rule__DispatchCondition__Group_3__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getGroup_3()); } - // InternalBehaviorAnnexParser.g:5335:2: ( rule__DispatchCondition__Group_3__0 )? - int alt57=2; - int LA57_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5511:2: ( rule__DispatchCondition__Group_3__0 )? + int alt60=2; + int LA60_0 = input.LA(1); - if ( (LA57_0==Frozen) ) { - alt57=1; + if ( (LA60_0==Frozen) ) { + alt60=1; } - switch (alt57) { + switch (alt60) { case 1 : - // InternalBehaviorAnnexParser.g:5335:3: rule__DispatchCondition__Group_3__0 + // InternalBehaviorAnnexParser.g:5511:3: rule__DispatchCondition__Group_3__0 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchCondition__Group_3__0(); @@ -18699,14 +19330,14 @@ public final void rule__DispatchCondition__Group__3__Impl() throws RecognitionEx // $ANTLR start "rule__DispatchCondition__Group_3__0" - // InternalBehaviorAnnexParser.g:5344:1: rule__DispatchCondition__Group_3__0 : rule__DispatchCondition__Group_3__0__Impl rule__DispatchCondition__Group_3__1 ; + // InternalBehaviorAnnexParser.g:5520:1: rule__DispatchCondition__Group_3__0 : rule__DispatchCondition__Group_3__0__Impl rule__DispatchCondition__Group_3__1 ; public final void rule__DispatchCondition__Group_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5348:1: ( rule__DispatchCondition__Group_3__0__Impl rule__DispatchCondition__Group_3__1 ) - // InternalBehaviorAnnexParser.g:5349:2: rule__DispatchCondition__Group_3__0__Impl rule__DispatchCondition__Group_3__1 + // InternalBehaviorAnnexParser.g:5524:1: ( rule__DispatchCondition__Group_3__0__Impl rule__DispatchCondition__Group_3__1 ) + // InternalBehaviorAnnexParser.g:5525:2: rule__DispatchCondition__Group_3__0__Impl rule__DispatchCondition__Group_3__1 { pushFollow(FollowSets000.FOLLOW_27); rule__DispatchCondition__Group_3__0__Impl(); @@ -18737,17 +19368,17 @@ public final void rule__DispatchCondition__Group_3__0() throws RecognitionExcept // $ANTLR start "rule__DispatchCondition__Group_3__0__Impl" - // InternalBehaviorAnnexParser.g:5356:1: rule__DispatchCondition__Group_3__0__Impl : ( Frozen ) ; + // InternalBehaviorAnnexParser.g:5532:1: rule__DispatchCondition__Group_3__0__Impl : ( Frozen ) ; public final void rule__DispatchCondition__Group_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5360:1: ( ( Frozen ) ) - // InternalBehaviorAnnexParser.g:5361:1: ( Frozen ) + // InternalBehaviorAnnexParser.g:5536:1: ( ( Frozen ) ) + // InternalBehaviorAnnexParser.g:5537:1: ( Frozen ) { - // InternalBehaviorAnnexParser.g:5361:1: ( Frozen ) - // InternalBehaviorAnnexParser.g:5362:2: Frozen + // InternalBehaviorAnnexParser.g:5537:1: ( Frozen ) + // InternalBehaviorAnnexParser.g:5538:2: Frozen { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getFrozenKeyword_3_0()); @@ -18778,14 +19409,14 @@ public final void rule__DispatchCondition__Group_3__0__Impl() throws Recognition // $ANTLR start "rule__DispatchCondition__Group_3__1" - // InternalBehaviorAnnexParser.g:5371:1: rule__DispatchCondition__Group_3__1 : rule__DispatchCondition__Group_3__1__Impl rule__DispatchCondition__Group_3__2 ; + // InternalBehaviorAnnexParser.g:5547:1: rule__DispatchCondition__Group_3__1 : rule__DispatchCondition__Group_3__1__Impl rule__DispatchCondition__Group_3__2 ; public final void rule__DispatchCondition__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5375:1: ( rule__DispatchCondition__Group_3__1__Impl rule__DispatchCondition__Group_3__2 ) - // InternalBehaviorAnnexParser.g:5376:2: rule__DispatchCondition__Group_3__1__Impl rule__DispatchCondition__Group_3__2 + // InternalBehaviorAnnexParser.g:5551:1: ( rule__DispatchCondition__Group_3__1__Impl rule__DispatchCondition__Group_3__2 ) + // InternalBehaviorAnnexParser.g:5552:2: rule__DispatchCondition__Group_3__1__Impl rule__DispatchCondition__Group_3__2 { pushFollow(FollowSets000.FOLLOW_13); rule__DispatchCondition__Group_3__1__Impl(); @@ -18816,17 +19447,17 @@ public final void rule__DispatchCondition__Group_3__1() throws RecognitionExcept // $ANTLR start "rule__DispatchCondition__Group_3__1__Impl" - // InternalBehaviorAnnexParser.g:5383:1: rule__DispatchCondition__Group_3__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:5559:1: rule__DispatchCondition__Group_3__1__Impl : ( LeftParenthesis ) ; public final void rule__DispatchCondition__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5387:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:5388:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:5563:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:5564:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:5388:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:5389:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:5564:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:5565:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getLeftParenthesisKeyword_3_1()); @@ -18857,14 +19488,14 @@ public final void rule__DispatchCondition__Group_3__1__Impl() throws Recognition // $ANTLR start "rule__DispatchCondition__Group_3__2" - // InternalBehaviorAnnexParser.g:5398:1: rule__DispatchCondition__Group_3__2 : rule__DispatchCondition__Group_3__2__Impl rule__DispatchCondition__Group_3__3 ; + // InternalBehaviorAnnexParser.g:5574:1: rule__DispatchCondition__Group_3__2 : rule__DispatchCondition__Group_3__2__Impl rule__DispatchCondition__Group_3__3 ; public final void rule__DispatchCondition__Group_3__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5402:1: ( rule__DispatchCondition__Group_3__2__Impl rule__DispatchCondition__Group_3__3 ) - // InternalBehaviorAnnexParser.g:5403:2: rule__DispatchCondition__Group_3__2__Impl rule__DispatchCondition__Group_3__3 + // InternalBehaviorAnnexParser.g:5578:1: ( rule__DispatchCondition__Group_3__2__Impl rule__DispatchCondition__Group_3__3 ) + // InternalBehaviorAnnexParser.g:5579:2: rule__DispatchCondition__Group_3__2__Impl rule__DispatchCondition__Group_3__3 { pushFollow(FollowSets000.FOLLOW_28); rule__DispatchCondition__Group_3__2__Impl(); @@ -18895,23 +19526,23 @@ public final void rule__DispatchCondition__Group_3__2() throws RecognitionExcept // $ANTLR start "rule__DispatchCondition__Group_3__2__Impl" - // InternalBehaviorAnnexParser.g:5410:1: rule__DispatchCondition__Group_3__2__Impl : ( ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) ) ; + // InternalBehaviorAnnexParser.g:5586:1: rule__DispatchCondition__Group_3__2__Impl : ( ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) ) ; public final void rule__DispatchCondition__Group_3__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5414:1: ( ( ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) ) ) - // InternalBehaviorAnnexParser.g:5415:1: ( ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) ) + // InternalBehaviorAnnexParser.g:5590:1: ( ( ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) ) ) + // InternalBehaviorAnnexParser.g:5591:1: ( ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) ) { - // InternalBehaviorAnnexParser.g:5415:1: ( ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) ) - // InternalBehaviorAnnexParser.g:5416:2: ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) + // InternalBehaviorAnnexParser.g:5591:1: ( ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) ) + // InternalBehaviorAnnexParser.g:5592:2: ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getFrozenPortsAssignment_3_2()); } - // InternalBehaviorAnnexParser.g:5417:2: ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) - // InternalBehaviorAnnexParser.g:5417:3: rule__DispatchCondition__FrozenPortsAssignment_3_2 + // InternalBehaviorAnnexParser.g:5593:2: ( rule__DispatchCondition__FrozenPortsAssignment_3_2 ) + // InternalBehaviorAnnexParser.g:5593:3: rule__DispatchCondition__FrozenPortsAssignment_3_2 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchCondition__FrozenPortsAssignment_3_2(); @@ -18946,14 +19577,14 @@ public final void rule__DispatchCondition__Group_3__2__Impl() throws Recognition // $ANTLR start "rule__DispatchCondition__Group_3__3" - // InternalBehaviorAnnexParser.g:5425:1: rule__DispatchCondition__Group_3__3 : rule__DispatchCondition__Group_3__3__Impl rule__DispatchCondition__Group_3__4 ; + // InternalBehaviorAnnexParser.g:5601:1: rule__DispatchCondition__Group_3__3 : rule__DispatchCondition__Group_3__3__Impl rule__DispatchCondition__Group_3__4 ; public final void rule__DispatchCondition__Group_3__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5429:1: ( rule__DispatchCondition__Group_3__3__Impl rule__DispatchCondition__Group_3__4 ) - // InternalBehaviorAnnexParser.g:5430:2: rule__DispatchCondition__Group_3__3__Impl rule__DispatchCondition__Group_3__4 + // InternalBehaviorAnnexParser.g:5605:1: ( rule__DispatchCondition__Group_3__3__Impl rule__DispatchCondition__Group_3__4 ) + // InternalBehaviorAnnexParser.g:5606:2: rule__DispatchCondition__Group_3__3__Impl rule__DispatchCondition__Group_3__4 { pushFollow(FollowSets000.FOLLOW_28); rule__DispatchCondition__Group_3__3__Impl(); @@ -18984,35 +19615,35 @@ public final void rule__DispatchCondition__Group_3__3() throws RecognitionExcept // $ANTLR start "rule__DispatchCondition__Group_3__3__Impl" - // InternalBehaviorAnnexParser.g:5437:1: rule__DispatchCondition__Group_3__3__Impl : ( ( rule__DispatchCondition__Group_3_3__0 )* ) ; + // InternalBehaviorAnnexParser.g:5613:1: rule__DispatchCondition__Group_3__3__Impl : ( ( rule__DispatchCondition__Group_3_3__0 )* ) ; public final void rule__DispatchCondition__Group_3__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5441:1: ( ( ( rule__DispatchCondition__Group_3_3__0 )* ) ) - // InternalBehaviorAnnexParser.g:5442:1: ( ( rule__DispatchCondition__Group_3_3__0 )* ) + // InternalBehaviorAnnexParser.g:5617:1: ( ( ( rule__DispatchCondition__Group_3_3__0 )* ) ) + // InternalBehaviorAnnexParser.g:5618:1: ( ( rule__DispatchCondition__Group_3_3__0 )* ) { - // InternalBehaviorAnnexParser.g:5442:1: ( ( rule__DispatchCondition__Group_3_3__0 )* ) - // InternalBehaviorAnnexParser.g:5443:2: ( rule__DispatchCondition__Group_3_3__0 )* + // InternalBehaviorAnnexParser.g:5618:1: ( ( rule__DispatchCondition__Group_3_3__0 )* ) + // InternalBehaviorAnnexParser.g:5619:2: ( rule__DispatchCondition__Group_3_3__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getGroup_3_3()); } - // InternalBehaviorAnnexParser.g:5444:2: ( rule__DispatchCondition__Group_3_3__0 )* - loop58: + // InternalBehaviorAnnexParser.g:5620:2: ( rule__DispatchCondition__Group_3_3__0 )* + loop61: do { - int alt58=2; - int LA58_0 = input.LA(1); + int alt61=2; + int LA61_0 = input.LA(1); - if ( (LA58_0==Comma) ) { - alt58=1; + if ( (LA61_0==Comma) ) { + alt61=1; } - switch (alt58) { + switch (alt61) { case 1 : - // InternalBehaviorAnnexParser.g:5444:3: rule__DispatchCondition__Group_3_3__0 + // InternalBehaviorAnnexParser.g:5620:3: rule__DispatchCondition__Group_3_3__0 { pushFollow(FollowSets000.FOLLOW_7); rule__DispatchCondition__Group_3_3__0(); @@ -19024,7 +19655,7 @@ public final void rule__DispatchCondition__Group_3__3__Impl() throws Recognition break; default : - break loop58; + break loop61; } } while (true); @@ -19053,14 +19684,14 @@ public final void rule__DispatchCondition__Group_3__3__Impl() throws Recognition // $ANTLR start "rule__DispatchCondition__Group_3__4" - // InternalBehaviorAnnexParser.g:5452:1: rule__DispatchCondition__Group_3__4 : rule__DispatchCondition__Group_3__4__Impl ; + // InternalBehaviorAnnexParser.g:5628:1: rule__DispatchCondition__Group_3__4 : rule__DispatchCondition__Group_3__4__Impl ; public final void rule__DispatchCondition__Group_3__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5456:1: ( rule__DispatchCondition__Group_3__4__Impl ) - // InternalBehaviorAnnexParser.g:5457:2: rule__DispatchCondition__Group_3__4__Impl + // InternalBehaviorAnnexParser.g:5632:1: ( rule__DispatchCondition__Group_3__4__Impl ) + // InternalBehaviorAnnexParser.g:5633:2: rule__DispatchCondition__Group_3__4__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchCondition__Group_3__4__Impl(); @@ -19086,17 +19717,17 @@ public final void rule__DispatchCondition__Group_3__4() throws RecognitionExcept // $ANTLR start "rule__DispatchCondition__Group_3__4__Impl" - // InternalBehaviorAnnexParser.g:5463:1: rule__DispatchCondition__Group_3__4__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:5639:1: rule__DispatchCondition__Group_3__4__Impl : ( RightParenthesis ) ; public final void rule__DispatchCondition__Group_3__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5467:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:5468:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:5643:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:5644:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:5468:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:5469:2: RightParenthesis + // InternalBehaviorAnnexParser.g:5644:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:5645:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getRightParenthesisKeyword_3_4()); @@ -19127,14 +19758,14 @@ public final void rule__DispatchCondition__Group_3__4__Impl() throws Recognition // $ANTLR start "rule__DispatchCondition__Group_3_3__0" - // InternalBehaviorAnnexParser.g:5479:1: rule__DispatchCondition__Group_3_3__0 : rule__DispatchCondition__Group_3_3__0__Impl rule__DispatchCondition__Group_3_3__1 ; + // InternalBehaviorAnnexParser.g:5655:1: rule__DispatchCondition__Group_3_3__0 : rule__DispatchCondition__Group_3_3__0__Impl rule__DispatchCondition__Group_3_3__1 ; public final void rule__DispatchCondition__Group_3_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5483:1: ( rule__DispatchCondition__Group_3_3__0__Impl rule__DispatchCondition__Group_3_3__1 ) - // InternalBehaviorAnnexParser.g:5484:2: rule__DispatchCondition__Group_3_3__0__Impl rule__DispatchCondition__Group_3_3__1 + // InternalBehaviorAnnexParser.g:5659:1: ( rule__DispatchCondition__Group_3_3__0__Impl rule__DispatchCondition__Group_3_3__1 ) + // InternalBehaviorAnnexParser.g:5660:2: rule__DispatchCondition__Group_3_3__0__Impl rule__DispatchCondition__Group_3_3__1 { pushFollow(FollowSets000.FOLLOW_13); rule__DispatchCondition__Group_3_3__0__Impl(); @@ -19165,17 +19796,17 @@ public final void rule__DispatchCondition__Group_3_3__0() throws RecognitionExce // $ANTLR start "rule__DispatchCondition__Group_3_3__0__Impl" - // InternalBehaviorAnnexParser.g:5491:1: rule__DispatchCondition__Group_3_3__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:5667:1: rule__DispatchCondition__Group_3_3__0__Impl : ( Comma ) ; public final void rule__DispatchCondition__Group_3_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5495:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:5496:1: ( Comma ) + // InternalBehaviorAnnexParser.g:5671:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:5672:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:5496:1: ( Comma ) - // InternalBehaviorAnnexParser.g:5497:2: Comma + // InternalBehaviorAnnexParser.g:5672:1: ( Comma ) + // InternalBehaviorAnnexParser.g:5673:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getCommaKeyword_3_3_0()); @@ -19206,14 +19837,14 @@ public final void rule__DispatchCondition__Group_3_3__0__Impl() throws Recogniti // $ANTLR start "rule__DispatchCondition__Group_3_3__1" - // InternalBehaviorAnnexParser.g:5506:1: rule__DispatchCondition__Group_3_3__1 : rule__DispatchCondition__Group_3_3__1__Impl ; + // InternalBehaviorAnnexParser.g:5682:1: rule__DispatchCondition__Group_3_3__1 : rule__DispatchCondition__Group_3_3__1__Impl ; public final void rule__DispatchCondition__Group_3_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5510:1: ( rule__DispatchCondition__Group_3_3__1__Impl ) - // InternalBehaviorAnnexParser.g:5511:2: rule__DispatchCondition__Group_3_3__1__Impl + // InternalBehaviorAnnexParser.g:5686:1: ( rule__DispatchCondition__Group_3_3__1__Impl ) + // InternalBehaviorAnnexParser.g:5687:2: rule__DispatchCondition__Group_3_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchCondition__Group_3_3__1__Impl(); @@ -19239,23 +19870,23 @@ public final void rule__DispatchCondition__Group_3_3__1() throws RecognitionExce // $ANTLR start "rule__DispatchCondition__Group_3_3__1__Impl" - // InternalBehaviorAnnexParser.g:5517:1: rule__DispatchCondition__Group_3_3__1__Impl : ( ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:5693:1: rule__DispatchCondition__Group_3_3__1__Impl : ( ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) ) ; public final void rule__DispatchCondition__Group_3_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5521:1: ( ( ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:5522:1: ( ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) ) + // InternalBehaviorAnnexParser.g:5697:1: ( ( ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:5698:1: ( ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) ) { - // InternalBehaviorAnnexParser.g:5522:1: ( ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) ) - // InternalBehaviorAnnexParser.g:5523:2: ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) + // InternalBehaviorAnnexParser.g:5698:1: ( ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) ) + // InternalBehaviorAnnexParser.g:5699:2: ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getFrozenPortsAssignment_3_3_1()); } - // InternalBehaviorAnnexParser.g:5524:2: ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) - // InternalBehaviorAnnexParser.g:5524:3: rule__DispatchCondition__FrozenPortsAssignment_3_3_1 + // InternalBehaviorAnnexParser.g:5700:2: ( rule__DispatchCondition__FrozenPortsAssignment_3_3_1 ) + // InternalBehaviorAnnexParser.g:5700:3: rule__DispatchCondition__FrozenPortsAssignment_3_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchCondition__FrozenPortsAssignment_3_3_1(); @@ -19290,14 +19921,14 @@ public final void rule__DispatchCondition__Group_3_3__1__Impl() throws Recogniti // $ANTLR start "rule__DispatchTriggerCondition__Group_1__0" - // InternalBehaviorAnnexParser.g:5533:1: rule__DispatchTriggerCondition__Group_1__0 : rule__DispatchTriggerCondition__Group_1__0__Impl rule__DispatchTriggerCondition__Group_1__1 ; + // InternalBehaviorAnnexParser.g:5709:1: rule__DispatchTriggerCondition__Group_1__0 : rule__DispatchTriggerCondition__Group_1__0__Impl rule__DispatchTriggerCondition__Group_1__1 ; public final void rule__DispatchTriggerCondition__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5537:1: ( rule__DispatchTriggerCondition__Group_1__0__Impl rule__DispatchTriggerCondition__Group_1__1 ) - // InternalBehaviorAnnexParser.g:5538:2: rule__DispatchTriggerCondition__Group_1__0__Impl rule__DispatchTriggerCondition__Group_1__1 + // InternalBehaviorAnnexParser.g:5713:1: ( rule__DispatchTriggerCondition__Group_1__0__Impl rule__DispatchTriggerCondition__Group_1__1 ) + // InternalBehaviorAnnexParser.g:5714:2: rule__DispatchTriggerCondition__Group_1__0__Impl rule__DispatchTriggerCondition__Group_1__1 { pushFollow(FollowSets000.FOLLOW_29); rule__DispatchTriggerCondition__Group_1__0__Impl(); @@ -19328,23 +19959,23 @@ public final void rule__DispatchTriggerCondition__Group_1__0() throws Recognitio // $ANTLR start "rule__DispatchTriggerCondition__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:5545:1: rule__DispatchTriggerCondition__Group_1__0__Impl : ( ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) ) ; + // InternalBehaviorAnnexParser.g:5721:1: rule__DispatchTriggerCondition__Group_1__0__Impl : ( ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) ) ; public final void rule__DispatchTriggerCondition__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5549:1: ( ( ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) ) ) - // InternalBehaviorAnnexParser.g:5550:1: ( ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:5725:1: ( ( ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) ) ) + // InternalBehaviorAnnexParser.g:5726:1: ( ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) ) { - // InternalBehaviorAnnexParser.g:5550:1: ( ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) ) - // InternalBehaviorAnnexParser.g:5551:2: ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:5726:1: ( ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:5727:2: ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getTimeoutAssignment_1_0()); } - // InternalBehaviorAnnexParser.g:5552:2: ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) - // InternalBehaviorAnnexParser.g:5552:3: rule__DispatchTriggerCondition__TimeoutAssignment_1_0 + // InternalBehaviorAnnexParser.g:5728:2: ( rule__DispatchTriggerCondition__TimeoutAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:5728:3: rule__DispatchTriggerCondition__TimeoutAssignment_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__TimeoutAssignment_1_0(); @@ -19379,14 +20010,14 @@ public final void rule__DispatchTriggerCondition__Group_1__0__Impl() throws Reco // $ANTLR start "rule__DispatchTriggerCondition__Group_1__1" - // InternalBehaviorAnnexParser.g:5560:1: rule__DispatchTriggerCondition__Group_1__1 : rule__DispatchTriggerCondition__Group_1__1__Impl rule__DispatchTriggerCondition__Group_1__2 ; + // InternalBehaviorAnnexParser.g:5736:1: rule__DispatchTriggerCondition__Group_1__1 : rule__DispatchTriggerCondition__Group_1__1__Impl rule__DispatchTriggerCondition__Group_1__2 ; public final void rule__DispatchTriggerCondition__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5564:1: ( rule__DispatchTriggerCondition__Group_1__1__Impl rule__DispatchTriggerCondition__Group_1__2 ) - // InternalBehaviorAnnexParser.g:5565:2: rule__DispatchTriggerCondition__Group_1__1__Impl rule__DispatchTriggerCondition__Group_1__2 + // InternalBehaviorAnnexParser.g:5740:1: ( rule__DispatchTriggerCondition__Group_1__1__Impl rule__DispatchTriggerCondition__Group_1__2 ) + // InternalBehaviorAnnexParser.g:5741:2: rule__DispatchTriggerCondition__Group_1__1__Impl rule__DispatchTriggerCondition__Group_1__2 { pushFollow(FollowSets000.FOLLOW_29); rule__DispatchTriggerCondition__Group_1__1__Impl(); @@ -19417,31 +20048,31 @@ public final void rule__DispatchTriggerCondition__Group_1__1() throws Recognitio // $ANTLR start "rule__DispatchTriggerCondition__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:5572:1: rule__DispatchTriggerCondition__Group_1__1__Impl : ( ( rule__DispatchTriggerCondition__Group_1_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:5748:1: rule__DispatchTriggerCondition__Group_1__1__Impl : ( ( rule__DispatchTriggerCondition__Group_1_1__0 )? ) ; public final void rule__DispatchTriggerCondition__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5576:1: ( ( ( rule__DispatchTriggerCondition__Group_1_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:5577:1: ( ( rule__DispatchTriggerCondition__Group_1_1__0 )? ) + // InternalBehaviorAnnexParser.g:5752:1: ( ( ( rule__DispatchTriggerCondition__Group_1_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:5753:1: ( ( rule__DispatchTriggerCondition__Group_1_1__0 )? ) { - // InternalBehaviorAnnexParser.g:5577:1: ( ( rule__DispatchTriggerCondition__Group_1_1__0 )? ) - // InternalBehaviorAnnexParser.g:5578:2: ( rule__DispatchTriggerCondition__Group_1_1__0 )? + // InternalBehaviorAnnexParser.g:5753:1: ( ( rule__DispatchTriggerCondition__Group_1_1__0 )? ) + // InternalBehaviorAnnexParser.g:5754:2: ( rule__DispatchTriggerCondition__Group_1_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getGroup_1_1()); } - // InternalBehaviorAnnexParser.g:5579:2: ( rule__DispatchTriggerCondition__Group_1_1__0 )? - int alt59=2; - int LA59_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5755:2: ( rule__DispatchTriggerCondition__Group_1_1__0 )? + int alt62=2; + int LA62_0 = input.LA(1); - if ( (LA59_0==LeftParenthesis) ) { - alt59=1; + if ( (LA62_0==LeftParenthesis) ) { + alt62=1; } - switch (alt59) { + switch (alt62) { case 1 : - // InternalBehaviorAnnexParser.g:5579:3: rule__DispatchTriggerCondition__Group_1_1__0 + // InternalBehaviorAnnexParser.g:5755:3: rule__DispatchTriggerCondition__Group_1_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__Group_1_1__0(); @@ -19479,14 +20110,14 @@ public final void rule__DispatchTriggerCondition__Group_1__1__Impl() throws Reco // $ANTLR start "rule__DispatchTriggerCondition__Group_1__2" - // InternalBehaviorAnnexParser.g:5587:1: rule__DispatchTriggerCondition__Group_1__2 : rule__DispatchTriggerCondition__Group_1__2__Impl ; + // InternalBehaviorAnnexParser.g:5763:1: rule__DispatchTriggerCondition__Group_1__2 : rule__DispatchTriggerCondition__Group_1__2__Impl ; public final void rule__DispatchTriggerCondition__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5591:1: ( rule__DispatchTriggerCondition__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:5592:2: rule__DispatchTriggerCondition__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:5767:1: ( rule__DispatchTriggerCondition__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:5768:2: rule__DispatchTriggerCondition__Group_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__Group_1__2__Impl(); @@ -19512,31 +20143,31 @@ public final void rule__DispatchTriggerCondition__Group_1__2() throws Recognitio // $ANTLR start "rule__DispatchTriggerCondition__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:5598:1: rule__DispatchTriggerCondition__Group_1__2__Impl : ( ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? ) ; + // InternalBehaviorAnnexParser.g:5774:1: rule__DispatchTriggerCondition__Group_1__2__Impl : ( ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? ) ; public final void rule__DispatchTriggerCondition__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5602:1: ( ( ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? ) ) - // InternalBehaviorAnnexParser.g:5603:1: ( ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? ) + // InternalBehaviorAnnexParser.g:5778:1: ( ( ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? ) ) + // InternalBehaviorAnnexParser.g:5779:1: ( ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? ) { - // InternalBehaviorAnnexParser.g:5603:1: ( ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? ) - // InternalBehaviorAnnexParser.g:5604:2: ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? + // InternalBehaviorAnnexParser.g:5779:1: ( ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? ) + // InternalBehaviorAnnexParser.g:5780:2: ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getTimeAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:5605:2: ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? - int alt60=2; - int LA60_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5781:2: ( rule__DispatchTriggerCondition__TimeAssignment_1_2 )? + int alt63=2; + int LA63_0 = input.LA(1); - if ( (LA60_0==NumberSign||LA60_0==RULE_INTEGER_LIT||LA60_0==RULE_ID) ) { - alt60=1; + if ( (LA63_0==NumberSign||LA63_0==RULE_INTEGER_LIT||LA63_0==RULE_ID) ) { + alt63=1; } - switch (alt60) { + switch (alt63) { case 1 : - // InternalBehaviorAnnexParser.g:5605:3: rule__DispatchTriggerCondition__TimeAssignment_1_2 + // InternalBehaviorAnnexParser.g:5781:3: rule__DispatchTriggerCondition__TimeAssignment_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__TimeAssignment_1_2(); @@ -19574,14 +20205,14 @@ public final void rule__DispatchTriggerCondition__Group_1__2__Impl() throws Reco // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1__0" - // InternalBehaviorAnnexParser.g:5614:1: rule__DispatchTriggerCondition__Group_1_1__0 : rule__DispatchTriggerCondition__Group_1_1__0__Impl rule__DispatchTriggerCondition__Group_1_1__1 ; + // InternalBehaviorAnnexParser.g:5790:1: rule__DispatchTriggerCondition__Group_1_1__0 : rule__DispatchTriggerCondition__Group_1_1__0__Impl rule__DispatchTriggerCondition__Group_1_1__1 ; public final void rule__DispatchTriggerCondition__Group_1_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5618:1: ( rule__DispatchTriggerCondition__Group_1_1__0__Impl rule__DispatchTriggerCondition__Group_1_1__1 ) - // InternalBehaviorAnnexParser.g:5619:2: rule__DispatchTriggerCondition__Group_1_1__0__Impl rule__DispatchTriggerCondition__Group_1_1__1 + // InternalBehaviorAnnexParser.g:5794:1: ( rule__DispatchTriggerCondition__Group_1_1__0__Impl rule__DispatchTriggerCondition__Group_1_1__1 ) + // InternalBehaviorAnnexParser.g:5795:2: rule__DispatchTriggerCondition__Group_1_1__0__Impl rule__DispatchTriggerCondition__Group_1_1__1 { pushFollow(FollowSets000.FOLLOW_13); rule__DispatchTriggerCondition__Group_1_1__0__Impl(); @@ -19612,17 +20243,17 @@ public final void rule__DispatchTriggerCondition__Group_1_1__0() throws Recognit // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1__0__Impl" - // InternalBehaviorAnnexParser.g:5626:1: rule__DispatchTriggerCondition__Group_1_1__0__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:5802:1: rule__DispatchTriggerCondition__Group_1_1__0__Impl : ( LeftParenthesis ) ; public final void rule__DispatchTriggerCondition__Group_1_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5630:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:5631:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:5806:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:5807:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:5631:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:5632:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:5807:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:5808:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getLeftParenthesisKeyword_1_1_0()); @@ -19653,14 +20284,14 @@ public final void rule__DispatchTriggerCondition__Group_1_1__0__Impl() throws Re // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1__1" - // InternalBehaviorAnnexParser.g:5641:1: rule__DispatchTriggerCondition__Group_1_1__1 : rule__DispatchTriggerCondition__Group_1_1__1__Impl rule__DispatchTriggerCondition__Group_1_1__2 ; + // InternalBehaviorAnnexParser.g:5817:1: rule__DispatchTriggerCondition__Group_1_1__1 : rule__DispatchTriggerCondition__Group_1_1__1__Impl rule__DispatchTriggerCondition__Group_1_1__2 ; public final void rule__DispatchTriggerCondition__Group_1_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5645:1: ( rule__DispatchTriggerCondition__Group_1_1__1__Impl rule__DispatchTriggerCondition__Group_1_1__2 ) - // InternalBehaviorAnnexParser.g:5646:2: rule__DispatchTriggerCondition__Group_1_1__1__Impl rule__DispatchTriggerCondition__Group_1_1__2 + // InternalBehaviorAnnexParser.g:5821:1: ( rule__DispatchTriggerCondition__Group_1_1__1__Impl rule__DispatchTriggerCondition__Group_1_1__2 ) + // InternalBehaviorAnnexParser.g:5822:2: rule__DispatchTriggerCondition__Group_1_1__1__Impl rule__DispatchTriggerCondition__Group_1_1__2 { pushFollow(FollowSets000.FOLLOW_30); rule__DispatchTriggerCondition__Group_1_1__1__Impl(); @@ -19691,23 +20322,23 @@ public final void rule__DispatchTriggerCondition__Group_1_1__1() throws Recognit // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1__1__Impl" - // InternalBehaviorAnnexParser.g:5653:1: rule__DispatchTriggerCondition__Group_1_1__1__Impl : ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:5829:1: rule__DispatchTriggerCondition__Group_1_1__1__Impl : ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) ) ; public final void rule__DispatchTriggerCondition__Group_1_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5657:1: ( ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:5658:1: ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:5833:1: ( ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:5834:1: ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) ) { - // InternalBehaviorAnnexParser.g:5658:1: ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) ) - // InternalBehaviorAnnexParser.g:5659:2: ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) + // InternalBehaviorAnnexParser.g:5834:1: ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:5835:2: ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getResetPortsAssignment_1_1_1()); } - // InternalBehaviorAnnexParser.g:5660:2: ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) - // InternalBehaviorAnnexParser.g:5660:3: rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 + // InternalBehaviorAnnexParser.g:5836:2: ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 ) + // InternalBehaviorAnnexParser.g:5836:3: rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1(); @@ -19742,14 +20373,14 @@ public final void rule__DispatchTriggerCondition__Group_1_1__1__Impl() throws Re // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1__2" - // InternalBehaviorAnnexParser.g:5668:1: rule__DispatchTriggerCondition__Group_1_1__2 : rule__DispatchTriggerCondition__Group_1_1__2__Impl rule__DispatchTriggerCondition__Group_1_1__3 ; + // InternalBehaviorAnnexParser.g:5844:1: rule__DispatchTriggerCondition__Group_1_1__2 : rule__DispatchTriggerCondition__Group_1_1__2__Impl rule__DispatchTriggerCondition__Group_1_1__3 ; public final void rule__DispatchTriggerCondition__Group_1_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5672:1: ( rule__DispatchTriggerCondition__Group_1_1__2__Impl rule__DispatchTriggerCondition__Group_1_1__3 ) - // InternalBehaviorAnnexParser.g:5673:2: rule__DispatchTriggerCondition__Group_1_1__2__Impl rule__DispatchTriggerCondition__Group_1_1__3 + // InternalBehaviorAnnexParser.g:5848:1: ( rule__DispatchTriggerCondition__Group_1_1__2__Impl rule__DispatchTriggerCondition__Group_1_1__3 ) + // InternalBehaviorAnnexParser.g:5849:2: rule__DispatchTriggerCondition__Group_1_1__2__Impl rule__DispatchTriggerCondition__Group_1_1__3 { pushFollow(FollowSets000.FOLLOW_30); rule__DispatchTriggerCondition__Group_1_1__2__Impl(); @@ -19780,35 +20411,35 @@ public final void rule__DispatchTriggerCondition__Group_1_1__2() throws Recognit // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1__2__Impl" - // InternalBehaviorAnnexParser.g:5680:1: rule__DispatchTriggerCondition__Group_1_1__2__Impl : ( ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* ) ; + // InternalBehaviorAnnexParser.g:5856:1: rule__DispatchTriggerCondition__Group_1_1__2__Impl : ( ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* ) ; public final void rule__DispatchTriggerCondition__Group_1_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5684:1: ( ( ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* ) ) - // InternalBehaviorAnnexParser.g:5685:1: ( ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* ) + // InternalBehaviorAnnexParser.g:5860:1: ( ( ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* ) ) + // InternalBehaviorAnnexParser.g:5861:1: ( ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* ) { - // InternalBehaviorAnnexParser.g:5685:1: ( ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* ) - // InternalBehaviorAnnexParser.g:5686:2: ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* + // InternalBehaviorAnnexParser.g:5861:1: ( ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* ) + // InternalBehaviorAnnexParser.g:5862:2: ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getGroup_1_1_2()); } - // InternalBehaviorAnnexParser.g:5687:2: ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* - loop61: + // InternalBehaviorAnnexParser.g:5863:2: ( rule__DispatchTriggerCondition__Group_1_1_2__0 )* + loop64: do { - int alt61=2; - int LA61_0 = input.LA(1); + int alt64=2; + int LA64_0 = input.LA(1); - if ( (LA61_0==Or) ) { - alt61=1; + if ( (LA64_0==Or) ) { + alt64=1; } - switch (alt61) { + switch (alt64) { case 1 : - // InternalBehaviorAnnexParser.g:5687:3: rule__DispatchTriggerCondition__Group_1_1_2__0 + // InternalBehaviorAnnexParser.g:5863:3: rule__DispatchTriggerCondition__Group_1_1_2__0 { pushFollow(FollowSets000.FOLLOW_31); rule__DispatchTriggerCondition__Group_1_1_2__0(); @@ -19820,7 +20451,7 @@ public final void rule__DispatchTriggerCondition__Group_1_1__2__Impl() throws Re break; default : - break loop61; + break loop64; } } while (true); @@ -19849,14 +20480,14 @@ public final void rule__DispatchTriggerCondition__Group_1_1__2__Impl() throws Re // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1__3" - // InternalBehaviorAnnexParser.g:5695:1: rule__DispatchTriggerCondition__Group_1_1__3 : rule__DispatchTriggerCondition__Group_1_1__3__Impl ; + // InternalBehaviorAnnexParser.g:5871:1: rule__DispatchTriggerCondition__Group_1_1__3 : rule__DispatchTriggerCondition__Group_1_1__3__Impl ; public final void rule__DispatchTriggerCondition__Group_1_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5699:1: ( rule__DispatchTriggerCondition__Group_1_1__3__Impl ) - // InternalBehaviorAnnexParser.g:5700:2: rule__DispatchTriggerCondition__Group_1_1__3__Impl + // InternalBehaviorAnnexParser.g:5875:1: ( rule__DispatchTriggerCondition__Group_1_1__3__Impl ) + // InternalBehaviorAnnexParser.g:5876:2: rule__DispatchTriggerCondition__Group_1_1__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__Group_1_1__3__Impl(); @@ -19882,17 +20513,17 @@ public final void rule__DispatchTriggerCondition__Group_1_1__3() throws Recognit // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1__3__Impl" - // InternalBehaviorAnnexParser.g:5706:1: rule__DispatchTriggerCondition__Group_1_1__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:5882:1: rule__DispatchTriggerCondition__Group_1_1__3__Impl : ( RightParenthesis ) ; public final void rule__DispatchTriggerCondition__Group_1_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5710:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:5711:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:5886:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:5887:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:5711:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:5712:2: RightParenthesis + // InternalBehaviorAnnexParser.g:5887:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:5888:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getRightParenthesisKeyword_1_1_3()); @@ -19923,14 +20554,14 @@ public final void rule__DispatchTriggerCondition__Group_1_1__3__Impl() throws Re // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1_2__0" - // InternalBehaviorAnnexParser.g:5722:1: rule__DispatchTriggerCondition__Group_1_1_2__0 : rule__DispatchTriggerCondition__Group_1_1_2__0__Impl rule__DispatchTriggerCondition__Group_1_1_2__1 ; + // InternalBehaviorAnnexParser.g:5898:1: rule__DispatchTriggerCondition__Group_1_1_2__0 : rule__DispatchTriggerCondition__Group_1_1_2__0__Impl rule__DispatchTriggerCondition__Group_1_1_2__1 ; public final void rule__DispatchTriggerCondition__Group_1_1_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5726:1: ( rule__DispatchTriggerCondition__Group_1_1_2__0__Impl rule__DispatchTriggerCondition__Group_1_1_2__1 ) - // InternalBehaviorAnnexParser.g:5727:2: rule__DispatchTriggerCondition__Group_1_1_2__0__Impl rule__DispatchTriggerCondition__Group_1_1_2__1 + // InternalBehaviorAnnexParser.g:5902:1: ( rule__DispatchTriggerCondition__Group_1_1_2__0__Impl rule__DispatchTriggerCondition__Group_1_1_2__1 ) + // InternalBehaviorAnnexParser.g:5903:2: rule__DispatchTriggerCondition__Group_1_1_2__0__Impl rule__DispatchTriggerCondition__Group_1_1_2__1 { pushFollow(FollowSets000.FOLLOW_13); rule__DispatchTriggerCondition__Group_1_1_2__0__Impl(); @@ -19961,17 +20592,17 @@ public final void rule__DispatchTriggerCondition__Group_1_1_2__0() throws Recogn // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1_2__0__Impl" - // InternalBehaviorAnnexParser.g:5734:1: rule__DispatchTriggerCondition__Group_1_1_2__0__Impl : ( Or ) ; + // InternalBehaviorAnnexParser.g:5910:1: rule__DispatchTriggerCondition__Group_1_1_2__0__Impl : ( Or ) ; public final void rule__DispatchTriggerCondition__Group_1_1_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5738:1: ( ( Or ) ) - // InternalBehaviorAnnexParser.g:5739:1: ( Or ) + // InternalBehaviorAnnexParser.g:5914:1: ( ( Or ) ) + // InternalBehaviorAnnexParser.g:5915:1: ( Or ) { - // InternalBehaviorAnnexParser.g:5739:1: ( Or ) - // InternalBehaviorAnnexParser.g:5740:2: Or + // InternalBehaviorAnnexParser.g:5915:1: ( Or ) + // InternalBehaviorAnnexParser.g:5916:2: Or { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getOrKeyword_1_1_2_0()); @@ -20002,14 +20633,14 @@ public final void rule__DispatchTriggerCondition__Group_1_1_2__0__Impl() throws // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1_2__1" - // InternalBehaviorAnnexParser.g:5749:1: rule__DispatchTriggerCondition__Group_1_1_2__1 : rule__DispatchTriggerCondition__Group_1_1_2__1__Impl ; + // InternalBehaviorAnnexParser.g:5925:1: rule__DispatchTriggerCondition__Group_1_1_2__1 : rule__DispatchTriggerCondition__Group_1_1_2__1__Impl ; public final void rule__DispatchTriggerCondition__Group_1_1_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5753:1: ( rule__DispatchTriggerCondition__Group_1_1_2__1__Impl ) - // InternalBehaviorAnnexParser.g:5754:2: rule__DispatchTriggerCondition__Group_1_1_2__1__Impl + // InternalBehaviorAnnexParser.g:5929:1: ( rule__DispatchTriggerCondition__Group_1_1_2__1__Impl ) + // InternalBehaviorAnnexParser.g:5930:2: rule__DispatchTriggerCondition__Group_1_1_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__Group_1_1_2__1__Impl(); @@ -20035,23 +20666,23 @@ public final void rule__DispatchTriggerCondition__Group_1_1_2__1() throws Recogn // $ANTLR start "rule__DispatchTriggerCondition__Group_1_1_2__1__Impl" - // InternalBehaviorAnnexParser.g:5760:1: rule__DispatchTriggerCondition__Group_1_1_2__1__Impl : ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) ) ; + // InternalBehaviorAnnexParser.g:5936:1: rule__DispatchTriggerCondition__Group_1_1_2__1__Impl : ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) ) ; public final void rule__DispatchTriggerCondition__Group_1_1_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5764:1: ( ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) ) ) - // InternalBehaviorAnnexParser.g:5765:1: ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) ) + // InternalBehaviorAnnexParser.g:5940:1: ( ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) ) ) + // InternalBehaviorAnnexParser.g:5941:1: ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) ) { - // InternalBehaviorAnnexParser.g:5765:1: ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) ) - // InternalBehaviorAnnexParser.g:5766:2: ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) + // InternalBehaviorAnnexParser.g:5941:1: ( ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) ) + // InternalBehaviorAnnexParser.g:5942:2: ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getResetPortsAssignment_1_1_2_1()); } - // InternalBehaviorAnnexParser.g:5767:2: ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) - // InternalBehaviorAnnexParser.g:5767:3: rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 + // InternalBehaviorAnnexParser.g:5943:2: ( rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 ) + // InternalBehaviorAnnexParser.g:5943:3: rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1(); @@ -20086,14 +20717,14 @@ public final void rule__DispatchTriggerCondition__Group_1_1_2__1__Impl() throws // $ANTLR start "rule__DispatchTriggerLogicalExpression__Group__0" - // InternalBehaviorAnnexParser.g:5776:1: rule__DispatchTriggerLogicalExpression__Group__0 : rule__DispatchTriggerLogicalExpression__Group__0__Impl rule__DispatchTriggerLogicalExpression__Group__1 ; + // InternalBehaviorAnnexParser.g:5952:1: rule__DispatchTriggerLogicalExpression__Group__0 : rule__DispatchTriggerLogicalExpression__Group__0__Impl rule__DispatchTriggerLogicalExpression__Group__1 ; public final void rule__DispatchTriggerLogicalExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5780:1: ( rule__DispatchTriggerLogicalExpression__Group__0__Impl rule__DispatchTriggerLogicalExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:5781:2: rule__DispatchTriggerLogicalExpression__Group__0__Impl rule__DispatchTriggerLogicalExpression__Group__1 + // InternalBehaviorAnnexParser.g:5956:1: ( rule__DispatchTriggerLogicalExpression__Group__0__Impl rule__DispatchTriggerLogicalExpression__Group__1 ) + // InternalBehaviorAnnexParser.g:5957:2: rule__DispatchTriggerLogicalExpression__Group__0__Impl rule__DispatchTriggerLogicalExpression__Group__1 { pushFollow(FollowSets000.FOLLOW_32); rule__DispatchTriggerLogicalExpression__Group__0__Impl(); @@ -20124,23 +20755,23 @@ public final void rule__DispatchTriggerLogicalExpression__Group__0() throws Reco // $ANTLR start "rule__DispatchTriggerLogicalExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:5788:1: rule__DispatchTriggerLogicalExpression__Group__0__Impl : ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:5964:1: rule__DispatchTriggerLogicalExpression__Group__0__Impl : ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) ) ; public final void rule__DispatchTriggerLogicalExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5792:1: ( ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:5793:1: ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:5968:1: ( ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:5969:1: ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:5793:1: ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:5794:2: ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) + // InternalBehaviorAnnexParser.g:5969:1: ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:5970:2: ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerLogicalExpressionAccess().getConjunctionsAssignment_0()); } - // InternalBehaviorAnnexParser.g:5795:2: ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) - // InternalBehaviorAnnexParser.g:5795:3: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 + // InternalBehaviorAnnexParser.g:5971:2: ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 ) + // InternalBehaviorAnnexParser.g:5971:3: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0(); @@ -20175,14 +20806,14 @@ public final void rule__DispatchTriggerLogicalExpression__Group__0__Impl() throw // $ANTLR start "rule__DispatchTriggerLogicalExpression__Group__1" - // InternalBehaviorAnnexParser.g:5803:1: rule__DispatchTriggerLogicalExpression__Group__1 : rule__DispatchTriggerLogicalExpression__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:5979:1: rule__DispatchTriggerLogicalExpression__Group__1 : rule__DispatchTriggerLogicalExpression__Group__1__Impl ; public final void rule__DispatchTriggerLogicalExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5807:1: ( rule__DispatchTriggerLogicalExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:5808:2: rule__DispatchTriggerLogicalExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:5983:1: ( rule__DispatchTriggerLogicalExpression__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:5984:2: rule__DispatchTriggerLogicalExpression__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerLogicalExpression__Group__1__Impl(); @@ -20208,35 +20839,35 @@ public final void rule__DispatchTriggerLogicalExpression__Group__1() throws Reco // $ANTLR start "rule__DispatchTriggerLogicalExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:5814:1: rule__DispatchTriggerLogicalExpression__Group__1__Impl : ( ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:5990:1: rule__DispatchTriggerLogicalExpression__Group__1__Impl : ( ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* ) ; public final void rule__DispatchTriggerLogicalExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5818:1: ( ( ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:5819:1: ( ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:5994:1: ( ( ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:5995:1: ( ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:5819:1: ( ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:5820:2: ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* + // InternalBehaviorAnnexParser.g:5995:1: ( ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:5996:2: ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerLogicalExpressionAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:5821:2: ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* - loop62: + // InternalBehaviorAnnexParser.g:5997:2: ( rule__DispatchTriggerLogicalExpression__Group_1__0 )* + loop65: do { - int alt62=2; - int LA62_0 = input.LA(1); + int alt65=2; + int LA65_0 = input.LA(1); - if ( (LA62_0==Or) ) { - alt62=1; + if ( (LA65_0==Or) ) { + alt65=1; } - switch (alt62) { + switch (alt65) { case 1 : - // InternalBehaviorAnnexParser.g:5821:3: rule__DispatchTriggerLogicalExpression__Group_1__0 + // InternalBehaviorAnnexParser.g:5997:3: rule__DispatchTriggerLogicalExpression__Group_1__0 { pushFollow(FollowSets000.FOLLOW_31); rule__DispatchTriggerLogicalExpression__Group_1__0(); @@ -20248,7 +20879,7 @@ public final void rule__DispatchTriggerLogicalExpression__Group__1__Impl() throw break; default : - break loop62; + break loop65; } } while (true); @@ -20277,14 +20908,14 @@ public final void rule__DispatchTriggerLogicalExpression__Group__1__Impl() throw // $ANTLR start "rule__DispatchTriggerLogicalExpression__Group_1__0" - // InternalBehaviorAnnexParser.g:5830:1: rule__DispatchTriggerLogicalExpression__Group_1__0 : rule__DispatchTriggerLogicalExpression__Group_1__0__Impl rule__DispatchTriggerLogicalExpression__Group_1__1 ; + // InternalBehaviorAnnexParser.g:6006:1: rule__DispatchTriggerLogicalExpression__Group_1__0 : rule__DispatchTriggerLogicalExpression__Group_1__0__Impl rule__DispatchTriggerLogicalExpression__Group_1__1 ; public final void rule__DispatchTriggerLogicalExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5834:1: ( rule__DispatchTriggerLogicalExpression__Group_1__0__Impl rule__DispatchTriggerLogicalExpression__Group_1__1 ) - // InternalBehaviorAnnexParser.g:5835:2: rule__DispatchTriggerLogicalExpression__Group_1__0__Impl rule__DispatchTriggerLogicalExpression__Group_1__1 + // InternalBehaviorAnnexParser.g:6010:1: ( rule__DispatchTriggerLogicalExpression__Group_1__0__Impl rule__DispatchTriggerLogicalExpression__Group_1__1 ) + // InternalBehaviorAnnexParser.g:6011:2: rule__DispatchTriggerLogicalExpression__Group_1__0__Impl rule__DispatchTriggerLogicalExpression__Group_1__1 { pushFollow(FollowSets000.FOLLOW_13); rule__DispatchTriggerLogicalExpression__Group_1__0__Impl(); @@ -20315,17 +20946,17 @@ public final void rule__DispatchTriggerLogicalExpression__Group_1__0() throws Re // $ANTLR start "rule__DispatchTriggerLogicalExpression__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:5842:1: rule__DispatchTriggerLogicalExpression__Group_1__0__Impl : ( Or ) ; + // InternalBehaviorAnnexParser.g:6018:1: rule__DispatchTriggerLogicalExpression__Group_1__0__Impl : ( Or ) ; public final void rule__DispatchTriggerLogicalExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5846:1: ( ( Or ) ) - // InternalBehaviorAnnexParser.g:5847:1: ( Or ) + // InternalBehaviorAnnexParser.g:6022:1: ( ( Or ) ) + // InternalBehaviorAnnexParser.g:6023:1: ( Or ) { - // InternalBehaviorAnnexParser.g:5847:1: ( Or ) - // InternalBehaviorAnnexParser.g:5848:2: Or + // InternalBehaviorAnnexParser.g:6023:1: ( Or ) + // InternalBehaviorAnnexParser.g:6024:2: Or { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerLogicalExpressionAccess().getOrKeyword_1_0()); @@ -20356,14 +20987,14 @@ public final void rule__DispatchTriggerLogicalExpression__Group_1__0__Impl() thr // $ANTLR start "rule__DispatchTriggerLogicalExpression__Group_1__1" - // InternalBehaviorAnnexParser.g:5857:1: rule__DispatchTriggerLogicalExpression__Group_1__1 : rule__DispatchTriggerLogicalExpression__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:6033:1: rule__DispatchTriggerLogicalExpression__Group_1__1 : rule__DispatchTriggerLogicalExpression__Group_1__1__Impl ; public final void rule__DispatchTriggerLogicalExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5861:1: ( rule__DispatchTriggerLogicalExpression__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:5862:2: rule__DispatchTriggerLogicalExpression__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:6037:1: ( rule__DispatchTriggerLogicalExpression__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:6038:2: rule__DispatchTriggerLogicalExpression__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerLogicalExpression__Group_1__1__Impl(); @@ -20389,23 +21020,23 @@ public final void rule__DispatchTriggerLogicalExpression__Group_1__1() throws Re // $ANTLR start "rule__DispatchTriggerLogicalExpression__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:5868:1: rule__DispatchTriggerLogicalExpression__Group_1__1__Impl : ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:6044:1: rule__DispatchTriggerLogicalExpression__Group_1__1__Impl : ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) ) ; public final void rule__DispatchTriggerLogicalExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5872:1: ( ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:5873:1: ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:6048:1: ( ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:6049:1: ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:5873:1: ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:5874:2: ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:6049:1: ( ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:6050:2: ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerLogicalExpressionAccess().getConjunctionsAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:5875:2: ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:5875:3: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 + // InternalBehaviorAnnexParser.g:6051:2: ( rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:6051:3: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1(); @@ -20440,14 +21071,14 @@ public final void rule__DispatchTriggerLogicalExpression__Group_1__1__Impl() thr // $ANTLR start "rule__DispatchConjunction__Group__0" - // InternalBehaviorAnnexParser.g:5884:1: rule__DispatchConjunction__Group__0 : rule__DispatchConjunction__Group__0__Impl rule__DispatchConjunction__Group__1 ; + // InternalBehaviorAnnexParser.g:6060:1: rule__DispatchConjunction__Group__0 : rule__DispatchConjunction__Group__0__Impl rule__DispatchConjunction__Group__1 ; public final void rule__DispatchConjunction__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5888:1: ( rule__DispatchConjunction__Group__0__Impl rule__DispatchConjunction__Group__1 ) - // InternalBehaviorAnnexParser.g:5889:2: rule__DispatchConjunction__Group__0__Impl rule__DispatchConjunction__Group__1 + // InternalBehaviorAnnexParser.g:6064:1: ( rule__DispatchConjunction__Group__0__Impl rule__DispatchConjunction__Group__1 ) + // InternalBehaviorAnnexParser.g:6065:2: rule__DispatchConjunction__Group__0__Impl rule__DispatchConjunction__Group__1 { pushFollow(FollowSets000.FOLLOW_33); rule__DispatchConjunction__Group__0__Impl(); @@ -20478,23 +21109,23 @@ public final void rule__DispatchConjunction__Group__0() throws RecognitionExcept // $ANTLR start "rule__DispatchConjunction__Group__0__Impl" - // InternalBehaviorAnnexParser.g:5896:1: rule__DispatchConjunction__Group__0__Impl : ( ( rule__DispatchConjunction__TriggersAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:6072:1: rule__DispatchConjunction__Group__0__Impl : ( ( rule__DispatchConjunction__TriggersAssignment_0 ) ) ; public final void rule__DispatchConjunction__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5900:1: ( ( ( rule__DispatchConjunction__TriggersAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:5901:1: ( ( rule__DispatchConjunction__TriggersAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:6076:1: ( ( ( rule__DispatchConjunction__TriggersAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:6077:1: ( ( rule__DispatchConjunction__TriggersAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:5901:1: ( ( rule__DispatchConjunction__TriggersAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:5902:2: ( rule__DispatchConjunction__TriggersAssignment_0 ) + // InternalBehaviorAnnexParser.g:6077:1: ( ( rule__DispatchConjunction__TriggersAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:6078:2: ( rule__DispatchConjunction__TriggersAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConjunctionAccess().getTriggersAssignment_0()); } - // InternalBehaviorAnnexParser.g:5903:2: ( rule__DispatchConjunction__TriggersAssignment_0 ) - // InternalBehaviorAnnexParser.g:5903:3: rule__DispatchConjunction__TriggersAssignment_0 + // InternalBehaviorAnnexParser.g:6079:2: ( rule__DispatchConjunction__TriggersAssignment_0 ) + // InternalBehaviorAnnexParser.g:6079:3: rule__DispatchConjunction__TriggersAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchConjunction__TriggersAssignment_0(); @@ -20529,14 +21160,14 @@ public final void rule__DispatchConjunction__Group__0__Impl() throws Recognition // $ANTLR start "rule__DispatchConjunction__Group__1" - // InternalBehaviorAnnexParser.g:5911:1: rule__DispatchConjunction__Group__1 : rule__DispatchConjunction__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:6087:1: rule__DispatchConjunction__Group__1 : rule__DispatchConjunction__Group__1__Impl ; public final void rule__DispatchConjunction__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5915:1: ( rule__DispatchConjunction__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:5916:2: rule__DispatchConjunction__Group__1__Impl + // InternalBehaviorAnnexParser.g:6091:1: ( rule__DispatchConjunction__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:6092:2: rule__DispatchConjunction__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchConjunction__Group__1__Impl(); @@ -20562,35 +21193,35 @@ public final void rule__DispatchConjunction__Group__1() throws RecognitionExcept // $ANTLR start "rule__DispatchConjunction__Group__1__Impl" - // InternalBehaviorAnnexParser.g:5922:1: rule__DispatchConjunction__Group__1__Impl : ( ( rule__DispatchConjunction__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:6098:1: rule__DispatchConjunction__Group__1__Impl : ( ( rule__DispatchConjunction__Group_1__0 )* ) ; public final void rule__DispatchConjunction__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5926:1: ( ( ( rule__DispatchConjunction__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:5927:1: ( ( rule__DispatchConjunction__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:6102:1: ( ( ( rule__DispatchConjunction__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:6103:1: ( ( rule__DispatchConjunction__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:5927:1: ( ( rule__DispatchConjunction__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:5928:2: ( rule__DispatchConjunction__Group_1__0 )* + // InternalBehaviorAnnexParser.g:6103:1: ( ( rule__DispatchConjunction__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:6104:2: ( rule__DispatchConjunction__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConjunctionAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:5929:2: ( rule__DispatchConjunction__Group_1__0 )* - loop63: + // InternalBehaviorAnnexParser.g:6105:2: ( rule__DispatchConjunction__Group_1__0 )* + loop66: do { - int alt63=2; - int LA63_0 = input.LA(1); + int alt66=2; + int LA66_0 = input.LA(1); - if ( (LA63_0==And) ) { - alt63=1; + if ( (LA66_0==And) ) { + alt66=1; } - switch (alt63) { + switch (alt66) { case 1 : - // InternalBehaviorAnnexParser.g:5929:3: rule__DispatchConjunction__Group_1__0 + // InternalBehaviorAnnexParser.g:6105:3: rule__DispatchConjunction__Group_1__0 { pushFollow(FollowSets000.FOLLOW_34); rule__DispatchConjunction__Group_1__0(); @@ -20602,7 +21233,7 @@ public final void rule__DispatchConjunction__Group__1__Impl() throws Recognition break; default : - break loop63; + break loop66; } } while (true); @@ -20631,14 +21262,14 @@ public final void rule__DispatchConjunction__Group__1__Impl() throws Recognition // $ANTLR start "rule__DispatchConjunction__Group_1__0" - // InternalBehaviorAnnexParser.g:5938:1: rule__DispatchConjunction__Group_1__0 : rule__DispatchConjunction__Group_1__0__Impl rule__DispatchConjunction__Group_1__1 ; + // InternalBehaviorAnnexParser.g:6114:1: rule__DispatchConjunction__Group_1__0 : rule__DispatchConjunction__Group_1__0__Impl rule__DispatchConjunction__Group_1__1 ; public final void rule__DispatchConjunction__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5942:1: ( rule__DispatchConjunction__Group_1__0__Impl rule__DispatchConjunction__Group_1__1 ) - // InternalBehaviorAnnexParser.g:5943:2: rule__DispatchConjunction__Group_1__0__Impl rule__DispatchConjunction__Group_1__1 + // InternalBehaviorAnnexParser.g:6118:1: ( rule__DispatchConjunction__Group_1__0__Impl rule__DispatchConjunction__Group_1__1 ) + // InternalBehaviorAnnexParser.g:6119:2: rule__DispatchConjunction__Group_1__0__Impl rule__DispatchConjunction__Group_1__1 { pushFollow(FollowSets000.FOLLOW_13); rule__DispatchConjunction__Group_1__0__Impl(); @@ -20669,17 +21300,17 @@ public final void rule__DispatchConjunction__Group_1__0() throws RecognitionExce // $ANTLR start "rule__DispatchConjunction__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:5950:1: rule__DispatchConjunction__Group_1__0__Impl : ( And ) ; + // InternalBehaviorAnnexParser.g:6126:1: rule__DispatchConjunction__Group_1__0__Impl : ( And ) ; public final void rule__DispatchConjunction__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5954:1: ( ( And ) ) - // InternalBehaviorAnnexParser.g:5955:1: ( And ) + // InternalBehaviorAnnexParser.g:6130:1: ( ( And ) ) + // InternalBehaviorAnnexParser.g:6131:1: ( And ) { - // InternalBehaviorAnnexParser.g:5955:1: ( And ) - // InternalBehaviorAnnexParser.g:5956:2: And + // InternalBehaviorAnnexParser.g:6131:1: ( And ) + // InternalBehaviorAnnexParser.g:6132:2: And { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConjunctionAccess().getAndKeyword_1_0()); @@ -20710,14 +21341,14 @@ public final void rule__DispatchConjunction__Group_1__0__Impl() throws Recogniti // $ANTLR start "rule__DispatchConjunction__Group_1__1" - // InternalBehaviorAnnexParser.g:5965:1: rule__DispatchConjunction__Group_1__1 : rule__DispatchConjunction__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:6141:1: rule__DispatchConjunction__Group_1__1 : rule__DispatchConjunction__Group_1__1__Impl ; public final void rule__DispatchConjunction__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5969:1: ( rule__DispatchConjunction__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:5970:2: rule__DispatchConjunction__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:6145:1: ( rule__DispatchConjunction__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:6146:2: rule__DispatchConjunction__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchConjunction__Group_1__1__Impl(); @@ -20743,23 +21374,23 @@ public final void rule__DispatchConjunction__Group_1__1() throws RecognitionExce // $ANTLR start "rule__DispatchConjunction__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:5976:1: rule__DispatchConjunction__Group_1__1__Impl : ( ( rule__DispatchConjunction__TriggersAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:6152:1: rule__DispatchConjunction__Group_1__1__Impl : ( ( rule__DispatchConjunction__TriggersAssignment_1_1 ) ) ; public final void rule__DispatchConjunction__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5980:1: ( ( ( rule__DispatchConjunction__TriggersAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:5981:1: ( ( rule__DispatchConjunction__TriggersAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:6156:1: ( ( ( rule__DispatchConjunction__TriggersAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:6157:1: ( ( rule__DispatchConjunction__TriggersAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:5981:1: ( ( rule__DispatchConjunction__TriggersAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:5982:2: ( rule__DispatchConjunction__TriggersAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:6157:1: ( ( rule__DispatchConjunction__TriggersAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:6158:2: ( rule__DispatchConjunction__TriggersAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConjunctionAccess().getTriggersAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:5983:2: ( rule__DispatchConjunction__TriggersAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:5983:3: rule__DispatchConjunction__TriggersAssignment_1_1 + // InternalBehaviorAnnexParser.g:6159:2: ( rule__DispatchConjunction__TriggersAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:6159:3: rule__DispatchConjunction__TriggersAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__DispatchConjunction__TriggersAssignment_1_1(); @@ -20794,14 +21425,14 @@ public final void rule__DispatchConjunction__Group_1__1__Impl() throws Recogniti // $ANTLR start "rule__ModeSwitchCondition__Group__0" - // InternalBehaviorAnnexParser.g:5992:1: rule__ModeSwitchCondition__Group__0 : rule__ModeSwitchCondition__Group__0__Impl rule__ModeSwitchCondition__Group__1 ; + // InternalBehaviorAnnexParser.g:6168:1: rule__ModeSwitchCondition__Group__0 : rule__ModeSwitchCondition__Group__0__Impl rule__ModeSwitchCondition__Group__1 ; public final void rule__ModeSwitchCondition__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:5996:1: ( rule__ModeSwitchCondition__Group__0__Impl rule__ModeSwitchCondition__Group__1 ) - // InternalBehaviorAnnexParser.g:5997:2: rule__ModeSwitchCondition__Group__0__Impl rule__ModeSwitchCondition__Group__1 + // InternalBehaviorAnnexParser.g:6172:1: ( rule__ModeSwitchCondition__Group__0__Impl rule__ModeSwitchCondition__Group__1 ) + // InternalBehaviorAnnexParser.g:6173:2: rule__ModeSwitchCondition__Group__0__Impl rule__ModeSwitchCondition__Group__1 { pushFollow(FollowSets000.FOLLOW_35); rule__ModeSwitchCondition__Group__0__Impl(); @@ -20832,23 +21463,23 @@ public final void rule__ModeSwitchCondition__Group__0() throws RecognitionExcept // $ANTLR start "rule__ModeSwitchCondition__Group__0__Impl" - // InternalBehaviorAnnexParser.g:6004:1: rule__ModeSwitchCondition__Group__0__Impl : ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:6180:1: rule__ModeSwitchCondition__Group__0__Impl : ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) ) ; public final void rule__ModeSwitchCondition__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6008:1: ( ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:6009:1: ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:6184:1: ( ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:6185:1: ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:6009:1: ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:6010:2: ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) + // InternalBehaviorAnnexParser.g:6185:1: ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:6186:2: ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConditionAccess().getConjunctionsAssignment_0()); } - // InternalBehaviorAnnexParser.g:6011:2: ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) - // InternalBehaviorAnnexParser.g:6011:3: rule__ModeSwitchCondition__ConjunctionsAssignment_0 + // InternalBehaviorAnnexParser.g:6187:2: ( rule__ModeSwitchCondition__ConjunctionsAssignment_0 ) + // InternalBehaviorAnnexParser.g:6187:3: rule__ModeSwitchCondition__ConjunctionsAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchCondition__ConjunctionsAssignment_0(); @@ -20883,14 +21514,14 @@ public final void rule__ModeSwitchCondition__Group__0__Impl() throws Recognition // $ANTLR start "rule__ModeSwitchCondition__Group__1" - // InternalBehaviorAnnexParser.g:6019:1: rule__ModeSwitchCondition__Group__1 : rule__ModeSwitchCondition__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:6195:1: rule__ModeSwitchCondition__Group__1 : rule__ModeSwitchCondition__Group__1__Impl ; public final void rule__ModeSwitchCondition__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6023:1: ( rule__ModeSwitchCondition__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:6024:2: rule__ModeSwitchCondition__Group__1__Impl + // InternalBehaviorAnnexParser.g:6199:1: ( rule__ModeSwitchCondition__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:6200:2: rule__ModeSwitchCondition__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchCondition__Group__1__Impl(); @@ -20916,35 +21547,35 @@ public final void rule__ModeSwitchCondition__Group__1() throws RecognitionExcept // $ANTLR start "rule__ModeSwitchCondition__Group__1__Impl" - // InternalBehaviorAnnexParser.g:6030:1: rule__ModeSwitchCondition__Group__1__Impl : ( ( rule__ModeSwitchCondition__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:6206:1: rule__ModeSwitchCondition__Group__1__Impl : ( ( rule__ModeSwitchCondition__Group_1__0 )* ) ; public final void rule__ModeSwitchCondition__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6034:1: ( ( ( rule__ModeSwitchCondition__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:6035:1: ( ( rule__ModeSwitchCondition__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:6210:1: ( ( ( rule__ModeSwitchCondition__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:6211:1: ( ( rule__ModeSwitchCondition__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:6035:1: ( ( rule__ModeSwitchCondition__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:6036:2: ( rule__ModeSwitchCondition__Group_1__0 )* + // InternalBehaviorAnnexParser.g:6211:1: ( ( rule__ModeSwitchCondition__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:6212:2: ( rule__ModeSwitchCondition__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConditionAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:6037:2: ( rule__ModeSwitchCondition__Group_1__0 )* - loop64: + // InternalBehaviorAnnexParser.g:6213:2: ( rule__ModeSwitchCondition__Group_1__0 )* + loop67: do { - int alt64=2; - int LA64_0 = input.LA(1); + int alt67=2; + int LA67_0 = input.LA(1); - if ( (LA64_0==Xor||LA64_0==Or) ) { - alt64=1; + if ( (LA67_0==Xor||LA67_0==Or) ) { + alt67=1; } - switch (alt64) { + switch (alt67) { case 1 : - // InternalBehaviorAnnexParser.g:6037:3: rule__ModeSwitchCondition__Group_1__0 + // InternalBehaviorAnnexParser.g:6213:3: rule__ModeSwitchCondition__Group_1__0 { pushFollow(FollowSets000.FOLLOW_36); rule__ModeSwitchCondition__Group_1__0(); @@ -20956,7 +21587,7 @@ public final void rule__ModeSwitchCondition__Group__1__Impl() throws Recognition break; default : - break loop64; + break loop67; } } while (true); @@ -20985,14 +21616,14 @@ public final void rule__ModeSwitchCondition__Group__1__Impl() throws Recognition // $ANTLR start "rule__ModeSwitchCondition__Group_1__0" - // InternalBehaviorAnnexParser.g:6046:1: rule__ModeSwitchCondition__Group_1__0 : rule__ModeSwitchCondition__Group_1__0__Impl rule__ModeSwitchCondition__Group_1__1 ; + // InternalBehaviorAnnexParser.g:6222:1: rule__ModeSwitchCondition__Group_1__0 : rule__ModeSwitchCondition__Group_1__0__Impl rule__ModeSwitchCondition__Group_1__1 ; public final void rule__ModeSwitchCondition__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6050:1: ( rule__ModeSwitchCondition__Group_1__0__Impl rule__ModeSwitchCondition__Group_1__1 ) - // InternalBehaviorAnnexParser.g:6051:2: rule__ModeSwitchCondition__Group_1__0__Impl rule__ModeSwitchCondition__Group_1__1 + // InternalBehaviorAnnexParser.g:6226:1: ( rule__ModeSwitchCondition__Group_1__0__Impl rule__ModeSwitchCondition__Group_1__1 ) + // InternalBehaviorAnnexParser.g:6227:2: rule__ModeSwitchCondition__Group_1__0__Impl rule__ModeSwitchCondition__Group_1__1 { pushFollow(FollowSets000.FOLLOW_24); rule__ModeSwitchCondition__Group_1__0__Impl(); @@ -21023,23 +21654,23 @@ public final void rule__ModeSwitchCondition__Group_1__0() throws RecognitionExce // $ANTLR start "rule__ModeSwitchCondition__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:6058:1: rule__ModeSwitchCondition__Group_1__0__Impl : ( ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) ) ; + // InternalBehaviorAnnexParser.g:6234:1: rule__ModeSwitchCondition__Group_1__0__Impl : ( ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) ) ; public final void rule__ModeSwitchCondition__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6062:1: ( ( ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) ) ) - // InternalBehaviorAnnexParser.g:6063:1: ( ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:6238:1: ( ( ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) ) ) + // InternalBehaviorAnnexParser.g:6239:1: ( ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) ) { - // InternalBehaviorAnnexParser.g:6063:1: ( ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) ) - // InternalBehaviorAnnexParser.g:6064:2: ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:6239:1: ( ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:6240:2: ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConditionAccess().getLogicalOperatorsAssignment_1_0()); } - // InternalBehaviorAnnexParser.g:6065:2: ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) - // InternalBehaviorAnnexParser.g:6065:3: rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 + // InternalBehaviorAnnexParser.g:6241:2: ( rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:6241:3: rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0(); @@ -21074,14 +21705,14 @@ public final void rule__ModeSwitchCondition__Group_1__0__Impl() throws Recogniti // $ANTLR start "rule__ModeSwitchCondition__Group_1__1" - // InternalBehaviorAnnexParser.g:6073:1: rule__ModeSwitchCondition__Group_1__1 : rule__ModeSwitchCondition__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:6249:1: rule__ModeSwitchCondition__Group_1__1 : rule__ModeSwitchCondition__Group_1__1__Impl ; public final void rule__ModeSwitchCondition__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6077:1: ( rule__ModeSwitchCondition__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:6078:2: rule__ModeSwitchCondition__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:6253:1: ( rule__ModeSwitchCondition__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:6254:2: rule__ModeSwitchCondition__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchCondition__Group_1__1__Impl(); @@ -21107,23 +21738,23 @@ public final void rule__ModeSwitchCondition__Group_1__1() throws RecognitionExce // $ANTLR start "rule__ModeSwitchCondition__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:6084:1: rule__ModeSwitchCondition__Group_1__1__Impl : ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:6260:1: rule__ModeSwitchCondition__Group_1__1__Impl : ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) ) ; public final void rule__ModeSwitchCondition__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6088:1: ( ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:6089:1: ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:6264:1: ( ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:6265:1: ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:6089:1: ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:6090:2: ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:6265:1: ( ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:6266:2: ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConditionAccess().getConjunctionsAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:6091:2: ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:6091:3: rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 + // InternalBehaviorAnnexParser.g:6267:2: ( rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:6267:3: rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchCondition__ConjunctionsAssignment_1_1(); @@ -21158,14 +21789,14 @@ public final void rule__ModeSwitchCondition__Group_1__1__Impl() throws Recogniti // $ANTLR start "rule__ModeSwitchConjunction__Group__0" - // InternalBehaviorAnnexParser.g:6100:1: rule__ModeSwitchConjunction__Group__0 : rule__ModeSwitchConjunction__Group__0__Impl rule__ModeSwitchConjunction__Group__1 ; + // InternalBehaviorAnnexParser.g:6276:1: rule__ModeSwitchConjunction__Group__0 : rule__ModeSwitchConjunction__Group__0__Impl rule__ModeSwitchConjunction__Group__1 ; public final void rule__ModeSwitchConjunction__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6104:1: ( rule__ModeSwitchConjunction__Group__0__Impl rule__ModeSwitchConjunction__Group__1 ) - // InternalBehaviorAnnexParser.g:6105:2: rule__ModeSwitchConjunction__Group__0__Impl rule__ModeSwitchConjunction__Group__1 + // InternalBehaviorAnnexParser.g:6280:1: ( rule__ModeSwitchConjunction__Group__0__Impl rule__ModeSwitchConjunction__Group__1 ) + // InternalBehaviorAnnexParser.g:6281:2: rule__ModeSwitchConjunction__Group__0__Impl rule__ModeSwitchConjunction__Group__1 { pushFollow(FollowSets000.FOLLOW_33); rule__ModeSwitchConjunction__Group__0__Impl(); @@ -21196,23 +21827,23 @@ public final void rule__ModeSwitchConjunction__Group__0() throws RecognitionExce // $ANTLR start "rule__ModeSwitchConjunction__Group__0__Impl" - // InternalBehaviorAnnexParser.g:6112:1: rule__ModeSwitchConjunction__Group__0__Impl : ( ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:6288:1: rule__ModeSwitchConjunction__Group__0__Impl : ( ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) ) ; public final void rule__ModeSwitchConjunction__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6116:1: ( ( ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:6117:1: ( ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:6292:1: ( ( ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:6293:1: ( ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:6117:1: ( ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:6118:2: ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) + // InternalBehaviorAnnexParser.g:6293:1: ( ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:6294:2: ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConjunctionAccess().getTriggersAssignment_0()); } - // InternalBehaviorAnnexParser.g:6119:2: ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) - // InternalBehaviorAnnexParser.g:6119:3: rule__ModeSwitchConjunction__TriggersAssignment_0 + // InternalBehaviorAnnexParser.g:6295:2: ( rule__ModeSwitchConjunction__TriggersAssignment_0 ) + // InternalBehaviorAnnexParser.g:6295:3: rule__ModeSwitchConjunction__TriggersAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchConjunction__TriggersAssignment_0(); @@ -21247,14 +21878,14 @@ public final void rule__ModeSwitchConjunction__Group__0__Impl() throws Recogniti // $ANTLR start "rule__ModeSwitchConjunction__Group__1" - // InternalBehaviorAnnexParser.g:6127:1: rule__ModeSwitchConjunction__Group__1 : rule__ModeSwitchConjunction__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:6303:1: rule__ModeSwitchConjunction__Group__1 : rule__ModeSwitchConjunction__Group__1__Impl ; public final void rule__ModeSwitchConjunction__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6131:1: ( rule__ModeSwitchConjunction__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:6132:2: rule__ModeSwitchConjunction__Group__1__Impl + // InternalBehaviorAnnexParser.g:6307:1: ( rule__ModeSwitchConjunction__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:6308:2: rule__ModeSwitchConjunction__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchConjunction__Group__1__Impl(); @@ -21280,35 +21911,35 @@ public final void rule__ModeSwitchConjunction__Group__1() throws RecognitionExce // $ANTLR start "rule__ModeSwitchConjunction__Group__1__Impl" - // InternalBehaviorAnnexParser.g:6138:1: rule__ModeSwitchConjunction__Group__1__Impl : ( ( rule__ModeSwitchConjunction__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:6314:1: rule__ModeSwitchConjunction__Group__1__Impl : ( ( rule__ModeSwitchConjunction__Group_1__0 )* ) ; public final void rule__ModeSwitchConjunction__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6142:1: ( ( ( rule__ModeSwitchConjunction__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:6143:1: ( ( rule__ModeSwitchConjunction__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:6318:1: ( ( ( rule__ModeSwitchConjunction__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:6319:1: ( ( rule__ModeSwitchConjunction__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:6143:1: ( ( rule__ModeSwitchConjunction__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:6144:2: ( rule__ModeSwitchConjunction__Group_1__0 )* + // InternalBehaviorAnnexParser.g:6319:1: ( ( rule__ModeSwitchConjunction__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:6320:2: ( rule__ModeSwitchConjunction__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConjunctionAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:6145:2: ( rule__ModeSwitchConjunction__Group_1__0 )* - loop65: + // InternalBehaviorAnnexParser.g:6321:2: ( rule__ModeSwitchConjunction__Group_1__0 )* + loop68: do { - int alt65=2; - int LA65_0 = input.LA(1); + int alt68=2; + int LA68_0 = input.LA(1); - if ( (LA65_0==And) ) { - alt65=1; + if ( (LA68_0==And) ) { + alt68=1; } - switch (alt65) { + switch (alt68) { case 1 : - // InternalBehaviorAnnexParser.g:6145:3: rule__ModeSwitchConjunction__Group_1__0 + // InternalBehaviorAnnexParser.g:6321:3: rule__ModeSwitchConjunction__Group_1__0 { pushFollow(FollowSets000.FOLLOW_34); rule__ModeSwitchConjunction__Group_1__0(); @@ -21320,7 +21951,7 @@ public final void rule__ModeSwitchConjunction__Group__1__Impl() throws Recogniti break; default : - break loop65; + break loop68; } } while (true); @@ -21349,14 +21980,14 @@ public final void rule__ModeSwitchConjunction__Group__1__Impl() throws Recogniti // $ANTLR start "rule__ModeSwitchConjunction__Group_1__0" - // InternalBehaviorAnnexParser.g:6154:1: rule__ModeSwitchConjunction__Group_1__0 : rule__ModeSwitchConjunction__Group_1__0__Impl rule__ModeSwitchConjunction__Group_1__1 ; + // InternalBehaviorAnnexParser.g:6330:1: rule__ModeSwitchConjunction__Group_1__0 : rule__ModeSwitchConjunction__Group_1__0__Impl rule__ModeSwitchConjunction__Group_1__1 ; public final void rule__ModeSwitchConjunction__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6158:1: ( rule__ModeSwitchConjunction__Group_1__0__Impl rule__ModeSwitchConjunction__Group_1__1 ) - // InternalBehaviorAnnexParser.g:6159:2: rule__ModeSwitchConjunction__Group_1__0__Impl rule__ModeSwitchConjunction__Group_1__1 + // InternalBehaviorAnnexParser.g:6334:1: ( rule__ModeSwitchConjunction__Group_1__0__Impl rule__ModeSwitchConjunction__Group_1__1 ) + // InternalBehaviorAnnexParser.g:6335:2: rule__ModeSwitchConjunction__Group_1__0__Impl rule__ModeSwitchConjunction__Group_1__1 { pushFollow(FollowSets000.FOLLOW_24); rule__ModeSwitchConjunction__Group_1__0__Impl(); @@ -21387,23 +22018,23 @@ public final void rule__ModeSwitchConjunction__Group_1__0() throws RecognitionEx // $ANTLR start "rule__ModeSwitchConjunction__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:6166:1: rule__ModeSwitchConjunction__Group_1__0__Impl : ( ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) ) ; + // InternalBehaviorAnnexParser.g:6342:1: rule__ModeSwitchConjunction__Group_1__0__Impl : ( ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) ) ; public final void rule__ModeSwitchConjunction__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6170:1: ( ( ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) ) ) - // InternalBehaviorAnnexParser.g:6171:1: ( ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:6346:1: ( ( ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) ) ) + // InternalBehaviorAnnexParser.g:6347:1: ( ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) ) { - // InternalBehaviorAnnexParser.g:6171:1: ( ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) ) - // InternalBehaviorAnnexParser.g:6172:2: ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:6347:1: ( ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:6348:2: ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConjunctionAccess().getLogicalOperatorsAssignment_1_0()); } - // InternalBehaviorAnnexParser.g:6173:2: ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) - // InternalBehaviorAnnexParser.g:6173:3: rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 + // InternalBehaviorAnnexParser.g:6349:2: ( rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:6349:3: rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0(); @@ -21438,14 +22069,14 @@ public final void rule__ModeSwitchConjunction__Group_1__0__Impl() throws Recogni // $ANTLR start "rule__ModeSwitchConjunction__Group_1__1" - // InternalBehaviorAnnexParser.g:6181:1: rule__ModeSwitchConjunction__Group_1__1 : rule__ModeSwitchConjunction__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:6357:1: rule__ModeSwitchConjunction__Group_1__1 : rule__ModeSwitchConjunction__Group_1__1__Impl ; public final void rule__ModeSwitchConjunction__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6185:1: ( rule__ModeSwitchConjunction__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:6186:2: rule__ModeSwitchConjunction__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:6361:1: ( rule__ModeSwitchConjunction__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:6362:2: rule__ModeSwitchConjunction__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchConjunction__Group_1__1__Impl(); @@ -21471,23 +22102,23 @@ public final void rule__ModeSwitchConjunction__Group_1__1() throws RecognitionEx // $ANTLR start "rule__ModeSwitchConjunction__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:6192:1: rule__ModeSwitchConjunction__Group_1__1__Impl : ( ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:6368:1: rule__ModeSwitchConjunction__Group_1__1__Impl : ( ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) ) ; public final void rule__ModeSwitchConjunction__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6196:1: ( ( ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:6197:1: ( ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:6372:1: ( ( ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:6373:1: ( ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:6197:1: ( ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:6198:2: ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:6373:1: ( ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:6374:2: ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConjunctionAccess().getTriggersAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:6199:2: ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:6199:3: rule__ModeSwitchConjunction__TriggersAssignment_1_1 + // InternalBehaviorAnnexParser.g:6375:2: ( rule__ModeSwitchConjunction__TriggersAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:6375:3: rule__ModeSwitchConjunction__TriggersAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchConjunction__TriggersAssignment_1_1(); @@ -21522,14 +22153,14 @@ public final void rule__ModeSwitchConjunction__Group_1__1__Impl() throws Recogni // $ANTLR start "rule__ModeSwitchTrigger__Group_1__0" - // InternalBehaviorAnnexParser.g:6208:1: rule__ModeSwitchTrigger__Group_1__0 : rule__ModeSwitchTrigger__Group_1__0__Impl rule__ModeSwitchTrigger__Group_1__1 ; + // InternalBehaviorAnnexParser.g:6384:1: rule__ModeSwitchTrigger__Group_1__0 : rule__ModeSwitchTrigger__Group_1__0__Impl rule__ModeSwitchTrigger__Group_1__1 ; public final void rule__ModeSwitchTrigger__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6212:1: ( rule__ModeSwitchTrigger__Group_1__0__Impl rule__ModeSwitchTrigger__Group_1__1 ) - // InternalBehaviorAnnexParser.g:6213:2: rule__ModeSwitchTrigger__Group_1__0__Impl rule__ModeSwitchTrigger__Group_1__1 + // InternalBehaviorAnnexParser.g:6388:1: ( rule__ModeSwitchTrigger__Group_1__0__Impl rule__ModeSwitchTrigger__Group_1__1 ) + // InternalBehaviorAnnexParser.g:6389:2: rule__ModeSwitchTrigger__Group_1__0__Impl rule__ModeSwitchTrigger__Group_1__1 { pushFollow(FollowSets000.FOLLOW_24); rule__ModeSwitchTrigger__Group_1__0__Impl(); @@ -21560,17 +22191,17 @@ public final void rule__ModeSwitchTrigger__Group_1__0() throws RecognitionExcept // $ANTLR start "rule__ModeSwitchTrigger__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:6220:1: rule__ModeSwitchTrigger__Group_1__0__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:6396:1: rule__ModeSwitchTrigger__Group_1__0__Impl : ( LeftParenthesis ) ; public final void rule__ModeSwitchTrigger__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6224:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:6225:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:6400:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:6401:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:6225:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:6226:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:6401:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:6402:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchTriggerAccess().getLeftParenthesisKeyword_1_0()); @@ -21601,14 +22232,14 @@ public final void rule__ModeSwitchTrigger__Group_1__0__Impl() throws Recognition // $ANTLR start "rule__ModeSwitchTrigger__Group_1__1" - // InternalBehaviorAnnexParser.g:6235:1: rule__ModeSwitchTrigger__Group_1__1 : rule__ModeSwitchTrigger__Group_1__1__Impl rule__ModeSwitchTrigger__Group_1__2 ; + // InternalBehaviorAnnexParser.g:6411:1: rule__ModeSwitchTrigger__Group_1__1 : rule__ModeSwitchTrigger__Group_1__1__Impl rule__ModeSwitchTrigger__Group_1__2 ; public final void rule__ModeSwitchTrigger__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6239:1: ( rule__ModeSwitchTrigger__Group_1__1__Impl rule__ModeSwitchTrigger__Group_1__2 ) - // InternalBehaviorAnnexParser.g:6240:2: rule__ModeSwitchTrigger__Group_1__1__Impl rule__ModeSwitchTrigger__Group_1__2 + // InternalBehaviorAnnexParser.g:6415:1: ( rule__ModeSwitchTrigger__Group_1__1__Impl rule__ModeSwitchTrigger__Group_1__2 ) + // InternalBehaviorAnnexParser.g:6416:2: rule__ModeSwitchTrigger__Group_1__1__Impl rule__ModeSwitchTrigger__Group_1__2 { pushFollow(FollowSets000.FOLLOW_37); rule__ModeSwitchTrigger__Group_1__1__Impl(); @@ -21639,23 +22270,23 @@ public final void rule__ModeSwitchTrigger__Group_1__1() throws RecognitionExcept // $ANTLR start "rule__ModeSwitchTrigger__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:6247:1: rule__ModeSwitchTrigger__Group_1__1__Impl : ( ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:6423:1: rule__ModeSwitchTrigger__Group_1__1__Impl : ( ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) ) ; public final void rule__ModeSwitchTrigger__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6251:1: ( ( ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:6252:1: ( ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:6427:1: ( ( ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:6428:1: ( ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:6252:1: ( ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:6253:2: ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:6428:1: ( ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:6429:2: ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchTriggerAccess().getExpressionAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:6254:2: ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:6254:3: rule__ModeSwitchTrigger__ExpressionAssignment_1_1 + // InternalBehaviorAnnexParser.g:6430:2: ( rule__ModeSwitchTrigger__ExpressionAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:6430:3: rule__ModeSwitchTrigger__ExpressionAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchTrigger__ExpressionAssignment_1_1(); @@ -21690,14 +22321,14 @@ public final void rule__ModeSwitchTrigger__Group_1__1__Impl() throws Recognition // $ANTLR start "rule__ModeSwitchTrigger__Group_1__2" - // InternalBehaviorAnnexParser.g:6262:1: rule__ModeSwitchTrigger__Group_1__2 : rule__ModeSwitchTrigger__Group_1__2__Impl ; + // InternalBehaviorAnnexParser.g:6438:1: rule__ModeSwitchTrigger__Group_1__2 : rule__ModeSwitchTrigger__Group_1__2__Impl ; public final void rule__ModeSwitchTrigger__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6266:1: ( rule__ModeSwitchTrigger__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:6267:2: rule__ModeSwitchTrigger__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:6442:1: ( rule__ModeSwitchTrigger__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:6443:2: rule__ModeSwitchTrigger__Group_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ModeSwitchTrigger__Group_1__2__Impl(); @@ -21723,17 +22354,17 @@ public final void rule__ModeSwitchTrigger__Group_1__2() throws RecognitionExcept // $ANTLR start "rule__ModeSwitchTrigger__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:6273:1: rule__ModeSwitchTrigger__Group_1__2__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:6449:1: rule__ModeSwitchTrigger__Group_1__2__Impl : ( RightParenthesis ) ; public final void rule__ModeSwitchTrigger__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6277:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:6278:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:6453:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:6454:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:6278:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:6279:2: RightParenthesis + // InternalBehaviorAnnexParser.g:6454:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:6455:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchTriggerAccess().getRightParenthesisKeyword_1_2()); @@ -21764,14 +22395,14 @@ public final void rule__ModeSwitchTrigger__Group_1__2__Impl() throws Recognition // $ANTLR start "rule__InternalCondition__Group__0" - // InternalBehaviorAnnexParser.g:6289:1: rule__InternalCondition__Group__0 : rule__InternalCondition__Group__0__Impl rule__InternalCondition__Group__1 ; + // InternalBehaviorAnnexParser.g:6465:1: rule__InternalCondition__Group__0 : rule__InternalCondition__Group__0__Impl rule__InternalCondition__Group__1 ; public final void rule__InternalCondition__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6293:1: ( rule__InternalCondition__Group__0__Impl rule__InternalCondition__Group__1 ) - // InternalBehaviorAnnexParser.g:6294:2: rule__InternalCondition__Group__0__Impl rule__InternalCondition__Group__1 + // InternalBehaviorAnnexParser.g:6469:1: ( rule__InternalCondition__Group__0__Impl rule__InternalCondition__Group__1 ) + // InternalBehaviorAnnexParser.g:6470:2: rule__InternalCondition__Group__0__Impl rule__InternalCondition__Group__1 { pushFollow(FollowSets000.FOLLOW_13); rule__InternalCondition__Group__0__Impl(); @@ -21802,17 +22433,17 @@ public final void rule__InternalCondition__Group__0() throws RecognitionExceptio // $ANTLR start "rule__InternalCondition__Group__0__Impl" - // InternalBehaviorAnnexParser.g:6301:1: rule__InternalCondition__Group__0__Impl : ( Internal ) ; + // InternalBehaviorAnnexParser.g:6477:1: rule__InternalCondition__Group__0__Impl : ( Internal ) ; public final void rule__InternalCondition__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6305:1: ( ( Internal ) ) - // InternalBehaviorAnnexParser.g:6306:1: ( Internal ) + // InternalBehaviorAnnexParser.g:6481:1: ( ( Internal ) ) + // InternalBehaviorAnnexParser.g:6482:1: ( Internal ) { - // InternalBehaviorAnnexParser.g:6306:1: ( Internal ) - // InternalBehaviorAnnexParser.g:6307:2: Internal + // InternalBehaviorAnnexParser.g:6482:1: ( Internal ) + // InternalBehaviorAnnexParser.g:6483:2: Internal { if ( state.backtracking==0 ) { before(grammarAccess.getInternalConditionAccess().getInternalKeyword_0()); @@ -21843,14 +22474,14 @@ public final void rule__InternalCondition__Group__0__Impl() throws RecognitionEx // $ANTLR start "rule__InternalCondition__Group__1" - // InternalBehaviorAnnexParser.g:6316:1: rule__InternalCondition__Group__1 : rule__InternalCondition__Group__1__Impl rule__InternalCondition__Group__2 ; + // InternalBehaviorAnnexParser.g:6492:1: rule__InternalCondition__Group__1 : rule__InternalCondition__Group__1__Impl rule__InternalCondition__Group__2 ; public final void rule__InternalCondition__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6320:1: ( rule__InternalCondition__Group__1__Impl rule__InternalCondition__Group__2 ) - // InternalBehaviorAnnexParser.g:6321:2: rule__InternalCondition__Group__1__Impl rule__InternalCondition__Group__2 + // InternalBehaviorAnnexParser.g:6496:1: ( rule__InternalCondition__Group__1__Impl rule__InternalCondition__Group__2 ) + // InternalBehaviorAnnexParser.g:6497:2: rule__InternalCondition__Group__1__Impl rule__InternalCondition__Group__2 { pushFollow(FollowSets000.FOLLOW_32); rule__InternalCondition__Group__1__Impl(); @@ -21881,23 +22512,23 @@ public final void rule__InternalCondition__Group__1() throws RecognitionExceptio // $ANTLR start "rule__InternalCondition__Group__1__Impl" - // InternalBehaviorAnnexParser.g:6328:1: rule__InternalCondition__Group__1__Impl : ( ( rule__InternalCondition__InternalPortsAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:6504:1: rule__InternalCondition__Group__1__Impl : ( ( rule__InternalCondition__InternalPortsAssignment_1 ) ) ; public final void rule__InternalCondition__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6332:1: ( ( ( rule__InternalCondition__InternalPortsAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:6333:1: ( ( rule__InternalCondition__InternalPortsAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:6508:1: ( ( ( rule__InternalCondition__InternalPortsAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:6509:1: ( ( rule__InternalCondition__InternalPortsAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:6333:1: ( ( rule__InternalCondition__InternalPortsAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:6334:2: ( rule__InternalCondition__InternalPortsAssignment_1 ) + // InternalBehaviorAnnexParser.g:6509:1: ( ( rule__InternalCondition__InternalPortsAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:6510:2: ( rule__InternalCondition__InternalPortsAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getInternalConditionAccess().getInternalPortsAssignment_1()); } - // InternalBehaviorAnnexParser.g:6335:2: ( rule__InternalCondition__InternalPortsAssignment_1 ) - // InternalBehaviorAnnexParser.g:6335:3: rule__InternalCondition__InternalPortsAssignment_1 + // InternalBehaviorAnnexParser.g:6511:2: ( rule__InternalCondition__InternalPortsAssignment_1 ) + // InternalBehaviorAnnexParser.g:6511:3: rule__InternalCondition__InternalPortsAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__InternalCondition__InternalPortsAssignment_1(); @@ -21932,14 +22563,14 @@ public final void rule__InternalCondition__Group__1__Impl() throws RecognitionEx // $ANTLR start "rule__InternalCondition__Group__2" - // InternalBehaviorAnnexParser.g:6343:1: rule__InternalCondition__Group__2 : rule__InternalCondition__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:6519:1: rule__InternalCondition__Group__2 : rule__InternalCondition__Group__2__Impl ; public final void rule__InternalCondition__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6347:1: ( rule__InternalCondition__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:6348:2: rule__InternalCondition__Group__2__Impl + // InternalBehaviorAnnexParser.g:6523:1: ( rule__InternalCondition__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:6524:2: rule__InternalCondition__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__InternalCondition__Group__2__Impl(); @@ -21965,35 +22596,35 @@ public final void rule__InternalCondition__Group__2() throws RecognitionExceptio // $ANTLR start "rule__InternalCondition__Group__2__Impl" - // InternalBehaviorAnnexParser.g:6354:1: rule__InternalCondition__Group__2__Impl : ( ( rule__InternalCondition__Group_2__0 )* ) ; + // InternalBehaviorAnnexParser.g:6530:1: rule__InternalCondition__Group__2__Impl : ( ( rule__InternalCondition__Group_2__0 )* ) ; public final void rule__InternalCondition__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6358:1: ( ( ( rule__InternalCondition__Group_2__0 )* ) ) - // InternalBehaviorAnnexParser.g:6359:1: ( ( rule__InternalCondition__Group_2__0 )* ) + // InternalBehaviorAnnexParser.g:6534:1: ( ( ( rule__InternalCondition__Group_2__0 )* ) ) + // InternalBehaviorAnnexParser.g:6535:1: ( ( rule__InternalCondition__Group_2__0 )* ) { - // InternalBehaviorAnnexParser.g:6359:1: ( ( rule__InternalCondition__Group_2__0 )* ) - // InternalBehaviorAnnexParser.g:6360:2: ( rule__InternalCondition__Group_2__0 )* + // InternalBehaviorAnnexParser.g:6535:1: ( ( rule__InternalCondition__Group_2__0 )* ) + // InternalBehaviorAnnexParser.g:6536:2: ( rule__InternalCondition__Group_2__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getInternalConditionAccess().getGroup_2()); } - // InternalBehaviorAnnexParser.g:6361:2: ( rule__InternalCondition__Group_2__0 )* - loop66: + // InternalBehaviorAnnexParser.g:6537:2: ( rule__InternalCondition__Group_2__0 )* + loop69: do { - int alt66=2; - int LA66_0 = input.LA(1); + int alt69=2; + int LA69_0 = input.LA(1); - if ( (LA66_0==Or) ) { - alt66=1; + if ( (LA69_0==Or) ) { + alt69=1; } - switch (alt66) { + switch (alt69) { case 1 : - // InternalBehaviorAnnexParser.g:6361:3: rule__InternalCondition__Group_2__0 + // InternalBehaviorAnnexParser.g:6537:3: rule__InternalCondition__Group_2__0 { pushFollow(FollowSets000.FOLLOW_31); rule__InternalCondition__Group_2__0(); @@ -22005,7 +22636,7 @@ public final void rule__InternalCondition__Group__2__Impl() throws RecognitionEx break; default : - break loop66; + break loop69; } } while (true); @@ -22034,14 +22665,14 @@ public final void rule__InternalCondition__Group__2__Impl() throws RecognitionEx // $ANTLR start "rule__InternalCondition__Group_2__0" - // InternalBehaviorAnnexParser.g:6370:1: rule__InternalCondition__Group_2__0 : rule__InternalCondition__Group_2__0__Impl rule__InternalCondition__Group_2__1 ; + // InternalBehaviorAnnexParser.g:6546:1: rule__InternalCondition__Group_2__0 : rule__InternalCondition__Group_2__0__Impl rule__InternalCondition__Group_2__1 ; public final void rule__InternalCondition__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6374:1: ( rule__InternalCondition__Group_2__0__Impl rule__InternalCondition__Group_2__1 ) - // InternalBehaviorAnnexParser.g:6375:2: rule__InternalCondition__Group_2__0__Impl rule__InternalCondition__Group_2__1 + // InternalBehaviorAnnexParser.g:6550:1: ( rule__InternalCondition__Group_2__0__Impl rule__InternalCondition__Group_2__1 ) + // InternalBehaviorAnnexParser.g:6551:2: rule__InternalCondition__Group_2__0__Impl rule__InternalCondition__Group_2__1 { pushFollow(FollowSets000.FOLLOW_13); rule__InternalCondition__Group_2__0__Impl(); @@ -22072,17 +22703,17 @@ public final void rule__InternalCondition__Group_2__0() throws RecognitionExcept // $ANTLR start "rule__InternalCondition__Group_2__0__Impl" - // InternalBehaviorAnnexParser.g:6382:1: rule__InternalCondition__Group_2__0__Impl : ( Or ) ; + // InternalBehaviorAnnexParser.g:6558:1: rule__InternalCondition__Group_2__0__Impl : ( Or ) ; public final void rule__InternalCondition__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6386:1: ( ( Or ) ) - // InternalBehaviorAnnexParser.g:6387:1: ( Or ) + // InternalBehaviorAnnexParser.g:6562:1: ( ( Or ) ) + // InternalBehaviorAnnexParser.g:6563:1: ( Or ) { - // InternalBehaviorAnnexParser.g:6387:1: ( Or ) - // InternalBehaviorAnnexParser.g:6388:2: Or + // InternalBehaviorAnnexParser.g:6563:1: ( Or ) + // InternalBehaviorAnnexParser.g:6564:2: Or { if ( state.backtracking==0 ) { before(grammarAccess.getInternalConditionAccess().getOrKeyword_2_0()); @@ -22113,14 +22744,14 @@ public final void rule__InternalCondition__Group_2__0__Impl() throws Recognition // $ANTLR start "rule__InternalCondition__Group_2__1" - // InternalBehaviorAnnexParser.g:6397:1: rule__InternalCondition__Group_2__1 : rule__InternalCondition__Group_2__1__Impl ; + // InternalBehaviorAnnexParser.g:6573:1: rule__InternalCondition__Group_2__1 : rule__InternalCondition__Group_2__1__Impl ; public final void rule__InternalCondition__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6401:1: ( rule__InternalCondition__Group_2__1__Impl ) - // InternalBehaviorAnnexParser.g:6402:2: rule__InternalCondition__Group_2__1__Impl + // InternalBehaviorAnnexParser.g:6577:1: ( rule__InternalCondition__Group_2__1__Impl ) + // InternalBehaviorAnnexParser.g:6578:2: rule__InternalCondition__Group_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__InternalCondition__Group_2__1__Impl(); @@ -22146,23 +22777,23 @@ public final void rule__InternalCondition__Group_2__1() throws RecognitionExcept // $ANTLR start "rule__InternalCondition__Group_2__1__Impl" - // InternalBehaviorAnnexParser.g:6408:1: rule__InternalCondition__Group_2__1__Impl : ( ( rule__InternalCondition__InternalPortsAssignment_2_1 ) ) ; + // InternalBehaviorAnnexParser.g:6584:1: rule__InternalCondition__Group_2__1__Impl : ( ( rule__InternalCondition__InternalPortsAssignment_2_1 ) ) ; public final void rule__InternalCondition__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6412:1: ( ( ( rule__InternalCondition__InternalPortsAssignment_2_1 ) ) ) - // InternalBehaviorAnnexParser.g:6413:1: ( ( rule__InternalCondition__InternalPortsAssignment_2_1 ) ) + // InternalBehaviorAnnexParser.g:6588:1: ( ( ( rule__InternalCondition__InternalPortsAssignment_2_1 ) ) ) + // InternalBehaviorAnnexParser.g:6589:1: ( ( rule__InternalCondition__InternalPortsAssignment_2_1 ) ) { - // InternalBehaviorAnnexParser.g:6413:1: ( ( rule__InternalCondition__InternalPortsAssignment_2_1 ) ) - // InternalBehaviorAnnexParser.g:6414:2: ( rule__InternalCondition__InternalPortsAssignment_2_1 ) + // InternalBehaviorAnnexParser.g:6589:1: ( ( rule__InternalCondition__InternalPortsAssignment_2_1 ) ) + // InternalBehaviorAnnexParser.g:6590:2: ( rule__InternalCondition__InternalPortsAssignment_2_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getInternalConditionAccess().getInternalPortsAssignment_2_1()); } - // InternalBehaviorAnnexParser.g:6415:2: ( rule__InternalCondition__InternalPortsAssignment_2_1 ) - // InternalBehaviorAnnexParser.g:6415:3: rule__InternalCondition__InternalPortsAssignment_2_1 + // InternalBehaviorAnnexParser.g:6591:2: ( rule__InternalCondition__InternalPortsAssignment_2_1 ) + // InternalBehaviorAnnexParser.g:6591:3: rule__InternalCondition__InternalPortsAssignment_2_1 { pushFollow(FollowSets000.FOLLOW_2); rule__InternalCondition__InternalPortsAssignment_2_1(); @@ -22197,14 +22828,14 @@ public final void rule__InternalCondition__Group_2__1__Impl() throws Recognition // $ANTLR start "rule__BehaviorActionBlock__Group__0" - // InternalBehaviorAnnexParser.g:6424:1: rule__BehaviorActionBlock__Group__0 : rule__BehaviorActionBlock__Group__0__Impl rule__BehaviorActionBlock__Group__1 ; + // InternalBehaviorAnnexParser.g:6600:1: rule__BehaviorActionBlock__Group__0 : rule__BehaviorActionBlock__Group__0__Impl rule__BehaviorActionBlock__Group__1 ; public final void rule__BehaviorActionBlock__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6428:1: ( rule__BehaviorActionBlock__Group__0__Impl rule__BehaviorActionBlock__Group__1 ) - // InternalBehaviorAnnexParser.g:6429:2: rule__BehaviorActionBlock__Group__0__Impl rule__BehaviorActionBlock__Group__1 + // InternalBehaviorAnnexParser.g:6604:1: ( rule__BehaviorActionBlock__Group__0__Impl rule__BehaviorActionBlock__Group__1 ) + // InternalBehaviorAnnexParser.g:6605:2: rule__BehaviorActionBlock__Group__0__Impl rule__BehaviorActionBlock__Group__1 { pushFollow(FollowSets000.FOLLOW_38); rule__BehaviorActionBlock__Group__0__Impl(); @@ -22235,17 +22866,17 @@ public final void rule__BehaviorActionBlock__Group__0() throws RecognitionExcept // $ANTLR start "rule__BehaviorActionBlock__Group__0__Impl" - // InternalBehaviorAnnexParser.g:6436:1: rule__BehaviorActionBlock__Group__0__Impl : ( LeftCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:6612:1: rule__BehaviorActionBlock__Group__0__Impl : ( LeftCurlyBracket ) ; public final void rule__BehaviorActionBlock__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6440:1: ( ( LeftCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:6441:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:6616:1: ( ( LeftCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:6617:1: ( LeftCurlyBracket ) { - // InternalBehaviorAnnexParser.g:6441:1: ( LeftCurlyBracket ) - // InternalBehaviorAnnexParser.g:6442:2: LeftCurlyBracket + // InternalBehaviorAnnexParser.g:6617:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:6618:2: LeftCurlyBracket { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionBlockAccess().getLeftCurlyBracketKeyword_0()); @@ -22276,14 +22907,14 @@ public final void rule__BehaviorActionBlock__Group__0__Impl() throws Recognition // $ANTLR start "rule__BehaviorActionBlock__Group__1" - // InternalBehaviorAnnexParser.g:6451:1: rule__BehaviorActionBlock__Group__1 : rule__BehaviorActionBlock__Group__1__Impl rule__BehaviorActionBlock__Group__2 ; + // InternalBehaviorAnnexParser.g:6627:1: rule__BehaviorActionBlock__Group__1 : rule__BehaviorActionBlock__Group__1__Impl rule__BehaviorActionBlock__Group__2 ; public final void rule__BehaviorActionBlock__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6455:1: ( rule__BehaviorActionBlock__Group__1__Impl rule__BehaviorActionBlock__Group__2 ) - // InternalBehaviorAnnexParser.g:6456:2: rule__BehaviorActionBlock__Group__1__Impl rule__BehaviorActionBlock__Group__2 + // InternalBehaviorAnnexParser.g:6631:1: ( rule__BehaviorActionBlock__Group__1__Impl rule__BehaviorActionBlock__Group__2 ) + // InternalBehaviorAnnexParser.g:6632:2: rule__BehaviorActionBlock__Group__1__Impl rule__BehaviorActionBlock__Group__2 { pushFollow(FollowSets000.FOLLOW_10); rule__BehaviorActionBlock__Group__1__Impl(); @@ -22314,23 +22945,23 @@ public final void rule__BehaviorActionBlock__Group__1() throws RecognitionExcept // $ANTLR start "rule__BehaviorActionBlock__Group__1__Impl" - // InternalBehaviorAnnexParser.g:6463:1: rule__BehaviorActionBlock__Group__1__Impl : ( ( rule__BehaviorActionBlock__ContentAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:6639:1: rule__BehaviorActionBlock__Group__1__Impl : ( ( rule__BehaviorActionBlock__ContentAssignment_1 ) ) ; public final void rule__BehaviorActionBlock__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6467:1: ( ( ( rule__BehaviorActionBlock__ContentAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:6468:1: ( ( rule__BehaviorActionBlock__ContentAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:6643:1: ( ( ( rule__BehaviorActionBlock__ContentAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:6644:1: ( ( rule__BehaviorActionBlock__ContentAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:6468:1: ( ( rule__BehaviorActionBlock__ContentAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:6469:2: ( rule__BehaviorActionBlock__ContentAssignment_1 ) + // InternalBehaviorAnnexParser.g:6644:1: ( ( rule__BehaviorActionBlock__ContentAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:6645:2: ( rule__BehaviorActionBlock__ContentAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionBlockAccess().getContentAssignment_1()); } - // InternalBehaviorAnnexParser.g:6470:2: ( rule__BehaviorActionBlock__ContentAssignment_1 ) - // InternalBehaviorAnnexParser.g:6470:3: rule__BehaviorActionBlock__ContentAssignment_1 + // InternalBehaviorAnnexParser.g:6646:2: ( rule__BehaviorActionBlock__ContentAssignment_1 ) + // InternalBehaviorAnnexParser.g:6646:3: rule__BehaviorActionBlock__ContentAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActionBlock__ContentAssignment_1(); @@ -22365,14 +22996,14 @@ public final void rule__BehaviorActionBlock__Group__1__Impl() throws Recognition // $ANTLR start "rule__BehaviorActionBlock__Group__2" - // InternalBehaviorAnnexParser.g:6478:1: rule__BehaviorActionBlock__Group__2 : rule__BehaviorActionBlock__Group__2__Impl rule__BehaviorActionBlock__Group__3 ; + // InternalBehaviorAnnexParser.g:6654:1: rule__BehaviorActionBlock__Group__2 : rule__BehaviorActionBlock__Group__2__Impl rule__BehaviorActionBlock__Group__3 ; public final void rule__BehaviorActionBlock__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6482:1: ( rule__BehaviorActionBlock__Group__2__Impl rule__BehaviorActionBlock__Group__3 ) - // InternalBehaviorAnnexParser.g:6483:2: rule__BehaviorActionBlock__Group__2__Impl rule__BehaviorActionBlock__Group__3 + // InternalBehaviorAnnexParser.g:6658:1: ( rule__BehaviorActionBlock__Group__2__Impl rule__BehaviorActionBlock__Group__3 ) + // InternalBehaviorAnnexParser.g:6659:2: rule__BehaviorActionBlock__Group__2__Impl rule__BehaviorActionBlock__Group__3 { pushFollow(FollowSets000.FOLLOW_39); rule__BehaviorActionBlock__Group__2__Impl(); @@ -22403,17 +23034,17 @@ public final void rule__BehaviorActionBlock__Group__2() throws RecognitionExcept // $ANTLR start "rule__BehaviorActionBlock__Group__2__Impl" - // InternalBehaviorAnnexParser.g:6490:1: rule__BehaviorActionBlock__Group__2__Impl : ( RightCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:6666:1: rule__BehaviorActionBlock__Group__2__Impl : ( RightCurlyBracket ) ; public final void rule__BehaviorActionBlock__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6494:1: ( ( RightCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:6495:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:6670:1: ( ( RightCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:6671:1: ( RightCurlyBracket ) { - // InternalBehaviorAnnexParser.g:6495:1: ( RightCurlyBracket ) - // InternalBehaviorAnnexParser.g:6496:2: RightCurlyBracket + // InternalBehaviorAnnexParser.g:6671:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:6672:2: RightCurlyBracket { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionBlockAccess().getRightCurlyBracketKeyword_2()); @@ -22444,14 +23075,14 @@ public final void rule__BehaviorActionBlock__Group__2__Impl() throws Recognition // $ANTLR start "rule__BehaviorActionBlock__Group__3" - // InternalBehaviorAnnexParser.g:6505:1: rule__BehaviorActionBlock__Group__3 : rule__BehaviorActionBlock__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:6681:1: rule__BehaviorActionBlock__Group__3 : rule__BehaviorActionBlock__Group__3__Impl ; public final void rule__BehaviorActionBlock__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6509:1: ( rule__BehaviorActionBlock__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:6510:2: rule__BehaviorActionBlock__Group__3__Impl + // InternalBehaviorAnnexParser.g:6685:1: ( rule__BehaviorActionBlock__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:6686:2: rule__BehaviorActionBlock__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActionBlock__Group__3__Impl(); @@ -22477,31 +23108,31 @@ public final void rule__BehaviorActionBlock__Group__3() throws RecognitionExcept // $ANTLR start "rule__BehaviorActionBlock__Group__3__Impl" - // InternalBehaviorAnnexParser.g:6516:1: rule__BehaviorActionBlock__Group__3__Impl : ( ( rule__BehaviorActionBlock__Group_3__0 )? ) ; + // InternalBehaviorAnnexParser.g:6692:1: rule__BehaviorActionBlock__Group__3__Impl : ( ( rule__BehaviorActionBlock__Group_3__0 )? ) ; public final void rule__BehaviorActionBlock__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6520:1: ( ( ( rule__BehaviorActionBlock__Group_3__0 )? ) ) - // InternalBehaviorAnnexParser.g:6521:1: ( ( rule__BehaviorActionBlock__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:6696:1: ( ( ( rule__BehaviorActionBlock__Group_3__0 )? ) ) + // InternalBehaviorAnnexParser.g:6697:1: ( ( rule__BehaviorActionBlock__Group_3__0 )? ) { - // InternalBehaviorAnnexParser.g:6521:1: ( ( rule__BehaviorActionBlock__Group_3__0 )? ) - // InternalBehaviorAnnexParser.g:6522:2: ( rule__BehaviorActionBlock__Group_3__0 )? + // InternalBehaviorAnnexParser.g:6697:1: ( ( rule__BehaviorActionBlock__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:6698:2: ( rule__BehaviorActionBlock__Group_3__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionBlockAccess().getGroup_3()); } - // InternalBehaviorAnnexParser.g:6523:2: ( rule__BehaviorActionBlock__Group_3__0 )? - int alt67=2; - int LA67_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6699:2: ( rule__BehaviorActionBlock__Group_3__0 )? + int alt70=2; + int LA70_0 = input.LA(1); - if ( (LA67_0==Timeout) ) { - alt67=1; + if ( (LA70_0==Timeout) ) { + alt70=1; } - switch (alt67) { + switch (alt70) { case 1 : - // InternalBehaviorAnnexParser.g:6523:3: rule__BehaviorActionBlock__Group_3__0 + // InternalBehaviorAnnexParser.g:6699:3: rule__BehaviorActionBlock__Group_3__0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActionBlock__Group_3__0(); @@ -22539,14 +23170,14 @@ public final void rule__BehaviorActionBlock__Group__3__Impl() throws Recognition // $ANTLR start "rule__BehaviorActionBlock__Group_3__0" - // InternalBehaviorAnnexParser.g:6532:1: rule__BehaviorActionBlock__Group_3__0 : rule__BehaviorActionBlock__Group_3__0__Impl rule__BehaviorActionBlock__Group_3__1 ; + // InternalBehaviorAnnexParser.g:6708:1: rule__BehaviorActionBlock__Group_3__0 : rule__BehaviorActionBlock__Group_3__0__Impl rule__BehaviorActionBlock__Group_3__1 ; public final void rule__BehaviorActionBlock__Group_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6536:1: ( rule__BehaviorActionBlock__Group_3__0__Impl rule__BehaviorActionBlock__Group_3__1 ) - // InternalBehaviorAnnexParser.g:6537:2: rule__BehaviorActionBlock__Group_3__0__Impl rule__BehaviorActionBlock__Group_3__1 + // InternalBehaviorAnnexParser.g:6712:1: ( rule__BehaviorActionBlock__Group_3__0__Impl rule__BehaviorActionBlock__Group_3__1 ) + // InternalBehaviorAnnexParser.g:6713:2: rule__BehaviorActionBlock__Group_3__0__Impl rule__BehaviorActionBlock__Group_3__1 { pushFollow(FollowSets000.FOLLOW_13); rule__BehaviorActionBlock__Group_3__0__Impl(); @@ -22577,17 +23208,17 @@ public final void rule__BehaviorActionBlock__Group_3__0() throws RecognitionExce // $ANTLR start "rule__BehaviorActionBlock__Group_3__0__Impl" - // InternalBehaviorAnnexParser.g:6544:1: rule__BehaviorActionBlock__Group_3__0__Impl : ( Timeout ) ; + // InternalBehaviorAnnexParser.g:6720:1: rule__BehaviorActionBlock__Group_3__0__Impl : ( Timeout ) ; public final void rule__BehaviorActionBlock__Group_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6548:1: ( ( Timeout ) ) - // InternalBehaviorAnnexParser.g:6549:1: ( Timeout ) + // InternalBehaviorAnnexParser.g:6724:1: ( ( Timeout ) ) + // InternalBehaviorAnnexParser.g:6725:1: ( Timeout ) { - // InternalBehaviorAnnexParser.g:6549:1: ( Timeout ) - // InternalBehaviorAnnexParser.g:6550:2: Timeout + // InternalBehaviorAnnexParser.g:6725:1: ( Timeout ) + // InternalBehaviorAnnexParser.g:6726:2: Timeout { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionBlockAccess().getTimeoutKeyword_3_0()); @@ -22618,14 +23249,14 @@ public final void rule__BehaviorActionBlock__Group_3__0__Impl() throws Recogniti // $ANTLR start "rule__BehaviorActionBlock__Group_3__1" - // InternalBehaviorAnnexParser.g:6559:1: rule__BehaviorActionBlock__Group_3__1 : rule__BehaviorActionBlock__Group_3__1__Impl ; + // InternalBehaviorAnnexParser.g:6735:1: rule__BehaviorActionBlock__Group_3__1 : rule__BehaviorActionBlock__Group_3__1__Impl ; public final void rule__BehaviorActionBlock__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6563:1: ( rule__BehaviorActionBlock__Group_3__1__Impl ) - // InternalBehaviorAnnexParser.g:6564:2: rule__BehaviorActionBlock__Group_3__1__Impl + // InternalBehaviorAnnexParser.g:6739:1: ( rule__BehaviorActionBlock__Group_3__1__Impl ) + // InternalBehaviorAnnexParser.g:6740:2: rule__BehaviorActionBlock__Group_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActionBlock__Group_3__1__Impl(); @@ -22651,23 +23282,23 @@ public final void rule__BehaviorActionBlock__Group_3__1() throws RecognitionExce // $ANTLR start "rule__BehaviorActionBlock__Group_3__1__Impl" - // InternalBehaviorAnnexParser.g:6570:1: rule__BehaviorActionBlock__Group_3__1__Impl : ( ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:6746:1: rule__BehaviorActionBlock__Group_3__1__Impl : ( ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) ) ; public final void rule__BehaviorActionBlock__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6574:1: ( ( ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:6575:1: ( ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:6750:1: ( ( ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:6751:1: ( ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) ) { - // InternalBehaviorAnnexParser.g:6575:1: ( ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) ) - // InternalBehaviorAnnexParser.g:6576:2: ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:6751:1: ( ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:6752:2: ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionBlockAccess().getTimeoutAssignment_3_1()); } - // InternalBehaviorAnnexParser.g:6577:2: ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) - // InternalBehaviorAnnexParser.g:6577:3: rule__BehaviorActionBlock__TimeoutAssignment_3_1 + // InternalBehaviorAnnexParser.g:6753:2: ( rule__BehaviorActionBlock__TimeoutAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:6753:3: rule__BehaviorActionBlock__TimeoutAssignment_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActionBlock__TimeoutAssignment_3_1(); @@ -22702,14 +23333,14 @@ public final void rule__BehaviorActionBlock__Group_3__1__Impl() throws Recogniti // $ANTLR start "rule__BehaviorActions__Group__0" - // InternalBehaviorAnnexParser.g:6586:1: rule__BehaviorActions__Group__0 : rule__BehaviorActions__Group__0__Impl rule__BehaviorActions__Group__1 ; + // InternalBehaviorAnnexParser.g:6762:1: rule__BehaviorActions__Group__0 : rule__BehaviorActions__Group__0__Impl rule__BehaviorActions__Group__1 ; public final void rule__BehaviorActions__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6590:1: ( rule__BehaviorActions__Group__0__Impl rule__BehaviorActions__Group__1 ) - // InternalBehaviorAnnexParser.g:6591:2: rule__BehaviorActions__Group__0__Impl rule__BehaviorActions__Group__1 + // InternalBehaviorAnnexParser.g:6766:1: ( rule__BehaviorActions__Group__0__Impl rule__BehaviorActions__Group__1 ) + // InternalBehaviorAnnexParser.g:6767:2: rule__BehaviorActions__Group__0__Impl rule__BehaviorActions__Group__1 { pushFollow(FollowSets000.FOLLOW_40); rule__BehaviorActions__Group__0__Impl(); @@ -22740,17 +23371,17 @@ public final void rule__BehaviorActions__Group__0() throws RecognitionException // $ANTLR start "rule__BehaviorActions__Group__0__Impl" - // InternalBehaviorAnnexParser.g:6598:1: rule__BehaviorActions__Group__0__Impl : ( ruleBehaviorAction ) ; + // InternalBehaviorAnnexParser.g:6774:1: rule__BehaviorActions__Group__0__Impl : ( ruleBehaviorAction ) ; public final void rule__BehaviorActions__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6602:1: ( ( ruleBehaviorAction ) ) - // InternalBehaviorAnnexParser.g:6603:1: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:6778:1: ( ( ruleBehaviorAction ) ) + // InternalBehaviorAnnexParser.g:6779:1: ( ruleBehaviorAction ) { - // InternalBehaviorAnnexParser.g:6603:1: ( ruleBehaviorAction ) - // InternalBehaviorAnnexParser.g:6604:2: ruleBehaviorAction + // InternalBehaviorAnnexParser.g:6779:1: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:6780:2: ruleBehaviorAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getBehaviorActionParserRuleCall_0()); @@ -22785,14 +23416,14 @@ public final void rule__BehaviorActions__Group__0__Impl() throws RecognitionExce // $ANTLR start "rule__BehaviorActions__Group__1" - // InternalBehaviorAnnexParser.g:6613:1: rule__BehaviorActions__Group__1 : rule__BehaviorActions__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:6789:1: rule__BehaviorActions__Group__1 : rule__BehaviorActions__Group__1__Impl ; public final void rule__BehaviorActions__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6617:1: ( rule__BehaviorActions__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:6618:2: rule__BehaviorActions__Group__1__Impl + // InternalBehaviorAnnexParser.g:6793:1: ( rule__BehaviorActions__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:6794:2: rule__BehaviorActions__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__Group__1__Impl(); @@ -22818,31 +23449,31 @@ public final void rule__BehaviorActions__Group__1() throws RecognitionException // $ANTLR start "rule__BehaviorActions__Group__1__Impl" - // InternalBehaviorAnnexParser.g:6624:1: rule__BehaviorActions__Group__1__Impl : ( ( rule__BehaviorActions__Alternatives_1 )? ) ; + // InternalBehaviorAnnexParser.g:6800:1: rule__BehaviorActions__Group__1__Impl : ( ( rule__BehaviorActions__Alternatives_1 )? ) ; public final void rule__BehaviorActions__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6628:1: ( ( ( rule__BehaviorActions__Alternatives_1 )? ) ) - // InternalBehaviorAnnexParser.g:6629:1: ( ( rule__BehaviorActions__Alternatives_1 )? ) + // InternalBehaviorAnnexParser.g:6804:1: ( ( ( rule__BehaviorActions__Alternatives_1 )? ) ) + // InternalBehaviorAnnexParser.g:6805:1: ( ( rule__BehaviorActions__Alternatives_1 )? ) { - // InternalBehaviorAnnexParser.g:6629:1: ( ( rule__BehaviorActions__Alternatives_1 )? ) - // InternalBehaviorAnnexParser.g:6630:2: ( rule__BehaviorActions__Alternatives_1 )? + // InternalBehaviorAnnexParser.g:6805:1: ( ( rule__BehaviorActions__Alternatives_1 )? ) + // InternalBehaviorAnnexParser.g:6806:2: ( rule__BehaviorActions__Alternatives_1 )? { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:6631:2: ( rule__BehaviorActions__Alternatives_1 )? - int alt68=2; - int LA68_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6807:2: ( rule__BehaviorActions__Alternatives_1 )? + int alt71=2; + int LA71_0 = input.LA(1); - if ( (LA68_0==Ampersand||LA68_0==Semicolon) ) { - alt68=1; + if ( (LA71_0==Ampersand||LA71_0==Semicolon) ) { + alt71=1; } - switch (alt68) { + switch (alt71) { case 1 : - // InternalBehaviorAnnexParser.g:6631:3: rule__BehaviorActions__Alternatives_1 + // InternalBehaviorAnnexParser.g:6807:3: rule__BehaviorActions__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__Alternatives_1(); @@ -22880,14 +23511,14 @@ public final void rule__BehaviorActions__Group__1__Impl() throws RecognitionExce // $ANTLR start "rule__BehaviorActions__Group_1_0__0" - // InternalBehaviorAnnexParser.g:6640:1: rule__BehaviorActions__Group_1_0__0 : rule__BehaviorActions__Group_1_0__0__Impl rule__BehaviorActions__Group_1_0__1 ; + // InternalBehaviorAnnexParser.g:6816:1: rule__BehaviorActions__Group_1_0__0 : rule__BehaviorActions__Group_1_0__0__Impl rule__BehaviorActions__Group_1_0__1 ; public final void rule__BehaviorActions__Group_1_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6644:1: ( rule__BehaviorActions__Group_1_0__0__Impl rule__BehaviorActions__Group_1_0__1 ) - // InternalBehaviorAnnexParser.g:6645:2: rule__BehaviorActions__Group_1_0__0__Impl rule__BehaviorActions__Group_1_0__1 + // InternalBehaviorAnnexParser.g:6820:1: ( rule__BehaviorActions__Group_1_0__0__Impl rule__BehaviorActions__Group_1_0__1 ) + // InternalBehaviorAnnexParser.g:6821:2: rule__BehaviorActions__Group_1_0__0__Impl rule__BehaviorActions__Group_1_0__1 { pushFollow(FollowSets000.FOLLOW_17); rule__BehaviorActions__Group_1_0__0__Impl(); @@ -22918,23 +23549,23 @@ public final void rule__BehaviorActions__Group_1_0__0() throws RecognitionExcept // $ANTLR start "rule__BehaviorActions__Group_1_0__0__Impl" - // InternalBehaviorAnnexParser.g:6652:1: rule__BehaviorActions__Group_1_0__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:6828:1: rule__BehaviorActions__Group_1_0__0__Impl : ( () ) ; public final void rule__BehaviorActions__Group_1_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6656:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:6657:1: ( () ) + // InternalBehaviorAnnexParser.g:6832:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:6833:1: ( () ) { - // InternalBehaviorAnnexParser.g:6657:1: ( () ) - // InternalBehaviorAnnexParser.g:6658:2: () + // InternalBehaviorAnnexParser.g:6833:1: ( () ) + // InternalBehaviorAnnexParser.g:6834:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getBehaviorActionSequenceActionsAction_1_0_0()); } - // InternalBehaviorAnnexParser.g:6659:2: () - // InternalBehaviorAnnexParser.g:6659:3: + // InternalBehaviorAnnexParser.g:6835:2: () + // InternalBehaviorAnnexParser.g:6835:3: { } @@ -22959,14 +23590,14 @@ public final void rule__BehaviorActions__Group_1_0__0__Impl() throws Recognition // $ANTLR start "rule__BehaviorActions__Group_1_0__1" - // InternalBehaviorAnnexParser.g:6667:1: rule__BehaviorActions__Group_1_0__1 : rule__BehaviorActions__Group_1_0__1__Impl rule__BehaviorActions__Group_1_0__2 ; + // InternalBehaviorAnnexParser.g:6843:1: rule__BehaviorActions__Group_1_0__1 : rule__BehaviorActions__Group_1_0__1__Impl rule__BehaviorActions__Group_1_0__2 ; public final void rule__BehaviorActions__Group_1_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6671:1: ( rule__BehaviorActions__Group_1_0__1__Impl rule__BehaviorActions__Group_1_0__2 ) - // InternalBehaviorAnnexParser.g:6672:2: rule__BehaviorActions__Group_1_0__1__Impl rule__BehaviorActions__Group_1_0__2 + // InternalBehaviorAnnexParser.g:6847:1: ( rule__BehaviorActions__Group_1_0__1__Impl rule__BehaviorActions__Group_1_0__2 ) + // InternalBehaviorAnnexParser.g:6848:2: rule__BehaviorActions__Group_1_0__1__Impl rule__BehaviorActions__Group_1_0__2 { pushFollow(FollowSets000.FOLLOW_38); rule__BehaviorActions__Group_1_0__1__Impl(); @@ -22997,17 +23628,17 @@ public final void rule__BehaviorActions__Group_1_0__1() throws RecognitionExcept // $ANTLR start "rule__BehaviorActions__Group_1_0__1__Impl" - // InternalBehaviorAnnexParser.g:6679:1: rule__BehaviorActions__Group_1_0__1__Impl : ( Semicolon ) ; + // InternalBehaviorAnnexParser.g:6855:1: rule__BehaviorActions__Group_1_0__1__Impl : ( Semicolon ) ; public final void rule__BehaviorActions__Group_1_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6683:1: ( ( Semicolon ) ) - // InternalBehaviorAnnexParser.g:6684:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:6859:1: ( ( Semicolon ) ) + // InternalBehaviorAnnexParser.g:6860:1: ( Semicolon ) { - // InternalBehaviorAnnexParser.g:6684:1: ( Semicolon ) - // InternalBehaviorAnnexParser.g:6685:2: Semicolon + // InternalBehaviorAnnexParser.g:6860:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:6861:2: Semicolon { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getSemicolonKeyword_1_0_1()); @@ -23038,14 +23669,14 @@ public final void rule__BehaviorActions__Group_1_0__1__Impl() throws Recognition // $ANTLR start "rule__BehaviorActions__Group_1_0__2" - // InternalBehaviorAnnexParser.g:6694:1: rule__BehaviorActions__Group_1_0__2 : rule__BehaviorActions__Group_1_0__2__Impl rule__BehaviorActions__Group_1_0__3 ; + // InternalBehaviorAnnexParser.g:6870:1: rule__BehaviorActions__Group_1_0__2 : rule__BehaviorActions__Group_1_0__2__Impl rule__BehaviorActions__Group_1_0__3 ; public final void rule__BehaviorActions__Group_1_0__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6698:1: ( rule__BehaviorActions__Group_1_0__2__Impl rule__BehaviorActions__Group_1_0__3 ) - // InternalBehaviorAnnexParser.g:6699:2: rule__BehaviorActions__Group_1_0__2__Impl rule__BehaviorActions__Group_1_0__3 + // InternalBehaviorAnnexParser.g:6874:1: ( rule__BehaviorActions__Group_1_0__2__Impl rule__BehaviorActions__Group_1_0__3 ) + // InternalBehaviorAnnexParser.g:6875:2: rule__BehaviorActions__Group_1_0__2__Impl rule__BehaviorActions__Group_1_0__3 { pushFollow(FollowSets000.FOLLOW_17); rule__BehaviorActions__Group_1_0__2__Impl(); @@ -23076,23 +23707,23 @@ public final void rule__BehaviorActions__Group_1_0__2() throws RecognitionExcept // $ANTLR start "rule__BehaviorActions__Group_1_0__2__Impl" - // InternalBehaviorAnnexParser.g:6706:1: rule__BehaviorActions__Group_1_0__2__Impl : ( ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) ) ; + // InternalBehaviorAnnexParser.g:6882:1: rule__BehaviorActions__Group_1_0__2__Impl : ( ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) ) ; public final void rule__BehaviorActions__Group_1_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6710:1: ( ( ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) ) ) - // InternalBehaviorAnnexParser.g:6711:1: ( ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) ) + // InternalBehaviorAnnexParser.g:6886:1: ( ( ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) ) ) + // InternalBehaviorAnnexParser.g:6887:1: ( ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) ) { - // InternalBehaviorAnnexParser.g:6711:1: ( ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) ) - // InternalBehaviorAnnexParser.g:6712:2: ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) + // InternalBehaviorAnnexParser.g:6887:1: ( ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) ) + // InternalBehaviorAnnexParser.g:6888:2: ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsAssignment_1_0_2()); } - // InternalBehaviorAnnexParser.g:6713:2: ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) - // InternalBehaviorAnnexParser.g:6713:3: rule__BehaviorActions__ActionsAssignment_1_0_2 + // InternalBehaviorAnnexParser.g:6889:2: ( rule__BehaviorActions__ActionsAssignment_1_0_2 ) + // InternalBehaviorAnnexParser.g:6889:3: rule__BehaviorActions__ActionsAssignment_1_0_2 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__ActionsAssignment_1_0_2(); @@ -23127,14 +23758,14 @@ public final void rule__BehaviorActions__Group_1_0__2__Impl() throws Recognition // $ANTLR start "rule__BehaviorActions__Group_1_0__3" - // InternalBehaviorAnnexParser.g:6721:1: rule__BehaviorActions__Group_1_0__3 : rule__BehaviorActions__Group_1_0__3__Impl ; + // InternalBehaviorAnnexParser.g:6897:1: rule__BehaviorActions__Group_1_0__3 : rule__BehaviorActions__Group_1_0__3__Impl ; public final void rule__BehaviorActions__Group_1_0__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6725:1: ( rule__BehaviorActions__Group_1_0__3__Impl ) - // InternalBehaviorAnnexParser.g:6726:2: rule__BehaviorActions__Group_1_0__3__Impl + // InternalBehaviorAnnexParser.g:6901:1: ( rule__BehaviorActions__Group_1_0__3__Impl ) + // InternalBehaviorAnnexParser.g:6902:2: rule__BehaviorActions__Group_1_0__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__Group_1_0__3__Impl(); @@ -23160,35 +23791,35 @@ public final void rule__BehaviorActions__Group_1_0__3() throws RecognitionExcept // $ANTLR start "rule__BehaviorActions__Group_1_0__3__Impl" - // InternalBehaviorAnnexParser.g:6732:1: rule__BehaviorActions__Group_1_0__3__Impl : ( ( rule__BehaviorActions__Group_1_0_3__0 )* ) ; + // InternalBehaviorAnnexParser.g:6908:1: rule__BehaviorActions__Group_1_0__3__Impl : ( ( rule__BehaviorActions__Group_1_0_3__0 )* ) ; public final void rule__BehaviorActions__Group_1_0__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6736:1: ( ( ( rule__BehaviorActions__Group_1_0_3__0 )* ) ) - // InternalBehaviorAnnexParser.g:6737:1: ( ( rule__BehaviorActions__Group_1_0_3__0 )* ) + // InternalBehaviorAnnexParser.g:6912:1: ( ( ( rule__BehaviorActions__Group_1_0_3__0 )* ) ) + // InternalBehaviorAnnexParser.g:6913:1: ( ( rule__BehaviorActions__Group_1_0_3__0 )* ) { - // InternalBehaviorAnnexParser.g:6737:1: ( ( rule__BehaviorActions__Group_1_0_3__0 )* ) - // InternalBehaviorAnnexParser.g:6738:2: ( rule__BehaviorActions__Group_1_0_3__0 )* + // InternalBehaviorAnnexParser.g:6913:1: ( ( rule__BehaviorActions__Group_1_0_3__0 )* ) + // InternalBehaviorAnnexParser.g:6914:2: ( rule__BehaviorActions__Group_1_0_3__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getGroup_1_0_3()); } - // InternalBehaviorAnnexParser.g:6739:2: ( rule__BehaviorActions__Group_1_0_3__0 )* - loop69: + // InternalBehaviorAnnexParser.g:6915:2: ( rule__BehaviorActions__Group_1_0_3__0 )* + loop72: do { - int alt69=2; - int LA69_0 = input.LA(1); + int alt72=2; + int LA72_0 = input.LA(1); - if ( (LA69_0==Semicolon) ) { - alt69=1; + if ( (LA72_0==Semicolon) ) { + alt72=1; } - switch (alt69) { + switch (alt72) { case 1 : - // InternalBehaviorAnnexParser.g:6739:3: rule__BehaviorActions__Group_1_0_3__0 + // InternalBehaviorAnnexParser.g:6915:3: rule__BehaviorActions__Group_1_0_3__0 { pushFollow(FollowSets000.FOLLOW_41); rule__BehaviorActions__Group_1_0_3__0(); @@ -23200,7 +23831,7 @@ public final void rule__BehaviorActions__Group_1_0__3__Impl() throws Recognition break; default : - break loop69; + break loop72; } } while (true); @@ -23229,14 +23860,14 @@ public final void rule__BehaviorActions__Group_1_0__3__Impl() throws Recognition // $ANTLR start "rule__BehaviorActions__Group_1_0_3__0" - // InternalBehaviorAnnexParser.g:6748:1: rule__BehaviorActions__Group_1_0_3__0 : rule__BehaviorActions__Group_1_0_3__0__Impl rule__BehaviorActions__Group_1_0_3__1 ; + // InternalBehaviorAnnexParser.g:6924:1: rule__BehaviorActions__Group_1_0_3__0 : rule__BehaviorActions__Group_1_0_3__0__Impl rule__BehaviorActions__Group_1_0_3__1 ; public final void rule__BehaviorActions__Group_1_0_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6752:1: ( rule__BehaviorActions__Group_1_0_3__0__Impl rule__BehaviorActions__Group_1_0_3__1 ) - // InternalBehaviorAnnexParser.g:6753:2: rule__BehaviorActions__Group_1_0_3__0__Impl rule__BehaviorActions__Group_1_0_3__1 + // InternalBehaviorAnnexParser.g:6928:1: ( rule__BehaviorActions__Group_1_0_3__0__Impl rule__BehaviorActions__Group_1_0_3__1 ) + // InternalBehaviorAnnexParser.g:6929:2: rule__BehaviorActions__Group_1_0_3__0__Impl rule__BehaviorActions__Group_1_0_3__1 { pushFollow(FollowSets000.FOLLOW_38); rule__BehaviorActions__Group_1_0_3__0__Impl(); @@ -23267,17 +23898,17 @@ public final void rule__BehaviorActions__Group_1_0_3__0() throws RecognitionExce // $ANTLR start "rule__BehaviorActions__Group_1_0_3__0__Impl" - // InternalBehaviorAnnexParser.g:6760:1: rule__BehaviorActions__Group_1_0_3__0__Impl : ( Semicolon ) ; + // InternalBehaviorAnnexParser.g:6936:1: rule__BehaviorActions__Group_1_0_3__0__Impl : ( Semicolon ) ; public final void rule__BehaviorActions__Group_1_0_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6764:1: ( ( Semicolon ) ) - // InternalBehaviorAnnexParser.g:6765:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:6940:1: ( ( Semicolon ) ) + // InternalBehaviorAnnexParser.g:6941:1: ( Semicolon ) { - // InternalBehaviorAnnexParser.g:6765:1: ( Semicolon ) - // InternalBehaviorAnnexParser.g:6766:2: Semicolon + // InternalBehaviorAnnexParser.g:6941:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:6942:2: Semicolon { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getSemicolonKeyword_1_0_3_0()); @@ -23308,14 +23939,14 @@ public final void rule__BehaviorActions__Group_1_0_3__0__Impl() throws Recogniti // $ANTLR start "rule__BehaviorActions__Group_1_0_3__1" - // InternalBehaviorAnnexParser.g:6775:1: rule__BehaviorActions__Group_1_0_3__1 : rule__BehaviorActions__Group_1_0_3__1__Impl ; + // InternalBehaviorAnnexParser.g:6951:1: rule__BehaviorActions__Group_1_0_3__1 : rule__BehaviorActions__Group_1_0_3__1__Impl ; public final void rule__BehaviorActions__Group_1_0_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6779:1: ( rule__BehaviorActions__Group_1_0_3__1__Impl ) - // InternalBehaviorAnnexParser.g:6780:2: rule__BehaviorActions__Group_1_0_3__1__Impl + // InternalBehaviorAnnexParser.g:6955:1: ( rule__BehaviorActions__Group_1_0_3__1__Impl ) + // InternalBehaviorAnnexParser.g:6956:2: rule__BehaviorActions__Group_1_0_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__Group_1_0_3__1__Impl(); @@ -23341,23 +23972,23 @@ public final void rule__BehaviorActions__Group_1_0_3__1() throws RecognitionExce // $ANTLR start "rule__BehaviorActions__Group_1_0_3__1__Impl" - // InternalBehaviorAnnexParser.g:6786:1: rule__BehaviorActions__Group_1_0_3__1__Impl : ( ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:6962:1: rule__BehaviorActions__Group_1_0_3__1__Impl : ( ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) ) ; public final void rule__BehaviorActions__Group_1_0_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6790:1: ( ( ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:6791:1: ( ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) ) + // InternalBehaviorAnnexParser.g:6966:1: ( ( ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:6967:1: ( ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) ) { - // InternalBehaviorAnnexParser.g:6791:1: ( ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) ) - // InternalBehaviorAnnexParser.g:6792:2: ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) + // InternalBehaviorAnnexParser.g:6967:1: ( ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) ) + // InternalBehaviorAnnexParser.g:6968:2: ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsAssignment_1_0_3_1()); } - // InternalBehaviorAnnexParser.g:6793:2: ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) - // InternalBehaviorAnnexParser.g:6793:3: rule__BehaviorActions__ActionsAssignment_1_0_3_1 + // InternalBehaviorAnnexParser.g:6969:2: ( rule__BehaviorActions__ActionsAssignment_1_0_3_1 ) + // InternalBehaviorAnnexParser.g:6969:3: rule__BehaviorActions__ActionsAssignment_1_0_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__ActionsAssignment_1_0_3_1(); @@ -23392,14 +24023,14 @@ public final void rule__BehaviorActions__Group_1_0_3__1__Impl() throws Recogniti // $ANTLR start "rule__BehaviorActions__Group_1_1__0" - // InternalBehaviorAnnexParser.g:6802:1: rule__BehaviorActions__Group_1_1__0 : rule__BehaviorActions__Group_1_1__0__Impl rule__BehaviorActions__Group_1_1__1 ; + // InternalBehaviorAnnexParser.g:6978:1: rule__BehaviorActions__Group_1_1__0 : rule__BehaviorActions__Group_1_1__0__Impl rule__BehaviorActions__Group_1_1__1 ; public final void rule__BehaviorActions__Group_1_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6806:1: ( rule__BehaviorActions__Group_1_1__0__Impl rule__BehaviorActions__Group_1_1__1 ) - // InternalBehaviorAnnexParser.g:6807:2: rule__BehaviorActions__Group_1_1__0__Impl rule__BehaviorActions__Group_1_1__1 + // InternalBehaviorAnnexParser.g:6982:1: ( rule__BehaviorActions__Group_1_1__0__Impl rule__BehaviorActions__Group_1_1__1 ) + // InternalBehaviorAnnexParser.g:6983:2: rule__BehaviorActions__Group_1_1__0__Impl rule__BehaviorActions__Group_1_1__1 { pushFollow(FollowSets000.FOLLOW_40); rule__BehaviorActions__Group_1_1__0__Impl(); @@ -23430,23 +24061,23 @@ public final void rule__BehaviorActions__Group_1_1__0() throws RecognitionExcept // $ANTLR start "rule__BehaviorActions__Group_1_1__0__Impl" - // InternalBehaviorAnnexParser.g:6814:1: rule__BehaviorActions__Group_1_1__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:6990:1: rule__BehaviorActions__Group_1_1__0__Impl : ( () ) ; public final void rule__BehaviorActions__Group_1_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6818:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:6819:1: ( () ) + // InternalBehaviorAnnexParser.g:6994:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:6995:1: ( () ) { - // InternalBehaviorAnnexParser.g:6819:1: ( () ) - // InternalBehaviorAnnexParser.g:6820:2: () + // InternalBehaviorAnnexParser.g:6995:1: ( () ) + // InternalBehaviorAnnexParser.g:6996:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getBehaviorActionSetActionsAction_1_1_0()); } - // InternalBehaviorAnnexParser.g:6821:2: () - // InternalBehaviorAnnexParser.g:6821:3: + // InternalBehaviorAnnexParser.g:6997:2: () + // InternalBehaviorAnnexParser.g:6997:3: { } @@ -23471,14 +24102,14 @@ public final void rule__BehaviorActions__Group_1_1__0__Impl() throws Recognition // $ANTLR start "rule__BehaviorActions__Group_1_1__1" - // InternalBehaviorAnnexParser.g:6829:1: rule__BehaviorActions__Group_1_1__1 : rule__BehaviorActions__Group_1_1__1__Impl rule__BehaviorActions__Group_1_1__2 ; + // InternalBehaviorAnnexParser.g:7005:1: rule__BehaviorActions__Group_1_1__1 : rule__BehaviorActions__Group_1_1__1__Impl rule__BehaviorActions__Group_1_1__2 ; public final void rule__BehaviorActions__Group_1_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6833:1: ( rule__BehaviorActions__Group_1_1__1__Impl rule__BehaviorActions__Group_1_1__2 ) - // InternalBehaviorAnnexParser.g:6834:2: rule__BehaviorActions__Group_1_1__1__Impl rule__BehaviorActions__Group_1_1__2 + // InternalBehaviorAnnexParser.g:7009:1: ( rule__BehaviorActions__Group_1_1__1__Impl rule__BehaviorActions__Group_1_1__2 ) + // InternalBehaviorAnnexParser.g:7010:2: rule__BehaviorActions__Group_1_1__1__Impl rule__BehaviorActions__Group_1_1__2 { pushFollow(FollowSets000.FOLLOW_38); rule__BehaviorActions__Group_1_1__1__Impl(); @@ -23509,17 +24140,17 @@ public final void rule__BehaviorActions__Group_1_1__1() throws RecognitionExcept // $ANTLR start "rule__BehaviorActions__Group_1_1__1__Impl" - // InternalBehaviorAnnexParser.g:6841:1: rule__BehaviorActions__Group_1_1__1__Impl : ( Ampersand ) ; + // InternalBehaviorAnnexParser.g:7017:1: rule__BehaviorActions__Group_1_1__1__Impl : ( Ampersand ) ; public final void rule__BehaviorActions__Group_1_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6845:1: ( ( Ampersand ) ) - // InternalBehaviorAnnexParser.g:6846:1: ( Ampersand ) + // InternalBehaviorAnnexParser.g:7021:1: ( ( Ampersand ) ) + // InternalBehaviorAnnexParser.g:7022:1: ( Ampersand ) { - // InternalBehaviorAnnexParser.g:6846:1: ( Ampersand ) - // InternalBehaviorAnnexParser.g:6847:2: Ampersand + // InternalBehaviorAnnexParser.g:7022:1: ( Ampersand ) + // InternalBehaviorAnnexParser.g:7023:2: Ampersand { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getAmpersandKeyword_1_1_1()); @@ -23550,14 +24181,14 @@ public final void rule__BehaviorActions__Group_1_1__1__Impl() throws Recognition // $ANTLR start "rule__BehaviorActions__Group_1_1__2" - // InternalBehaviorAnnexParser.g:6856:1: rule__BehaviorActions__Group_1_1__2 : rule__BehaviorActions__Group_1_1__2__Impl rule__BehaviorActions__Group_1_1__3 ; + // InternalBehaviorAnnexParser.g:7032:1: rule__BehaviorActions__Group_1_1__2 : rule__BehaviorActions__Group_1_1__2__Impl rule__BehaviorActions__Group_1_1__3 ; public final void rule__BehaviorActions__Group_1_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6860:1: ( rule__BehaviorActions__Group_1_1__2__Impl rule__BehaviorActions__Group_1_1__3 ) - // InternalBehaviorAnnexParser.g:6861:2: rule__BehaviorActions__Group_1_1__2__Impl rule__BehaviorActions__Group_1_1__3 + // InternalBehaviorAnnexParser.g:7036:1: ( rule__BehaviorActions__Group_1_1__2__Impl rule__BehaviorActions__Group_1_1__3 ) + // InternalBehaviorAnnexParser.g:7037:2: rule__BehaviorActions__Group_1_1__2__Impl rule__BehaviorActions__Group_1_1__3 { pushFollow(FollowSets000.FOLLOW_42); rule__BehaviorActions__Group_1_1__2__Impl(); @@ -23588,23 +24219,23 @@ public final void rule__BehaviorActions__Group_1_1__2() throws RecognitionExcept // $ANTLR start "rule__BehaviorActions__Group_1_1__2__Impl" - // InternalBehaviorAnnexParser.g:6868:1: rule__BehaviorActions__Group_1_1__2__Impl : ( ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) ) ; + // InternalBehaviorAnnexParser.g:7044:1: rule__BehaviorActions__Group_1_1__2__Impl : ( ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) ) ; public final void rule__BehaviorActions__Group_1_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6872:1: ( ( ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:6873:1: ( ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) ) + // InternalBehaviorAnnexParser.g:7048:1: ( ( ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:7049:1: ( ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) ) { - // InternalBehaviorAnnexParser.g:6873:1: ( ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) ) - // InternalBehaviorAnnexParser.g:6874:2: ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) + // InternalBehaviorAnnexParser.g:7049:1: ( ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) ) + // InternalBehaviorAnnexParser.g:7050:2: ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsAssignment_1_1_2()); } - // InternalBehaviorAnnexParser.g:6875:2: ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) - // InternalBehaviorAnnexParser.g:6875:3: rule__BehaviorActions__ActionsAssignment_1_1_2 + // InternalBehaviorAnnexParser.g:7051:2: ( rule__BehaviorActions__ActionsAssignment_1_1_2 ) + // InternalBehaviorAnnexParser.g:7051:3: rule__BehaviorActions__ActionsAssignment_1_1_2 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__ActionsAssignment_1_1_2(); @@ -23639,14 +24270,14 @@ public final void rule__BehaviorActions__Group_1_1__2__Impl() throws Recognition // $ANTLR start "rule__BehaviorActions__Group_1_1__3" - // InternalBehaviorAnnexParser.g:6883:1: rule__BehaviorActions__Group_1_1__3 : rule__BehaviorActions__Group_1_1__3__Impl ; + // InternalBehaviorAnnexParser.g:7059:1: rule__BehaviorActions__Group_1_1__3 : rule__BehaviorActions__Group_1_1__3__Impl ; public final void rule__BehaviorActions__Group_1_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6887:1: ( rule__BehaviorActions__Group_1_1__3__Impl ) - // InternalBehaviorAnnexParser.g:6888:2: rule__BehaviorActions__Group_1_1__3__Impl + // InternalBehaviorAnnexParser.g:7063:1: ( rule__BehaviorActions__Group_1_1__3__Impl ) + // InternalBehaviorAnnexParser.g:7064:2: rule__BehaviorActions__Group_1_1__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__Group_1_1__3__Impl(); @@ -23672,35 +24303,35 @@ public final void rule__BehaviorActions__Group_1_1__3() throws RecognitionExcept // $ANTLR start "rule__BehaviorActions__Group_1_1__3__Impl" - // InternalBehaviorAnnexParser.g:6894:1: rule__BehaviorActions__Group_1_1__3__Impl : ( ( rule__BehaviorActions__Group_1_1_3__0 )* ) ; + // InternalBehaviorAnnexParser.g:7070:1: rule__BehaviorActions__Group_1_1__3__Impl : ( ( rule__BehaviorActions__Group_1_1_3__0 )* ) ; public final void rule__BehaviorActions__Group_1_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6898:1: ( ( ( rule__BehaviorActions__Group_1_1_3__0 )* ) ) - // InternalBehaviorAnnexParser.g:6899:1: ( ( rule__BehaviorActions__Group_1_1_3__0 )* ) + // InternalBehaviorAnnexParser.g:7074:1: ( ( ( rule__BehaviorActions__Group_1_1_3__0 )* ) ) + // InternalBehaviorAnnexParser.g:7075:1: ( ( rule__BehaviorActions__Group_1_1_3__0 )* ) { - // InternalBehaviorAnnexParser.g:6899:1: ( ( rule__BehaviorActions__Group_1_1_3__0 )* ) - // InternalBehaviorAnnexParser.g:6900:2: ( rule__BehaviorActions__Group_1_1_3__0 )* + // InternalBehaviorAnnexParser.g:7075:1: ( ( rule__BehaviorActions__Group_1_1_3__0 )* ) + // InternalBehaviorAnnexParser.g:7076:2: ( rule__BehaviorActions__Group_1_1_3__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getGroup_1_1_3()); } - // InternalBehaviorAnnexParser.g:6901:2: ( rule__BehaviorActions__Group_1_1_3__0 )* - loop70: + // InternalBehaviorAnnexParser.g:7077:2: ( rule__BehaviorActions__Group_1_1_3__0 )* + loop73: do { - int alt70=2; - int LA70_0 = input.LA(1); + int alt73=2; + int LA73_0 = input.LA(1); - if ( (LA70_0==Ampersand) ) { - alt70=1; + if ( (LA73_0==Ampersand) ) { + alt73=1; } - switch (alt70) { + switch (alt73) { case 1 : - // InternalBehaviorAnnexParser.g:6901:3: rule__BehaviorActions__Group_1_1_3__0 + // InternalBehaviorAnnexParser.g:7077:3: rule__BehaviorActions__Group_1_1_3__0 { pushFollow(FollowSets000.FOLLOW_43); rule__BehaviorActions__Group_1_1_3__0(); @@ -23712,7 +24343,7 @@ public final void rule__BehaviorActions__Group_1_1__3__Impl() throws Recognition break; default : - break loop70; + break loop73; } } while (true); @@ -23741,14 +24372,14 @@ public final void rule__BehaviorActions__Group_1_1__3__Impl() throws Recognition // $ANTLR start "rule__BehaviorActions__Group_1_1_3__0" - // InternalBehaviorAnnexParser.g:6910:1: rule__BehaviorActions__Group_1_1_3__0 : rule__BehaviorActions__Group_1_1_3__0__Impl rule__BehaviorActions__Group_1_1_3__1 ; + // InternalBehaviorAnnexParser.g:7086:1: rule__BehaviorActions__Group_1_1_3__0 : rule__BehaviorActions__Group_1_1_3__0__Impl rule__BehaviorActions__Group_1_1_3__1 ; public final void rule__BehaviorActions__Group_1_1_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6914:1: ( rule__BehaviorActions__Group_1_1_3__0__Impl rule__BehaviorActions__Group_1_1_3__1 ) - // InternalBehaviorAnnexParser.g:6915:2: rule__BehaviorActions__Group_1_1_3__0__Impl rule__BehaviorActions__Group_1_1_3__1 + // InternalBehaviorAnnexParser.g:7090:1: ( rule__BehaviorActions__Group_1_1_3__0__Impl rule__BehaviorActions__Group_1_1_3__1 ) + // InternalBehaviorAnnexParser.g:7091:2: rule__BehaviorActions__Group_1_1_3__0__Impl rule__BehaviorActions__Group_1_1_3__1 { pushFollow(FollowSets000.FOLLOW_38); rule__BehaviorActions__Group_1_1_3__0__Impl(); @@ -23779,17 +24410,17 @@ public final void rule__BehaviorActions__Group_1_1_3__0() throws RecognitionExce // $ANTLR start "rule__BehaviorActions__Group_1_1_3__0__Impl" - // InternalBehaviorAnnexParser.g:6922:1: rule__BehaviorActions__Group_1_1_3__0__Impl : ( Ampersand ) ; + // InternalBehaviorAnnexParser.g:7098:1: rule__BehaviorActions__Group_1_1_3__0__Impl : ( Ampersand ) ; public final void rule__BehaviorActions__Group_1_1_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6926:1: ( ( Ampersand ) ) - // InternalBehaviorAnnexParser.g:6927:1: ( Ampersand ) + // InternalBehaviorAnnexParser.g:7102:1: ( ( Ampersand ) ) + // InternalBehaviorAnnexParser.g:7103:1: ( Ampersand ) { - // InternalBehaviorAnnexParser.g:6927:1: ( Ampersand ) - // InternalBehaviorAnnexParser.g:6928:2: Ampersand + // InternalBehaviorAnnexParser.g:7103:1: ( Ampersand ) + // InternalBehaviorAnnexParser.g:7104:2: Ampersand { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getAmpersandKeyword_1_1_3_0()); @@ -23820,14 +24451,14 @@ public final void rule__BehaviorActions__Group_1_1_3__0__Impl() throws Recogniti // $ANTLR start "rule__BehaviorActions__Group_1_1_3__1" - // InternalBehaviorAnnexParser.g:6937:1: rule__BehaviorActions__Group_1_1_3__1 : rule__BehaviorActions__Group_1_1_3__1__Impl ; + // InternalBehaviorAnnexParser.g:7113:1: rule__BehaviorActions__Group_1_1_3__1 : rule__BehaviorActions__Group_1_1_3__1__Impl ; public final void rule__BehaviorActions__Group_1_1_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6941:1: ( rule__BehaviorActions__Group_1_1_3__1__Impl ) - // InternalBehaviorAnnexParser.g:6942:2: rule__BehaviorActions__Group_1_1_3__1__Impl + // InternalBehaviorAnnexParser.g:7117:1: ( rule__BehaviorActions__Group_1_1_3__1__Impl ) + // InternalBehaviorAnnexParser.g:7118:2: rule__BehaviorActions__Group_1_1_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__Group_1_1_3__1__Impl(); @@ -23853,23 +24484,23 @@ public final void rule__BehaviorActions__Group_1_1_3__1() throws RecognitionExce // $ANTLR start "rule__BehaviorActions__Group_1_1_3__1__Impl" - // InternalBehaviorAnnexParser.g:6948:1: rule__BehaviorActions__Group_1_1_3__1__Impl : ( ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:7124:1: rule__BehaviorActions__Group_1_1_3__1__Impl : ( ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) ) ; public final void rule__BehaviorActions__Group_1_1_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6952:1: ( ( ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:6953:1: ( ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) ) + // InternalBehaviorAnnexParser.g:7128:1: ( ( ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:7129:1: ( ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) ) { - // InternalBehaviorAnnexParser.g:6953:1: ( ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) ) - // InternalBehaviorAnnexParser.g:6954:2: ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) + // InternalBehaviorAnnexParser.g:7129:1: ( ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) ) + // InternalBehaviorAnnexParser.g:7130:2: ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsAssignment_1_1_3_1()); } - // InternalBehaviorAnnexParser.g:6955:2: ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) - // InternalBehaviorAnnexParser.g:6955:3: rule__BehaviorActions__ActionsAssignment_1_1_3_1 + // InternalBehaviorAnnexParser.g:7131:2: ( rule__BehaviorActions__ActionsAssignment_1_1_3_1 ) + // InternalBehaviorAnnexParser.g:7131:3: rule__BehaviorActions__ActionsAssignment_1_1_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorActions__ActionsAssignment_1_1_3_1(); @@ -23904,14 +24535,14 @@ public final void rule__BehaviorActions__Group_1_1_3__1__Impl() throws Recogniti // $ANTLR start "rule__AssignmentAction__Group__0" - // InternalBehaviorAnnexParser.g:6964:1: rule__AssignmentAction__Group__0 : rule__AssignmentAction__Group__0__Impl rule__AssignmentAction__Group__1 ; + // InternalBehaviorAnnexParser.g:7140:1: rule__AssignmentAction__Group__0 : rule__AssignmentAction__Group__0__Impl rule__AssignmentAction__Group__1 ; public final void rule__AssignmentAction__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6968:1: ( rule__AssignmentAction__Group__0__Impl rule__AssignmentAction__Group__1 ) - // InternalBehaviorAnnexParser.g:6969:2: rule__AssignmentAction__Group__0__Impl rule__AssignmentAction__Group__1 + // InternalBehaviorAnnexParser.g:7144:1: ( rule__AssignmentAction__Group__0__Impl rule__AssignmentAction__Group__1 ) + // InternalBehaviorAnnexParser.g:7145:2: rule__AssignmentAction__Group__0__Impl rule__AssignmentAction__Group__1 { pushFollow(FollowSets000.FOLLOW_44); rule__AssignmentAction__Group__0__Impl(); @@ -23942,23 +24573,23 @@ public final void rule__AssignmentAction__Group__0() throws RecognitionException // $ANTLR start "rule__AssignmentAction__Group__0__Impl" - // InternalBehaviorAnnexParser.g:6976:1: rule__AssignmentAction__Group__0__Impl : ( ( rule__AssignmentAction__TargetAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:7152:1: rule__AssignmentAction__Group__0__Impl : ( ( rule__AssignmentAction__TargetAssignment_0 ) ) ; public final void rule__AssignmentAction__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6980:1: ( ( ( rule__AssignmentAction__TargetAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:6981:1: ( ( rule__AssignmentAction__TargetAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:7156:1: ( ( ( rule__AssignmentAction__TargetAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:7157:1: ( ( rule__AssignmentAction__TargetAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:6981:1: ( ( rule__AssignmentAction__TargetAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:6982:2: ( rule__AssignmentAction__TargetAssignment_0 ) + // InternalBehaviorAnnexParser.g:7157:1: ( ( rule__AssignmentAction__TargetAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:7158:2: ( rule__AssignmentAction__TargetAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getTargetAssignment_0()); } - // InternalBehaviorAnnexParser.g:6983:2: ( rule__AssignmentAction__TargetAssignment_0 ) - // InternalBehaviorAnnexParser.g:6983:3: rule__AssignmentAction__TargetAssignment_0 + // InternalBehaviorAnnexParser.g:7159:2: ( rule__AssignmentAction__TargetAssignment_0 ) + // InternalBehaviorAnnexParser.g:7159:3: rule__AssignmentAction__TargetAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__AssignmentAction__TargetAssignment_0(); @@ -23993,14 +24624,14 @@ public final void rule__AssignmentAction__Group__0__Impl() throws RecognitionExc // $ANTLR start "rule__AssignmentAction__Group__1" - // InternalBehaviorAnnexParser.g:6991:1: rule__AssignmentAction__Group__1 : rule__AssignmentAction__Group__1__Impl rule__AssignmentAction__Group__2 ; + // InternalBehaviorAnnexParser.g:7167:1: rule__AssignmentAction__Group__1 : rule__AssignmentAction__Group__1__Impl rule__AssignmentAction__Group__2 ; public final void rule__AssignmentAction__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:6995:1: ( rule__AssignmentAction__Group__1__Impl rule__AssignmentAction__Group__2 ) - // InternalBehaviorAnnexParser.g:6996:2: rule__AssignmentAction__Group__1__Impl rule__AssignmentAction__Group__2 + // InternalBehaviorAnnexParser.g:7171:1: ( rule__AssignmentAction__Group__1__Impl rule__AssignmentAction__Group__2 ) + // InternalBehaviorAnnexParser.g:7172:2: rule__AssignmentAction__Group__1__Impl rule__AssignmentAction__Group__2 { pushFollow(FollowSets000.FOLLOW_45); rule__AssignmentAction__Group__1__Impl(); @@ -24031,17 +24662,17 @@ public final void rule__AssignmentAction__Group__1() throws RecognitionException // $ANTLR start "rule__AssignmentAction__Group__1__Impl" - // InternalBehaviorAnnexParser.g:7003:1: rule__AssignmentAction__Group__1__Impl : ( ColonEqualsSign ) ; + // InternalBehaviorAnnexParser.g:7179:1: rule__AssignmentAction__Group__1__Impl : ( ColonEqualsSign ) ; public final void rule__AssignmentAction__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7007:1: ( ( ColonEqualsSign ) ) - // InternalBehaviorAnnexParser.g:7008:1: ( ColonEqualsSign ) + // InternalBehaviorAnnexParser.g:7183:1: ( ( ColonEqualsSign ) ) + // InternalBehaviorAnnexParser.g:7184:1: ( ColonEqualsSign ) { - // InternalBehaviorAnnexParser.g:7008:1: ( ColonEqualsSign ) - // InternalBehaviorAnnexParser.g:7009:2: ColonEqualsSign + // InternalBehaviorAnnexParser.g:7184:1: ( ColonEqualsSign ) + // InternalBehaviorAnnexParser.g:7185:2: ColonEqualsSign { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getColonEqualsSignKeyword_1()); @@ -24072,14 +24703,14 @@ public final void rule__AssignmentAction__Group__1__Impl() throws RecognitionExc // $ANTLR start "rule__AssignmentAction__Group__2" - // InternalBehaviorAnnexParser.g:7018:1: rule__AssignmentAction__Group__2 : rule__AssignmentAction__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:7194:1: rule__AssignmentAction__Group__2 : rule__AssignmentAction__Group__2__Impl ; public final void rule__AssignmentAction__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7022:1: ( rule__AssignmentAction__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:7023:2: rule__AssignmentAction__Group__2__Impl + // InternalBehaviorAnnexParser.g:7198:1: ( rule__AssignmentAction__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:7199:2: rule__AssignmentAction__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__AssignmentAction__Group__2__Impl(); @@ -24105,23 +24736,23 @@ public final void rule__AssignmentAction__Group__2() throws RecognitionException // $ANTLR start "rule__AssignmentAction__Group__2__Impl" - // InternalBehaviorAnnexParser.g:7029:1: rule__AssignmentAction__Group__2__Impl : ( ( rule__AssignmentAction__Alternatives_2 ) ) ; + // InternalBehaviorAnnexParser.g:7205:1: rule__AssignmentAction__Group__2__Impl : ( ( rule__AssignmentAction__Alternatives_2 ) ) ; public final void rule__AssignmentAction__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7033:1: ( ( ( rule__AssignmentAction__Alternatives_2 ) ) ) - // InternalBehaviorAnnexParser.g:7034:1: ( ( rule__AssignmentAction__Alternatives_2 ) ) + // InternalBehaviorAnnexParser.g:7209:1: ( ( ( rule__AssignmentAction__Alternatives_2 ) ) ) + // InternalBehaviorAnnexParser.g:7210:1: ( ( rule__AssignmentAction__Alternatives_2 ) ) { - // InternalBehaviorAnnexParser.g:7034:1: ( ( rule__AssignmentAction__Alternatives_2 ) ) - // InternalBehaviorAnnexParser.g:7035:2: ( rule__AssignmentAction__Alternatives_2 ) + // InternalBehaviorAnnexParser.g:7210:1: ( ( rule__AssignmentAction__Alternatives_2 ) ) + // InternalBehaviorAnnexParser.g:7211:2: ( rule__AssignmentAction__Alternatives_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getAlternatives_2()); } - // InternalBehaviorAnnexParser.g:7036:2: ( rule__AssignmentAction__Alternatives_2 ) - // InternalBehaviorAnnexParser.g:7036:3: rule__AssignmentAction__Alternatives_2 + // InternalBehaviorAnnexParser.g:7212:2: ( rule__AssignmentAction__Alternatives_2 ) + // InternalBehaviorAnnexParser.g:7212:3: rule__AssignmentAction__Alternatives_2 { pushFollow(FollowSets000.FOLLOW_2); rule__AssignmentAction__Alternatives_2(); @@ -24156,14 +24787,14 @@ public final void rule__AssignmentAction__Group__2__Impl() throws RecognitionExc // $ANTLR start "rule__CommunicationAction__Group_0__0" - // InternalBehaviorAnnexParser.g:7045:1: rule__CommunicationAction__Group_0__0 : rule__CommunicationAction__Group_0__0__Impl rule__CommunicationAction__Group_0__1 ; + // InternalBehaviorAnnexParser.g:7221:1: rule__CommunicationAction__Group_0__0 : rule__CommunicationAction__Group_0__0__Impl rule__CommunicationAction__Group_0__1 ; public final void rule__CommunicationAction__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7049:1: ( rule__CommunicationAction__Group_0__0__Impl rule__CommunicationAction__Group_0__1 ) - // InternalBehaviorAnnexParser.g:7050:2: rule__CommunicationAction__Group_0__0__Impl rule__CommunicationAction__Group_0__1 + // InternalBehaviorAnnexParser.g:7225:1: ( rule__CommunicationAction__Group_0__0__Impl rule__CommunicationAction__Group_0__1 ) + // InternalBehaviorAnnexParser.g:7226:2: rule__CommunicationAction__Group_0__0__Impl rule__CommunicationAction__Group_0__1 { pushFollow(FollowSets000.FOLLOW_46); rule__CommunicationAction__Group_0__0__Impl(); @@ -24194,23 +24825,23 @@ public final void rule__CommunicationAction__Group_0__0() throws RecognitionExce // $ANTLR start "rule__CommunicationAction__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:7057:1: rule__CommunicationAction__Group_0__0__Impl : ( ( rule__CommunicationAction__ReferenceAssignment_0_0 ) ) ; + // InternalBehaviorAnnexParser.g:7233:1: rule__CommunicationAction__Group_0__0__Impl : ( ( rule__CommunicationAction__ReferenceAssignment_0_0 ) ) ; public final void rule__CommunicationAction__Group_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7061:1: ( ( ( rule__CommunicationAction__ReferenceAssignment_0_0 ) ) ) - // InternalBehaviorAnnexParser.g:7062:1: ( ( rule__CommunicationAction__ReferenceAssignment_0_0 ) ) + // InternalBehaviorAnnexParser.g:7237:1: ( ( ( rule__CommunicationAction__ReferenceAssignment_0_0 ) ) ) + // InternalBehaviorAnnexParser.g:7238:1: ( ( rule__CommunicationAction__ReferenceAssignment_0_0 ) ) { - // InternalBehaviorAnnexParser.g:7062:1: ( ( rule__CommunicationAction__ReferenceAssignment_0_0 ) ) - // InternalBehaviorAnnexParser.g:7063:2: ( rule__CommunicationAction__ReferenceAssignment_0_0 ) + // InternalBehaviorAnnexParser.g:7238:1: ( ( rule__CommunicationAction__ReferenceAssignment_0_0 ) ) + // InternalBehaviorAnnexParser.g:7239:2: ( rule__CommunicationAction__ReferenceAssignment_0_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getReferenceAssignment_0_0()); } - // InternalBehaviorAnnexParser.g:7064:2: ( rule__CommunicationAction__ReferenceAssignment_0_0 ) - // InternalBehaviorAnnexParser.g:7064:3: rule__CommunicationAction__ReferenceAssignment_0_0 + // InternalBehaviorAnnexParser.g:7240:2: ( rule__CommunicationAction__ReferenceAssignment_0_0 ) + // InternalBehaviorAnnexParser.g:7240:3: rule__CommunicationAction__ReferenceAssignment_0_0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__ReferenceAssignment_0_0(); @@ -24245,14 +24876,14 @@ public final void rule__CommunicationAction__Group_0__0__Impl() throws Recogniti // $ANTLR start "rule__CommunicationAction__Group_0__1" - // InternalBehaviorAnnexParser.g:7072:1: rule__CommunicationAction__Group_0__1 : rule__CommunicationAction__Group_0__1__Impl ; + // InternalBehaviorAnnexParser.g:7248:1: rule__CommunicationAction__Group_0__1 : rule__CommunicationAction__Group_0__1__Impl ; public final void rule__CommunicationAction__Group_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7076:1: ( rule__CommunicationAction__Group_0__1__Impl ) - // InternalBehaviorAnnexParser.g:7077:2: rule__CommunicationAction__Group_0__1__Impl + // InternalBehaviorAnnexParser.g:7252:1: ( rule__CommunicationAction__Group_0__1__Impl ) + // InternalBehaviorAnnexParser.g:7253:2: rule__CommunicationAction__Group_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0__1__Impl(); @@ -24278,23 +24909,23 @@ public final void rule__CommunicationAction__Group_0__1() throws RecognitionExce // $ANTLR start "rule__CommunicationAction__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:7083:1: rule__CommunicationAction__Group_0__1__Impl : ( ( rule__CommunicationAction__Alternatives_0_1 ) ) ; + // InternalBehaviorAnnexParser.g:7259:1: rule__CommunicationAction__Group_0__1__Impl : ( ( rule__CommunicationAction__Alternatives_0_1 ) ) ; public final void rule__CommunicationAction__Group_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7087:1: ( ( ( rule__CommunicationAction__Alternatives_0_1 ) ) ) - // InternalBehaviorAnnexParser.g:7088:1: ( ( rule__CommunicationAction__Alternatives_0_1 ) ) + // InternalBehaviorAnnexParser.g:7263:1: ( ( ( rule__CommunicationAction__Alternatives_0_1 ) ) ) + // InternalBehaviorAnnexParser.g:7264:1: ( ( rule__CommunicationAction__Alternatives_0_1 ) ) { - // InternalBehaviorAnnexParser.g:7088:1: ( ( rule__CommunicationAction__Alternatives_0_1 ) ) - // InternalBehaviorAnnexParser.g:7089:2: ( rule__CommunicationAction__Alternatives_0_1 ) + // InternalBehaviorAnnexParser.g:7264:1: ( ( rule__CommunicationAction__Alternatives_0_1 ) ) + // InternalBehaviorAnnexParser.g:7265:2: ( rule__CommunicationAction__Alternatives_0_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAlternatives_0_1()); } - // InternalBehaviorAnnexParser.g:7090:2: ( rule__CommunicationAction__Alternatives_0_1 ) - // InternalBehaviorAnnexParser.g:7090:3: rule__CommunicationAction__Alternatives_0_1 + // InternalBehaviorAnnexParser.g:7266:2: ( rule__CommunicationAction__Alternatives_0_1 ) + // InternalBehaviorAnnexParser.g:7266:3: rule__CommunicationAction__Alternatives_0_1 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Alternatives_0_1(); @@ -24329,14 +24960,14 @@ public final void rule__CommunicationAction__Group_0__1__Impl() throws Recogniti // $ANTLR start "rule__CommunicationAction__Group_0_1_0__0" - // InternalBehaviorAnnexParser.g:7099:1: rule__CommunicationAction__Group_0_1_0__0 : rule__CommunicationAction__Group_0_1_0__0__Impl rule__CommunicationAction__Group_0_1_0__1 ; + // InternalBehaviorAnnexParser.g:7275:1: rule__CommunicationAction__Group_0_1_0__0 : rule__CommunicationAction__Group_0_1_0__0__Impl rule__CommunicationAction__Group_0_1_0__1 ; public final void rule__CommunicationAction__Group_0_1_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7103:1: ( rule__CommunicationAction__Group_0_1_0__0__Impl rule__CommunicationAction__Group_0_1_0__1 ) - // InternalBehaviorAnnexParser.g:7104:2: rule__CommunicationAction__Group_0_1_0__0__Impl rule__CommunicationAction__Group_0_1_0__1 + // InternalBehaviorAnnexParser.g:7279:1: ( rule__CommunicationAction__Group_0_1_0__0__Impl rule__CommunicationAction__Group_0_1_0__1 ) + // InternalBehaviorAnnexParser.g:7280:2: rule__CommunicationAction__Group_0_1_0__0__Impl rule__CommunicationAction__Group_0_1_0__1 { pushFollow(FollowSets000.FOLLOW_27); rule__CommunicationAction__Group_0_1_0__0__Impl(); @@ -24367,23 +24998,23 @@ public final void rule__CommunicationAction__Group_0_1_0__0() throws Recognition // $ANTLR start "rule__CommunicationAction__Group_0_1_0__0__Impl" - // InternalBehaviorAnnexParser.g:7111:1: rule__CommunicationAction__Group_0_1_0__0__Impl : ( ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) ) ; + // InternalBehaviorAnnexParser.g:7287:1: rule__CommunicationAction__Group_0_1_0__0__Impl : ( ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) ) ; public final void rule__CommunicationAction__Group_0_1_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7115:1: ( ( ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) ) ) - // InternalBehaviorAnnexParser.g:7116:1: ( ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) ) + // InternalBehaviorAnnexParser.g:7291:1: ( ( ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) ) ) + // InternalBehaviorAnnexParser.g:7292:1: ( ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) ) { - // InternalBehaviorAnnexParser.g:7116:1: ( ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) ) - // InternalBehaviorAnnexParser.g:7117:2: ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) + // InternalBehaviorAnnexParser.g:7292:1: ( ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) ) + // InternalBehaviorAnnexParser.g:7293:2: ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getSendAssignment_0_1_0_0()); } - // InternalBehaviorAnnexParser.g:7118:2: ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) - // InternalBehaviorAnnexParser.g:7118:3: rule__CommunicationAction__SendAssignment_0_1_0_0 + // InternalBehaviorAnnexParser.g:7294:2: ( rule__CommunicationAction__SendAssignment_0_1_0_0 ) + // InternalBehaviorAnnexParser.g:7294:3: rule__CommunicationAction__SendAssignment_0_1_0_0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__SendAssignment_0_1_0_0(); @@ -24418,14 +25049,14 @@ public final void rule__CommunicationAction__Group_0_1_0__0__Impl() throws Recog // $ANTLR start "rule__CommunicationAction__Group_0_1_0__1" - // InternalBehaviorAnnexParser.g:7126:1: rule__CommunicationAction__Group_0_1_0__1 : rule__CommunicationAction__Group_0_1_0__1__Impl ; + // InternalBehaviorAnnexParser.g:7302:1: rule__CommunicationAction__Group_0_1_0__1 : rule__CommunicationAction__Group_0_1_0__1__Impl ; public final void rule__CommunicationAction__Group_0_1_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7130:1: ( rule__CommunicationAction__Group_0_1_0__1__Impl ) - // InternalBehaviorAnnexParser.g:7131:2: rule__CommunicationAction__Group_0_1_0__1__Impl + // InternalBehaviorAnnexParser.g:7306:1: ( rule__CommunicationAction__Group_0_1_0__1__Impl ) + // InternalBehaviorAnnexParser.g:7307:2: rule__CommunicationAction__Group_0_1_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0_1_0__1__Impl(); @@ -24451,31 +25082,31 @@ public final void rule__CommunicationAction__Group_0_1_0__1() throws Recognition // $ANTLR start "rule__CommunicationAction__Group_0_1_0__1__Impl" - // InternalBehaviorAnnexParser.g:7137:1: rule__CommunicationAction__Group_0_1_0__1__Impl : ( ( rule__CommunicationAction__Group_0_1_0_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:7313:1: rule__CommunicationAction__Group_0_1_0__1__Impl : ( ( rule__CommunicationAction__Group_0_1_0_1__0 )? ) ; public final void rule__CommunicationAction__Group_0_1_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7141:1: ( ( ( rule__CommunicationAction__Group_0_1_0_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:7142:1: ( ( rule__CommunicationAction__Group_0_1_0_1__0 )? ) + // InternalBehaviorAnnexParser.g:7317:1: ( ( ( rule__CommunicationAction__Group_0_1_0_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:7318:1: ( ( rule__CommunicationAction__Group_0_1_0_1__0 )? ) { - // InternalBehaviorAnnexParser.g:7142:1: ( ( rule__CommunicationAction__Group_0_1_0_1__0 )? ) - // InternalBehaviorAnnexParser.g:7143:2: ( rule__CommunicationAction__Group_0_1_0_1__0 )? + // InternalBehaviorAnnexParser.g:7318:1: ( ( rule__CommunicationAction__Group_0_1_0_1__0 )? ) + // InternalBehaviorAnnexParser.g:7319:2: ( rule__CommunicationAction__Group_0_1_0_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getGroup_0_1_0_1()); } - // InternalBehaviorAnnexParser.g:7144:2: ( rule__CommunicationAction__Group_0_1_0_1__0 )? - int alt71=2; - int LA71_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:7320:2: ( rule__CommunicationAction__Group_0_1_0_1__0 )? + int alt74=2; + int LA74_0 = input.LA(1); - if ( (LA71_0==LeftParenthesis) ) { - alt71=1; + if ( (LA74_0==LeftParenthesis) ) { + alt74=1; } - switch (alt71) { + switch (alt74) { case 1 : - // InternalBehaviorAnnexParser.g:7144:3: rule__CommunicationAction__Group_0_1_0_1__0 + // InternalBehaviorAnnexParser.g:7320:3: rule__CommunicationAction__Group_0_1_0_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0_1_0_1__0(); @@ -24513,14 +25144,14 @@ public final void rule__CommunicationAction__Group_0_1_0__1__Impl() throws Recog // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1__0" - // InternalBehaviorAnnexParser.g:7153:1: rule__CommunicationAction__Group_0_1_0_1__0 : rule__CommunicationAction__Group_0_1_0_1__0__Impl rule__CommunicationAction__Group_0_1_0_1__1 ; + // InternalBehaviorAnnexParser.g:7329:1: rule__CommunicationAction__Group_0_1_0_1__0 : rule__CommunicationAction__Group_0_1_0_1__0__Impl rule__CommunicationAction__Group_0_1_0_1__1 ; public final void rule__CommunicationAction__Group_0_1_0_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7157:1: ( rule__CommunicationAction__Group_0_1_0_1__0__Impl rule__CommunicationAction__Group_0_1_0_1__1 ) - // InternalBehaviorAnnexParser.g:7158:2: rule__CommunicationAction__Group_0_1_0_1__0__Impl rule__CommunicationAction__Group_0_1_0_1__1 + // InternalBehaviorAnnexParser.g:7333:1: ( rule__CommunicationAction__Group_0_1_0_1__0__Impl rule__CommunicationAction__Group_0_1_0_1__1 ) + // InternalBehaviorAnnexParser.g:7334:2: rule__CommunicationAction__Group_0_1_0_1__0__Impl rule__CommunicationAction__Group_0_1_0_1__1 { pushFollow(FollowSets000.FOLLOW_47); rule__CommunicationAction__Group_0_1_0_1__0__Impl(); @@ -24551,17 +25182,17 @@ public final void rule__CommunicationAction__Group_0_1_0_1__0() throws Recogniti // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1__0__Impl" - // InternalBehaviorAnnexParser.g:7165:1: rule__CommunicationAction__Group_0_1_0_1__0__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:7341:1: rule__CommunicationAction__Group_0_1_0_1__0__Impl : ( LeftParenthesis ) ; public final void rule__CommunicationAction__Group_0_1_0_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7169:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:7170:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:7345:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:7346:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:7170:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:7171:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:7346:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:7347:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getLeftParenthesisKeyword_0_1_0_1_0()); @@ -24592,14 +25223,14 @@ public final void rule__CommunicationAction__Group_0_1_0_1__0__Impl() throws Rec // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1__1" - // InternalBehaviorAnnexParser.g:7180:1: rule__CommunicationAction__Group_0_1_0_1__1 : rule__CommunicationAction__Group_0_1_0_1__1__Impl rule__CommunicationAction__Group_0_1_0_1__2 ; + // InternalBehaviorAnnexParser.g:7356:1: rule__CommunicationAction__Group_0_1_0_1__1 : rule__CommunicationAction__Group_0_1_0_1__1__Impl rule__CommunicationAction__Group_0_1_0_1__2 ; public final void rule__CommunicationAction__Group_0_1_0_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7184:1: ( rule__CommunicationAction__Group_0_1_0_1__1__Impl rule__CommunicationAction__Group_0_1_0_1__2 ) - // InternalBehaviorAnnexParser.g:7185:2: rule__CommunicationAction__Group_0_1_0_1__1__Impl rule__CommunicationAction__Group_0_1_0_1__2 + // InternalBehaviorAnnexParser.g:7360:1: ( rule__CommunicationAction__Group_0_1_0_1__1__Impl rule__CommunicationAction__Group_0_1_0_1__2 ) + // InternalBehaviorAnnexParser.g:7361:2: rule__CommunicationAction__Group_0_1_0_1__1__Impl rule__CommunicationAction__Group_0_1_0_1__2 { pushFollow(FollowSets000.FOLLOW_28); rule__CommunicationAction__Group_0_1_0_1__1__Impl(); @@ -24630,23 +25261,23 @@ public final void rule__CommunicationAction__Group_0_1_0_1__1() throws Recogniti // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1__1__Impl" - // InternalBehaviorAnnexParser.g:7192:1: rule__CommunicationAction__Group_0_1_0_1__1__Impl : ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:7368:1: rule__CommunicationAction__Group_0_1_0_1__1__Impl : ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) ) ; public final void rule__CommunicationAction__Group_0_1_0_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7196:1: ( ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:7197:1: ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) ) + // InternalBehaviorAnnexParser.g:7372:1: ( ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:7373:1: ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) ) { - // InternalBehaviorAnnexParser.g:7197:1: ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) ) - // InternalBehaviorAnnexParser.g:7198:2: ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) + // InternalBehaviorAnnexParser.g:7373:1: ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) ) + // InternalBehaviorAnnexParser.g:7374:2: ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getParametersAssignment_0_1_0_1_1()); } - // InternalBehaviorAnnexParser.g:7199:2: ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) - // InternalBehaviorAnnexParser.g:7199:3: rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 + // InternalBehaviorAnnexParser.g:7375:2: ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 ) + // InternalBehaviorAnnexParser.g:7375:3: rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__ParametersAssignment_0_1_0_1_1(); @@ -24681,14 +25312,14 @@ public final void rule__CommunicationAction__Group_0_1_0_1__1__Impl() throws Rec // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1__2" - // InternalBehaviorAnnexParser.g:7207:1: rule__CommunicationAction__Group_0_1_0_1__2 : rule__CommunicationAction__Group_0_1_0_1__2__Impl rule__CommunicationAction__Group_0_1_0_1__3 ; + // InternalBehaviorAnnexParser.g:7383:1: rule__CommunicationAction__Group_0_1_0_1__2 : rule__CommunicationAction__Group_0_1_0_1__2__Impl rule__CommunicationAction__Group_0_1_0_1__3 ; public final void rule__CommunicationAction__Group_0_1_0_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7211:1: ( rule__CommunicationAction__Group_0_1_0_1__2__Impl rule__CommunicationAction__Group_0_1_0_1__3 ) - // InternalBehaviorAnnexParser.g:7212:2: rule__CommunicationAction__Group_0_1_0_1__2__Impl rule__CommunicationAction__Group_0_1_0_1__3 + // InternalBehaviorAnnexParser.g:7387:1: ( rule__CommunicationAction__Group_0_1_0_1__2__Impl rule__CommunicationAction__Group_0_1_0_1__3 ) + // InternalBehaviorAnnexParser.g:7388:2: rule__CommunicationAction__Group_0_1_0_1__2__Impl rule__CommunicationAction__Group_0_1_0_1__3 { pushFollow(FollowSets000.FOLLOW_28); rule__CommunicationAction__Group_0_1_0_1__2__Impl(); @@ -24719,35 +25350,35 @@ public final void rule__CommunicationAction__Group_0_1_0_1__2() throws Recogniti // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1__2__Impl" - // InternalBehaviorAnnexParser.g:7219:1: rule__CommunicationAction__Group_0_1_0_1__2__Impl : ( ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* ) ; + // InternalBehaviorAnnexParser.g:7395:1: rule__CommunicationAction__Group_0_1_0_1__2__Impl : ( ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* ) ; public final void rule__CommunicationAction__Group_0_1_0_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7223:1: ( ( ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* ) ) - // InternalBehaviorAnnexParser.g:7224:1: ( ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* ) + // InternalBehaviorAnnexParser.g:7399:1: ( ( ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* ) ) + // InternalBehaviorAnnexParser.g:7400:1: ( ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* ) { - // InternalBehaviorAnnexParser.g:7224:1: ( ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* ) - // InternalBehaviorAnnexParser.g:7225:2: ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* + // InternalBehaviorAnnexParser.g:7400:1: ( ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* ) + // InternalBehaviorAnnexParser.g:7401:2: ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getGroup_0_1_0_1_2()); } - // InternalBehaviorAnnexParser.g:7226:2: ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* - loop72: + // InternalBehaviorAnnexParser.g:7402:2: ( rule__CommunicationAction__Group_0_1_0_1_2__0 )* + loop75: do { - int alt72=2; - int LA72_0 = input.LA(1); + int alt75=2; + int LA75_0 = input.LA(1); - if ( (LA72_0==Comma) ) { - alt72=1; + if ( (LA75_0==Comma) ) { + alt75=1; } - switch (alt72) { + switch (alt75) { case 1 : - // InternalBehaviorAnnexParser.g:7226:3: rule__CommunicationAction__Group_0_1_0_1_2__0 + // InternalBehaviorAnnexParser.g:7402:3: rule__CommunicationAction__Group_0_1_0_1_2__0 { pushFollow(FollowSets000.FOLLOW_7); rule__CommunicationAction__Group_0_1_0_1_2__0(); @@ -24759,7 +25390,7 @@ public final void rule__CommunicationAction__Group_0_1_0_1__2__Impl() throws Rec break; default : - break loop72; + break loop75; } } while (true); @@ -24788,14 +25419,14 @@ public final void rule__CommunicationAction__Group_0_1_0_1__2__Impl() throws Rec // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1__3" - // InternalBehaviorAnnexParser.g:7234:1: rule__CommunicationAction__Group_0_1_0_1__3 : rule__CommunicationAction__Group_0_1_0_1__3__Impl ; + // InternalBehaviorAnnexParser.g:7410:1: rule__CommunicationAction__Group_0_1_0_1__3 : rule__CommunicationAction__Group_0_1_0_1__3__Impl ; public final void rule__CommunicationAction__Group_0_1_0_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7238:1: ( rule__CommunicationAction__Group_0_1_0_1__3__Impl ) - // InternalBehaviorAnnexParser.g:7239:2: rule__CommunicationAction__Group_0_1_0_1__3__Impl + // InternalBehaviorAnnexParser.g:7414:1: ( rule__CommunicationAction__Group_0_1_0_1__3__Impl ) + // InternalBehaviorAnnexParser.g:7415:2: rule__CommunicationAction__Group_0_1_0_1__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0_1_0_1__3__Impl(); @@ -24821,17 +25452,17 @@ public final void rule__CommunicationAction__Group_0_1_0_1__3() throws Recogniti // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1__3__Impl" - // InternalBehaviorAnnexParser.g:7245:1: rule__CommunicationAction__Group_0_1_0_1__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:7421:1: rule__CommunicationAction__Group_0_1_0_1__3__Impl : ( RightParenthesis ) ; public final void rule__CommunicationAction__Group_0_1_0_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7249:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:7250:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:7425:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:7426:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:7250:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:7251:2: RightParenthesis + // InternalBehaviorAnnexParser.g:7426:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:7427:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getRightParenthesisKeyword_0_1_0_1_3()); @@ -24862,14 +25493,14 @@ public final void rule__CommunicationAction__Group_0_1_0_1__3__Impl() throws Rec // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1_2__0" - // InternalBehaviorAnnexParser.g:7261:1: rule__CommunicationAction__Group_0_1_0_1_2__0 : rule__CommunicationAction__Group_0_1_0_1_2__0__Impl rule__CommunicationAction__Group_0_1_0_1_2__1 ; + // InternalBehaviorAnnexParser.g:7437:1: rule__CommunicationAction__Group_0_1_0_1_2__0 : rule__CommunicationAction__Group_0_1_0_1_2__0__Impl rule__CommunicationAction__Group_0_1_0_1_2__1 ; public final void rule__CommunicationAction__Group_0_1_0_1_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7265:1: ( rule__CommunicationAction__Group_0_1_0_1_2__0__Impl rule__CommunicationAction__Group_0_1_0_1_2__1 ) - // InternalBehaviorAnnexParser.g:7266:2: rule__CommunicationAction__Group_0_1_0_1_2__0__Impl rule__CommunicationAction__Group_0_1_0_1_2__1 + // InternalBehaviorAnnexParser.g:7441:1: ( rule__CommunicationAction__Group_0_1_0_1_2__0__Impl rule__CommunicationAction__Group_0_1_0_1_2__1 ) + // InternalBehaviorAnnexParser.g:7442:2: rule__CommunicationAction__Group_0_1_0_1_2__0__Impl rule__CommunicationAction__Group_0_1_0_1_2__1 { pushFollow(FollowSets000.FOLLOW_47); rule__CommunicationAction__Group_0_1_0_1_2__0__Impl(); @@ -24900,17 +25531,17 @@ public final void rule__CommunicationAction__Group_0_1_0_1_2__0() throws Recogni // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1_2__0__Impl" - // InternalBehaviorAnnexParser.g:7273:1: rule__CommunicationAction__Group_0_1_0_1_2__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:7449:1: rule__CommunicationAction__Group_0_1_0_1_2__0__Impl : ( Comma ) ; public final void rule__CommunicationAction__Group_0_1_0_1_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7277:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:7278:1: ( Comma ) + // InternalBehaviorAnnexParser.g:7453:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:7454:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:7278:1: ( Comma ) - // InternalBehaviorAnnexParser.g:7279:2: Comma + // InternalBehaviorAnnexParser.g:7454:1: ( Comma ) + // InternalBehaviorAnnexParser.g:7455:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getCommaKeyword_0_1_0_1_2_0()); @@ -24941,14 +25572,14 @@ public final void rule__CommunicationAction__Group_0_1_0_1_2__0__Impl() throws R // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1_2__1" - // InternalBehaviorAnnexParser.g:7288:1: rule__CommunicationAction__Group_0_1_0_1_2__1 : rule__CommunicationAction__Group_0_1_0_1_2__1__Impl ; + // InternalBehaviorAnnexParser.g:7464:1: rule__CommunicationAction__Group_0_1_0_1_2__1 : rule__CommunicationAction__Group_0_1_0_1_2__1__Impl ; public final void rule__CommunicationAction__Group_0_1_0_1_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7292:1: ( rule__CommunicationAction__Group_0_1_0_1_2__1__Impl ) - // InternalBehaviorAnnexParser.g:7293:2: rule__CommunicationAction__Group_0_1_0_1_2__1__Impl + // InternalBehaviorAnnexParser.g:7468:1: ( rule__CommunicationAction__Group_0_1_0_1_2__1__Impl ) + // InternalBehaviorAnnexParser.g:7469:2: rule__CommunicationAction__Group_0_1_0_1_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0_1_0_1_2__1__Impl(); @@ -24974,23 +25605,23 @@ public final void rule__CommunicationAction__Group_0_1_0_1_2__1() throws Recogni // $ANTLR start "rule__CommunicationAction__Group_0_1_0_1_2__1__Impl" - // InternalBehaviorAnnexParser.g:7299:1: rule__CommunicationAction__Group_0_1_0_1_2__1__Impl : ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) ) ; + // InternalBehaviorAnnexParser.g:7475:1: rule__CommunicationAction__Group_0_1_0_1_2__1__Impl : ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) ) ; public final void rule__CommunicationAction__Group_0_1_0_1_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7303:1: ( ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) ) ) - // InternalBehaviorAnnexParser.g:7304:1: ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) ) + // InternalBehaviorAnnexParser.g:7479:1: ( ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) ) ) + // InternalBehaviorAnnexParser.g:7480:1: ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) ) { - // InternalBehaviorAnnexParser.g:7304:1: ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) ) - // InternalBehaviorAnnexParser.g:7305:2: ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) + // InternalBehaviorAnnexParser.g:7480:1: ( ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) ) + // InternalBehaviorAnnexParser.g:7481:2: ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getParametersAssignment_0_1_0_1_2_1()); } - // InternalBehaviorAnnexParser.g:7306:2: ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) - // InternalBehaviorAnnexParser.g:7306:3: rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 + // InternalBehaviorAnnexParser.g:7482:2: ( rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 ) + // InternalBehaviorAnnexParser.g:7482:3: rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1(); @@ -25025,14 +25656,14 @@ public final void rule__CommunicationAction__Group_0_1_0_1_2__1__Impl() throws R // $ANTLR start "rule__CommunicationAction__Group_0_1_1__0" - // InternalBehaviorAnnexParser.g:7315:1: rule__CommunicationAction__Group_0_1_1__0 : rule__CommunicationAction__Group_0_1_1__0__Impl rule__CommunicationAction__Group_0_1_1__1 ; + // InternalBehaviorAnnexParser.g:7491:1: rule__CommunicationAction__Group_0_1_1__0 : rule__CommunicationAction__Group_0_1_1__0__Impl rule__CommunicationAction__Group_0_1_1__1 ; public final void rule__CommunicationAction__Group_0_1_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7319:1: ( rule__CommunicationAction__Group_0_1_1__0__Impl rule__CommunicationAction__Group_0_1_1__1 ) - // InternalBehaviorAnnexParser.g:7320:2: rule__CommunicationAction__Group_0_1_1__0__Impl rule__CommunicationAction__Group_0_1_1__1 + // InternalBehaviorAnnexParser.g:7495:1: ( rule__CommunicationAction__Group_0_1_1__0__Impl rule__CommunicationAction__Group_0_1_1__1 ) + // InternalBehaviorAnnexParser.g:7496:2: rule__CommunicationAction__Group_0_1_1__0__Impl rule__CommunicationAction__Group_0_1_1__1 { pushFollow(FollowSets000.FOLLOW_27); rule__CommunicationAction__Group_0_1_1__0__Impl(); @@ -25063,23 +25694,23 @@ public final void rule__CommunicationAction__Group_0_1_1__0() throws Recognition // $ANTLR start "rule__CommunicationAction__Group_0_1_1__0__Impl" - // InternalBehaviorAnnexParser.g:7327:1: rule__CommunicationAction__Group_0_1_1__0__Impl : ( ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) ) ; + // InternalBehaviorAnnexParser.g:7503:1: rule__CommunicationAction__Group_0_1_1__0__Impl : ( ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) ) ; public final void rule__CommunicationAction__Group_0_1_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7331:1: ( ( ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) ) ) - // InternalBehaviorAnnexParser.g:7332:1: ( ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) ) + // InternalBehaviorAnnexParser.g:7507:1: ( ( ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) ) ) + // InternalBehaviorAnnexParser.g:7508:1: ( ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) ) { - // InternalBehaviorAnnexParser.g:7332:1: ( ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) ) - // InternalBehaviorAnnexParser.g:7333:2: ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) + // InternalBehaviorAnnexParser.g:7508:1: ( ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) ) + // InternalBehaviorAnnexParser.g:7509:2: ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getDequeueAssignment_0_1_1_0()); } - // InternalBehaviorAnnexParser.g:7334:2: ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) - // InternalBehaviorAnnexParser.g:7334:3: rule__CommunicationAction__DequeueAssignment_0_1_1_0 + // InternalBehaviorAnnexParser.g:7510:2: ( rule__CommunicationAction__DequeueAssignment_0_1_1_0 ) + // InternalBehaviorAnnexParser.g:7510:3: rule__CommunicationAction__DequeueAssignment_0_1_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__DequeueAssignment_0_1_1_0(); @@ -25114,14 +25745,14 @@ public final void rule__CommunicationAction__Group_0_1_1__0__Impl() throws Recog // $ANTLR start "rule__CommunicationAction__Group_0_1_1__1" - // InternalBehaviorAnnexParser.g:7342:1: rule__CommunicationAction__Group_0_1_1__1 : rule__CommunicationAction__Group_0_1_1__1__Impl ; + // InternalBehaviorAnnexParser.g:7518:1: rule__CommunicationAction__Group_0_1_1__1 : rule__CommunicationAction__Group_0_1_1__1__Impl ; public final void rule__CommunicationAction__Group_0_1_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7346:1: ( rule__CommunicationAction__Group_0_1_1__1__Impl ) - // InternalBehaviorAnnexParser.g:7347:2: rule__CommunicationAction__Group_0_1_1__1__Impl + // InternalBehaviorAnnexParser.g:7522:1: ( rule__CommunicationAction__Group_0_1_1__1__Impl ) + // InternalBehaviorAnnexParser.g:7523:2: rule__CommunicationAction__Group_0_1_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0_1_1__1__Impl(); @@ -25147,31 +25778,31 @@ public final void rule__CommunicationAction__Group_0_1_1__1() throws Recognition // $ANTLR start "rule__CommunicationAction__Group_0_1_1__1__Impl" - // InternalBehaviorAnnexParser.g:7353:1: rule__CommunicationAction__Group_0_1_1__1__Impl : ( ( rule__CommunicationAction__Group_0_1_1_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:7529:1: rule__CommunicationAction__Group_0_1_1__1__Impl : ( ( rule__CommunicationAction__Group_0_1_1_1__0 )? ) ; public final void rule__CommunicationAction__Group_0_1_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7357:1: ( ( ( rule__CommunicationAction__Group_0_1_1_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:7358:1: ( ( rule__CommunicationAction__Group_0_1_1_1__0 )? ) + // InternalBehaviorAnnexParser.g:7533:1: ( ( ( rule__CommunicationAction__Group_0_1_1_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:7534:1: ( ( rule__CommunicationAction__Group_0_1_1_1__0 )? ) { - // InternalBehaviorAnnexParser.g:7358:1: ( ( rule__CommunicationAction__Group_0_1_1_1__0 )? ) - // InternalBehaviorAnnexParser.g:7359:2: ( rule__CommunicationAction__Group_0_1_1_1__0 )? + // InternalBehaviorAnnexParser.g:7534:1: ( ( rule__CommunicationAction__Group_0_1_1_1__0 )? ) + // InternalBehaviorAnnexParser.g:7535:2: ( rule__CommunicationAction__Group_0_1_1_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getGroup_0_1_1_1()); } - // InternalBehaviorAnnexParser.g:7360:2: ( rule__CommunicationAction__Group_0_1_1_1__0 )? - int alt73=2; - int LA73_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:7536:2: ( rule__CommunicationAction__Group_0_1_1_1__0 )? + int alt76=2; + int LA76_0 = input.LA(1); - if ( (LA73_0==LeftParenthesis) ) { - alt73=1; + if ( (LA76_0==LeftParenthesis) ) { + alt76=1; } - switch (alt73) { + switch (alt76) { case 1 : - // InternalBehaviorAnnexParser.g:7360:3: rule__CommunicationAction__Group_0_1_1_1__0 + // InternalBehaviorAnnexParser.g:7536:3: rule__CommunicationAction__Group_0_1_1_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0_1_1_1__0(); @@ -25209,14 +25840,14 @@ public final void rule__CommunicationAction__Group_0_1_1__1__Impl() throws Recog // $ANTLR start "rule__CommunicationAction__Group_0_1_1_1__0" - // InternalBehaviorAnnexParser.g:7369:1: rule__CommunicationAction__Group_0_1_1_1__0 : rule__CommunicationAction__Group_0_1_1_1__0__Impl rule__CommunicationAction__Group_0_1_1_1__1 ; + // InternalBehaviorAnnexParser.g:7545:1: rule__CommunicationAction__Group_0_1_1_1__0 : rule__CommunicationAction__Group_0_1_1_1__0__Impl rule__CommunicationAction__Group_0_1_1_1__1 ; public final void rule__CommunicationAction__Group_0_1_1_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7373:1: ( rule__CommunicationAction__Group_0_1_1_1__0__Impl rule__CommunicationAction__Group_0_1_1_1__1 ) - // InternalBehaviorAnnexParser.g:7374:2: rule__CommunicationAction__Group_0_1_1_1__0__Impl rule__CommunicationAction__Group_0_1_1_1__1 + // InternalBehaviorAnnexParser.g:7549:1: ( rule__CommunicationAction__Group_0_1_1_1__0__Impl rule__CommunicationAction__Group_0_1_1_1__1 ) + // InternalBehaviorAnnexParser.g:7550:2: rule__CommunicationAction__Group_0_1_1_1__0__Impl rule__CommunicationAction__Group_0_1_1_1__1 { pushFollow(FollowSets000.FOLLOW_13); rule__CommunicationAction__Group_0_1_1_1__0__Impl(); @@ -25247,17 +25878,17 @@ public final void rule__CommunicationAction__Group_0_1_1_1__0() throws Recogniti // $ANTLR start "rule__CommunicationAction__Group_0_1_1_1__0__Impl" - // InternalBehaviorAnnexParser.g:7381:1: rule__CommunicationAction__Group_0_1_1_1__0__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:7557:1: rule__CommunicationAction__Group_0_1_1_1__0__Impl : ( LeftParenthesis ) ; public final void rule__CommunicationAction__Group_0_1_1_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7385:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:7386:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:7561:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:7562:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:7386:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:7387:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:7562:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:7563:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getLeftParenthesisKeyword_0_1_1_1_0()); @@ -25288,14 +25919,14 @@ public final void rule__CommunicationAction__Group_0_1_1_1__0__Impl() throws Rec // $ANTLR start "rule__CommunicationAction__Group_0_1_1_1__1" - // InternalBehaviorAnnexParser.g:7396:1: rule__CommunicationAction__Group_0_1_1_1__1 : rule__CommunicationAction__Group_0_1_1_1__1__Impl rule__CommunicationAction__Group_0_1_1_1__2 ; + // InternalBehaviorAnnexParser.g:7572:1: rule__CommunicationAction__Group_0_1_1_1__1 : rule__CommunicationAction__Group_0_1_1_1__1__Impl rule__CommunicationAction__Group_0_1_1_1__2 ; public final void rule__CommunicationAction__Group_0_1_1_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7400:1: ( rule__CommunicationAction__Group_0_1_1_1__1__Impl rule__CommunicationAction__Group_0_1_1_1__2 ) - // InternalBehaviorAnnexParser.g:7401:2: rule__CommunicationAction__Group_0_1_1_1__1__Impl rule__CommunicationAction__Group_0_1_1_1__2 + // InternalBehaviorAnnexParser.g:7576:1: ( rule__CommunicationAction__Group_0_1_1_1__1__Impl rule__CommunicationAction__Group_0_1_1_1__2 ) + // InternalBehaviorAnnexParser.g:7577:2: rule__CommunicationAction__Group_0_1_1_1__1__Impl rule__CommunicationAction__Group_0_1_1_1__2 { pushFollow(FollowSets000.FOLLOW_37); rule__CommunicationAction__Group_0_1_1_1__1__Impl(); @@ -25326,23 +25957,23 @@ public final void rule__CommunicationAction__Group_0_1_1_1__1() throws Recogniti // $ANTLR start "rule__CommunicationAction__Group_0_1_1_1__1__Impl" - // InternalBehaviorAnnexParser.g:7408:1: rule__CommunicationAction__Group_0_1_1_1__1__Impl : ( ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:7584:1: rule__CommunicationAction__Group_0_1_1_1__1__Impl : ( ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) ) ; public final void rule__CommunicationAction__Group_0_1_1_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7412:1: ( ( ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:7413:1: ( ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:7588:1: ( ( ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:7589:1: ( ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) ) { - // InternalBehaviorAnnexParser.g:7413:1: ( ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) ) - // InternalBehaviorAnnexParser.g:7414:2: ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) + // InternalBehaviorAnnexParser.g:7589:1: ( ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:7590:2: ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getTargetAssignment_0_1_1_1_1()); } - // InternalBehaviorAnnexParser.g:7415:2: ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) - // InternalBehaviorAnnexParser.g:7415:3: rule__CommunicationAction__TargetAssignment_0_1_1_1_1 + // InternalBehaviorAnnexParser.g:7591:2: ( rule__CommunicationAction__TargetAssignment_0_1_1_1_1 ) + // InternalBehaviorAnnexParser.g:7591:3: rule__CommunicationAction__TargetAssignment_0_1_1_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__TargetAssignment_0_1_1_1_1(); @@ -25377,14 +26008,14 @@ public final void rule__CommunicationAction__Group_0_1_1_1__1__Impl() throws Rec // $ANTLR start "rule__CommunicationAction__Group_0_1_1_1__2" - // InternalBehaviorAnnexParser.g:7423:1: rule__CommunicationAction__Group_0_1_1_1__2 : rule__CommunicationAction__Group_0_1_1_1__2__Impl ; + // InternalBehaviorAnnexParser.g:7599:1: rule__CommunicationAction__Group_0_1_1_1__2 : rule__CommunicationAction__Group_0_1_1_1__2__Impl ; public final void rule__CommunicationAction__Group_0_1_1_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7427:1: ( rule__CommunicationAction__Group_0_1_1_1__2__Impl ) - // InternalBehaviorAnnexParser.g:7428:2: rule__CommunicationAction__Group_0_1_1_1__2__Impl + // InternalBehaviorAnnexParser.g:7603:1: ( rule__CommunicationAction__Group_0_1_1_1__2__Impl ) + // InternalBehaviorAnnexParser.g:7604:2: rule__CommunicationAction__Group_0_1_1_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_0_1_1_1__2__Impl(); @@ -25410,17 +26041,17 @@ public final void rule__CommunicationAction__Group_0_1_1_1__2() throws Recogniti // $ANTLR start "rule__CommunicationAction__Group_0_1_1_1__2__Impl" - // InternalBehaviorAnnexParser.g:7434:1: rule__CommunicationAction__Group_0_1_1_1__2__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:7610:1: rule__CommunicationAction__Group_0_1_1_1__2__Impl : ( RightParenthesis ) ; public final void rule__CommunicationAction__Group_0_1_1_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7438:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:7439:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:7614:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:7615:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:7439:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:7440:2: RightParenthesis + // InternalBehaviorAnnexParser.g:7615:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:7616:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getRightParenthesisKeyword_0_1_1_1_2()); @@ -25451,14 +26082,14 @@ public final void rule__CommunicationAction__Group_0_1_1_1__2__Impl() throws Rec // $ANTLR start "rule__CommunicationAction__Group_1__0" - // InternalBehaviorAnnexParser.g:7450:1: rule__CommunicationAction__Group_1__0 : rule__CommunicationAction__Group_1__0__Impl rule__CommunicationAction__Group_1__1 ; + // InternalBehaviorAnnexParser.g:7626:1: rule__CommunicationAction__Group_1__0 : rule__CommunicationAction__Group_1__0__Impl rule__CommunicationAction__Group_1__1 ; public final void rule__CommunicationAction__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7454:1: ( rule__CommunicationAction__Group_1__0__Impl rule__CommunicationAction__Group_1__1 ) - // InternalBehaviorAnnexParser.g:7455:2: rule__CommunicationAction__Group_1__0__Impl rule__CommunicationAction__Group_1__1 + // InternalBehaviorAnnexParser.g:7630:1: ( rule__CommunicationAction__Group_1__0__Impl rule__CommunicationAction__Group_1__1 ) + // InternalBehaviorAnnexParser.g:7631:2: rule__CommunicationAction__Group_1__0__Impl rule__CommunicationAction__Group_1__1 { pushFollow(FollowSets000.FOLLOW_48); rule__CommunicationAction__Group_1__0__Impl(); @@ -25489,23 +26120,23 @@ public final void rule__CommunicationAction__Group_1__0() throws RecognitionExce // $ANTLR start "rule__CommunicationAction__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:7462:1: rule__CommunicationAction__Group_1__0__Impl : ( ( rule__CommunicationAction__AllAssignment_1_0 ) ) ; + // InternalBehaviorAnnexParser.g:7638:1: rule__CommunicationAction__Group_1__0__Impl : ( ( rule__CommunicationAction__AllAssignment_1_0 ) ) ; public final void rule__CommunicationAction__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7466:1: ( ( ( rule__CommunicationAction__AllAssignment_1_0 ) ) ) - // InternalBehaviorAnnexParser.g:7467:1: ( ( rule__CommunicationAction__AllAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:7642:1: ( ( ( rule__CommunicationAction__AllAssignment_1_0 ) ) ) + // InternalBehaviorAnnexParser.g:7643:1: ( ( rule__CommunicationAction__AllAssignment_1_0 ) ) { - // InternalBehaviorAnnexParser.g:7467:1: ( ( rule__CommunicationAction__AllAssignment_1_0 ) ) - // InternalBehaviorAnnexParser.g:7468:2: ( rule__CommunicationAction__AllAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:7643:1: ( ( rule__CommunicationAction__AllAssignment_1_0 ) ) + // InternalBehaviorAnnexParser.g:7644:2: ( rule__CommunicationAction__AllAssignment_1_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllAssignment_1_0()); } - // InternalBehaviorAnnexParser.g:7469:2: ( rule__CommunicationAction__AllAssignment_1_0 ) - // InternalBehaviorAnnexParser.g:7469:3: rule__CommunicationAction__AllAssignment_1_0 + // InternalBehaviorAnnexParser.g:7645:2: ( rule__CommunicationAction__AllAssignment_1_0 ) + // InternalBehaviorAnnexParser.g:7645:3: rule__CommunicationAction__AllAssignment_1_0 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__AllAssignment_1_0(); @@ -25540,14 +26171,14 @@ public final void rule__CommunicationAction__Group_1__0__Impl() throws Recogniti // $ANTLR start "rule__CommunicationAction__Group_1__1" - // InternalBehaviorAnnexParser.g:7477:1: rule__CommunicationAction__Group_1__1 : rule__CommunicationAction__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:7653:1: rule__CommunicationAction__Group_1__1 : rule__CommunicationAction__Group_1__1__Impl ; public final void rule__CommunicationAction__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7481:1: ( rule__CommunicationAction__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:7482:2: rule__CommunicationAction__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:7657:1: ( rule__CommunicationAction__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:7658:2: rule__CommunicationAction__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Group_1__1__Impl(); @@ -25573,23 +26204,23 @@ public final void rule__CommunicationAction__Group_1__1() throws RecognitionExce // $ANTLR start "rule__CommunicationAction__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:7488:1: rule__CommunicationAction__Group_1__1__Impl : ( ( rule__CommunicationAction__Alternatives_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:7664:1: rule__CommunicationAction__Group_1__1__Impl : ( ( rule__CommunicationAction__Alternatives_1_1 ) ) ; public final void rule__CommunicationAction__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7492:1: ( ( ( rule__CommunicationAction__Alternatives_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:7493:1: ( ( rule__CommunicationAction__Alternatives_1_1 ) ) + // InternalBehaviorAnnexParser.g:7668:1: ( ( ( rule__CommunicationAction__Alternatives_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:7669:1: ( ( rule__CommunicationAction__Alternatives_1_1 ) ) { - // InternalBehaviorAnnexParser.g:7493:1: ( ( rule__CommunicationAction__Alternatives_1_1 ) ) - // InternalBehaviorAnnexParser.g:7494:2: ( rule__CommunicationAction__Alternatives_1_1 ) + // InternalBehaviorAnnexParser.g:7669:1: ( ( rule__CommunicationAction__Alternatives_1_1 ) ) + // InternalBehaviorAnnexParser.g:7670:2: ( rule__CommunicationAction__Alternatives_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAlternatives_1_1()); } - // InternalBehaviorAnnexParser.g:7495:2: ( rule__CommunicationAction__Alternatives_1_1 ) - // InternalBehaviorAnnexParser.g:7495:3: rule__CommunicationAction__Alternatives_1_1 + // InternalBehaviorAnnexParser.g:7671:2: ( rule__CommunicationAction__Alternatives_1_1 ) + // InternalBehaviorAnnexParser.g:7671:3: rule__CommunicationAction__Alternatives_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__CommunicationAction__Alternatives_1_1(); @@ -25624,14 +26255,14 @@ public final void rule__CommunicationAction__Group_1__1__Impl() throws Recogniti // $ANTLR start "rule__TimedAction__Group__0" - // InternalBehaviorAnnexParser.g:7504:1: rule__TimedAction__Group__0 : rule__TimedAction__Group__0__Impl rule__TimedAction__Group__1 ; + // InternalBehaviorAnnexParser.g:7680:1: rule__TimedAction__Group__0 : rule__TimedAction__Group__0__Impl rule__TimedAction__Group__1 ; public final void rule__TimedAction__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7508:1: ( rule__TimedAction__Group__0__Impl rule__TimedAction__Group__1 ) - // InternalBehaviorAnnexParser.g:7509:2: rule__TimedAction__Group__0__Impl rule__TimedAction__Group__1 + // InternalBehaviorAnnexParser.g:7684:1: ( rule__TimedAction__Group__0__Impl rule__TimedAction__Group__1 ) + // InternalBehaviorAnnexParser.g:7685:2: rule__TimedAction__Group__0__Impl rule__TimedAction__Group__1 { pushFollow(FollowSets000.FOLLOW_27); rule__TimedAction__Group__0__Impl(); @@ -25662,17 +26293,17 @@ public final void rule__TimedAction__Group__0() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group__0__Impl" - // InternalBehaviorAnnexParser.g:7516:1: rule__TimedAction__Group__0__Impl : ( Computation ) ; + // InternalBehaviorAnnexParser.g:7692:1: rule__TimedAction__Group__0__Impl : ( Computation ) ; public final void rule__TimedAction__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7520:1: ( ( Computation ) ) - // InternalBehaviorAnnexParser.g:7521:1: ( Computation ) + // InternalBehaviorAnnexParser.g:7696:1: ( ( Computation ) ) + // InternalBehaviorAnnexParser.g:7697:1: ( Computation ) { - // InternalBehaviorAnnexParser.g:7521:1: ( Computation ) - // InternalBehaviorAnnexParser.g:7522:2: Computation + // InternalBehaviorAnnexParser.g:7697:1: ( Computation ) + // InternalBehaviorAnnexParser.g:7698:2: Computation { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getComputationKeyword_0()); @@ -25703,14 +26334,14 @@ public final void rule__TimedAction__Group__0__Impl() throws RecognitionExceptio // $ANTLR start "rule__TimedAction__Group__1" - // InternalBehaviorAnnexParser.g:7531:1: rule__TimedAction__Group__1 : rule__TimedAction__Group__1__Impl rule__TimedAction__Group__2 ; + // InternalBehaviorAnnexParser.g:7707:1: rule__TimedAction__Group__1 : rule__TimedAction__Group__1__Impl rule__TimedAction__Group__2 ; public final void rule__TimedAction__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7535:1: ( rule__TimedAction__Group__1__Impl rule__TimedAction__Group__2 ) - // InternalBehaviorAnnexParser.g:7536:2: rule__TimedAction__Group__1__Impl rule__TimedAction__Group__2 + // InternalBehaviorAnnexParser.g:7711:1: ( rule__TimedAction__Group__1__Impl rule__TimedAction__Group__2 ) + // InternalBehaviorAnnexParser.g:7712:2: rule__TimedAction__Group__1__Impl rule__TimedAction__Group__2 { pushFollow(FollowSets000.FOLLOW_13); rule__TimedAction__Group__1__Impl(); @@ -25741,17 +26372,17 @@ public final void rule__TimedAction__Group__1() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group__1__Impl" - // InternalBehaviorAnnexParser.g:7543:1: rule__TimedAction__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:7719:1: rule__TimedAction__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__TimedAction__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7547:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:7548:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:7723:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:7724:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:7548:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:7549:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:7724:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:7725:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getLeftParenthesisKeyword_1()); @@ -25782,14 +26413,14 @@ public final void rule__TimedAction__Group__1__Impl() throws RecognitionExceptio // $ANTLR start "rule__TimedAction__Group__2" - // InternalBehaviorAnnexParser.g:7558:1: rule__TimedAction__Group__2 : rule__TimedAction__Group__2__Impl rule__TimedAction__Group__3 ; + // InternalBehaviorAnnexParser.g:7734:1: rule__TimedAction__Group__2 : rule__TimedAction__Group__2__Impl rule__TimedAction__Group__3 ; public final void rule__TimedAction__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7562:1: ( rule__TimedAction__Group__2__Impl rule__TimedAction__Group__3 ) - // InternalBehaviorAnnexParser.g:7563:2: rule__TimedAction__Group__2__Impl rule__TimedAction__Group__3 + // InternalBehaviorAnnexParser.g:7738:1: ( rule__TimedAction__Group__2__Impl rule__TimedAction__Group__3 ) + // InternalBehaviorAnnexParser.g:7739:2: rule__TimedAction__Group__2__Impl rule__TimedAction__Group__3 { pushFollow(FollowSets000.FOLLOW_49); rule__TimedAction__Group__2__Impl(); @@ -25820,23 +26451,23 @@ public final void rule__TimedAction__Group__2() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group__2__Impl" - // InternalBehaviorAnnexParser.g:7570:1: rule__TimedAction__Group__2__Impl : ( ( rule__TimedAction__LowerTimeAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:7746:1: rule__TimedAction__Group__2__Impl : ( ( rule__TimedAction__LowerTimeAssignment_2 ) ) ; public final void rule__TimedAction__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7574:1: ( ( ( rule__TimedAction__LowerTimeAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:7575:1: ( ( rule__TimedAction__LowerTimeAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:7750:1: ( ( ( rule__TimedAction__LowerTimeAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:7751:1: ( ( rule__TimedAction__LowerTimeAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:7575:1: ( ( rule__TimedAction__LowerTimeAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:7576:2: ( rule__TimedAction__LowerTimeAssignment_2 ) + // InternalBehaviorAnnexParser.g:7751:1: ( ( rule__TimedAction__LowerTimeAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:7752:2: ( rule__TimedAction__LowerTimeAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getLowerTimeAssignment_2()); } - // InternalBehaviorAnnexParser.g:7577:2: ( rule__TimedAction__LowerTimeAssignment_2 ) - // InternalBehaviorAnnexParser.g:7577:3: rule__TimedAction__LowerTimeAssignment_2 + // InternalBehaviorAnnexParser.g:7753:2: ( rule__TimedAction__LowerTimeAssignment_2 ) + // InternalBehaviorAnnexParser.g:7753:3: rule__TimedAction__LowerTimeAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__TimedAction__LowerTimeAssignment_2(); @@ -25871,14 +26502,14 @@ public final void rule__TimedAction__Group__2__Impl() throws RecognitionExceptio // $ANTLR start "rule__TimedAction__Group__3" - // InternalBehaviorAnnexParser.g:7585:1: rule__TimedAction__Group__3 : rule__TimedAction__Group__3__Impl rule__TimedAction__Group__4 ; + // InternalBehaviorAnnexParser.g:7761:1: rule__TimedAction__Group__3 : rule__TimedAction__Group__3__Impl rule__TimedAction__Group__4 ; public final void rule__TimedAction__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7589:1: ( rule__TimedAction__Group__3__Impl rule__TimedAction__Group__4 ) - // InternalBehaviorAnnexParser.g:7590:2: rule__TimedAction__Group__3__Impl rule__TimedAction__Group__4 + // InternalBehaviorAnnexParser.g:7765:1: ( rule__TimedAction__Group__3__Impl rule__TimedAction__Group__4 ) + // InternalBehaviorAnnexParser.g:7766:2: rule__TimedAction__Group__3__Impl rule__TimedAction__Group__4 { pushFollow(FollowSets000.FOLLOW_49); rule__TimedAction__Group__3__Impl(); @@ -25909,31 +26540,31 @@ public final void rule__TimedAction__Group__3() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group__3__Impl" - // InternalBehaviorAnnexParser.g:7597:1: rule__TimedAction__Group__3__Impl : ( ( rule__TimedAction__Group_3__0 )? ) ; + // InternalBehaviorAnnexParser.g:7773:1: rule__TimedAction__Group__3__Impl : ( ( rule__TimedAction__Group_3__0 )? ) ; public final void rule__TimedAction__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7601:1: ( ( ( rule__TimedAction__Group_3__0 )? ) ) - // InternalBehaviorAnnexParser.g:7602:1: ( ( rule__TimedAction__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:7777:1: ( ( ( rule__TimedAction__Group_3__0 )? ) ) + // InternalBehaviorAnnexParser.g:7778:1: ( ( rule__TimedAction__Group_3__0 )? ) { - // InternalBehaviorAnnexParser.g:7602:1: ( ( rule__TimedAction__Group_3__0 )? ) - // InternalBehaviorAnnexParser.g:7603:2: ( rule__TimedAction__Group_3__0 )? + // InternalBehaviorAnnexParser.g:7778:1: ( ( rule__TimedAction__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:7779:2: ( rule__TimedAction__Group_3__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getGroup_3()); } - // InternalBehaviorAnnexParser.g:7604:2: ( rule__TimedAction__Group_3__0 )? - int alt74=2; - int LA74_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:7780:2: ( rule__TimedAction__Group_3__0 )? + int alt77=2; + int LA77_0 = input.LA(1); - if ( (LA74_0==FullStopFullStop) ) { - alt74=1; + if ( (LA77_0==FullStopFullStop) ) { + alt77=1; } - switch (alt74) { + switch (alt77) { case 1 : - // InternalBehaviorAnnexParser.g:7604:3: rule__TimedAction__Group_3__0 + // InternalBehaviorAnnexParser.g:7780:3: rule__TimedAction__Group_3__0 { pushFollow(FollowSets000.FOLLOW_2); rule__TimedAction__Group_3__0(); @@ -25971,14 +26602,14 @@ public final void rule__TimedAction__Group__3__Impl() throws RecognitionExceptio // $ANTLR start "rule__TimedAction__Group__4" - // InternalBehaviorAnnexParser.g:7612:1: rule__TimedAction__Group__4 : rule__TimedAction__Group__4__Impl rule__TimedAction__Group__5 ; + // InternalBehaviorAnnexParser.g:7788:1: rule__TimedAction__Group__4 : rule__TimedAction__Group__4__Impl rule__TimedAction__Group__5 ; public final void rule__TimedAction__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7616:1: ( rule__TimedAction__Group__4__Impl rule__TimedAction__Group__5 ) - // InternalBehaviorAnnexParser.g:7617:2: rule__TimedAction__Group__4__Impl rule__TimedAction__Group__5 + // InternalBehaviorAnnexParser.g:7792:1: ( rule__TimedAction__Group__4__Impl rule__TimedAction__Group__5 ) + // InternalBehaviorAnnexParser.g:7793:2: rule__TimedAction__Group__4__Impl rule__TimedAction__Group__5 { pushFollow(FollowSets000.FOLLOW_50); rule__TimedAction__Group__4__Impl(); @@ -26009,17 +26640,17 @@ public final void rule__TimedAction__Group__4() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group__4__Impl" - // InternalBehaviorAnnexParser.g:7624:1: rule__TimedAction__Group__4__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:7800:1: rule__TimedAction__Group__4__Impl : ( RightParenthesis ) ; public final void rule__TimedAction__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7628:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:7629:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:7804:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:7805:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:7629:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:7630:2: RightParenthesis + // InternalBehaviorAnnexParser.g:7805:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:7806:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getRightParenthesisKeyword_4()); @@ -26050,14 +26681,14 @@ public final void rule__TimedAction__Group__4__Impl() throws RecognitionExceptio // $ANTLR start "rule__TimedAction__Group__5" - // InternalBehaviorAnnexParser.g:7639:1: rule__TimedAction__Group__5 : rule__TimedAction__Group__5__Impl ; + // InternalBehaviorAnnexParser.g:7815:1: rule__TimedAction__Group__5 : rule__TimedAction__Group__5__Impl ; public final void rule__TimedAction__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7643:1: ( rule__TimedAction__Group__5__Impl ) - // InternalBehaviorAnnexParser.g:7644:2: rule__TimedAction__Group__5__Impl + // InternalBehaviorAnnexParser.g:7819:1: ( rule__TimedAction__Group__5__Impl ) + // InternalBehaviorAnnexParser.g:7820:2: rule__TimedAction__Group__5__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__TimedAction__Group__5__Impl(); @@ -26083,31 +26714,31 @@ public final void rule__TimedAction__Group__5() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group__5__Impl" - // InternalBehaviorAnnexParser.g:7650:1: rule__TimedAction__Group__5__Impl : ( ( rule__TimedAction__Group_5__0 )? ) ; + // InternalBehaviorAnnexParser.g:7826:1: rule__TimedAction__Group__5__Impl : ( ( rule__TimedAction__Group_5__0 )? ) ; public final void rule__TimedAction__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7654:1: ( ( ( rule__TimedAction__Group_5__0 )? ) ) - // InternalBehaviorAnnexParser.g:7655:1: ( ( rule__TimedAction__Group_5__0 )? ) + // InternalBehaviorAnnexParser.g:7830:1: ( ( ( rule__TimedAction__Group_5__0 )? ) ) + // InternalBehaviorAnnexParser.g:7831:1: ( ( rule__TimedAction__Group_5__0 )? ) { - // InternalBehaviorAnnexParser.g:7655:1: ( ( rule__TimedAction__Group_5__0 )? ) - // InternalBehaviorAnnexParser.g:7656:2: ( rule__TimedAction__Group_5__0 )? + // InternalBehaviorAnnexParser.g:7831:1: ( ( rule__TimedAction__Group_5__0 )? ) + // InternalBehaviorAnnexParser.g:7832:2: ( rule__TimedAction__Group_5__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getGroup_5()); } - // InternalBehaviorAnnexParser.g:7657:2: ( rule__TimedAction__Group_5__0 )? - int alt75=2; - int LA75_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:7833:2: ( rule__TimedAction__Group_5__0 )? + int alt78=2; + int LA78_0 = input.LA(1); - if ( (LA75_0==In) ) { - alt75=1; + if ( (LA78_0==In) ) { + alt78=1; } - switch (alt75) { + switch (alt78) { case 1 : - // InternalBehaviorAnnexParser.g:7657:3: rule__TimedAction__Group_5__0 + // InternalBehaviorAnnexParser.g:7833:3: rule__TimedAction__Group_5__0 { pushFollow(FollowSets000.FOLLOW_2); rule__TimedAction__Group_5__0(); @@ -26145,14 +26776,14 @@ public final void rule__TimedAction__Group__5__Impl() throws RecognitionExceptio // $ANTLR start "rule__TimedAction__Group_3__0" - // InternalBehaviorAnnexParser.g:7666:1: rule__TimedAction__Group_3__0 : rule__TimedAction__Group_3__0__Impl rule__TimedAction__Group_3__1 ; + // InternalBehaviorAnnexParser.g:7842:1: rule__TimedAction__Group_3__0 : rule__TimedAction__Group_3__0__Impl rule__TimedAction__Group_3__1 ; public final void rule__TimedAction__Group_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7670:1: ( rule__TimedAction__Group_3__0__Impl rule__TimedAction__Group_3__1 ) - // InternalBehaviorAnnexParser.g:7671:2: rule__TimedAction__Group_3__0__Impl rule__TimedAction__Group_3__1 + // InternalBehaviorAnnexParser.g:7846:1: ( rule__TimedAction__Group_3__0__Impl rule__TimedAction__Group_3__1 ) + // InternalBehaviorAnnexParser.g:7847:2: rule__TimedAction__Group_3__0__Impl rule__TimedAction__Group_3__1 { pushFollow(FollowSets000.FOLLOW_13); rule__TimedAction__Group_3__0__Impl(); @@ -26183,17 +26814,17 @@ public final void rule__TimedAction__Group_3__0() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group_3__0__Impl" - // InternalBehaviorAnnexParser.g:7678:1: rule__TimedAction__Group_3__0__Impl : ( FullStopFullStop ) ; + // InternalBehaviorAnnexParser.g:7854:1: rule__TimedAction__Group_3__0__Impl : ( FullStopFullStop ) ; public final void rule__TimedAction__Group_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7682:1: ( ( FullStopFullStop ) ) - // InternalBehaviorAnnexParser.g:7683:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:7858:1: ( ( FullStopFullStop ) ) + // InternalBehaviorAnnexParser.g:7859:1: ( FullStopFullStop ) { - // InternalBehaviorAnnexParser.g:7683:1: ( FullStopFullStop ) - // InternalBehaviorAnnexParser.g:7684:2: FullStopFullStop + // InternalBehaviorAnnexParser.g:7859:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:7860:2: FullStopFullStop { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getFullStopFullStopKeyword_3_0()); @@ -26224,14 +26855,14 @@ public final void rule__TimedAction__Group_3__0__Impl() throws RecognitionExcept // $ANTLR start "rule__TimedAction__Group_3__1" - // InternalBehaviorAnnexParser.g:7693:1: rule__TimedAction__Group_3__1 : rule__TimedAction__Group_3__1__Impl ; + // InternalBehaviorAnnexParser.g:7869:1: rule__TimedAction__Group_3__1 : rule__TimedAction__Group_3__1__Impl ; public final void rule__TimedAction__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7697:1: ( rule__TimedAction__Group_3__1__Impl ) - // InternalBehaviorAnnexParser.g:7698:2: rule__TimedAction__Group_3__1__Impl + // InternalBehaviorAnnexParser.g:7873:1: ( rule__TimedAction__Group_3__1__Impl ) + // InternalBehaviorAnnexParser.g:7874:2: rule__TimedAction__Group_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__TimedAction__Group_3__1__Impl(); @@ -26257,23 +26888,23 @@ public final void rule__TimedAction__Group_3__1() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group_3__1__Impl" - // InternalBehaviorAnnexParser.g:7704:1: rule__TimedAction__Group_3__1__Impl : ( ( rule__TimedAction__UpperTimeAssignment_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:7880:1: rule__TimedAction__Group_3__1__Impl : ( ( rule__TimedAction__UpperTimeAssignment_3_1 ) ) ; public final void rule__TimedAction__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7708:1: ( ( ( rule__TimedAction__UpperTimeAssignment_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:7709:1: ( ( rule__TimedAction__UpperTimeAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:7884:1: ( ( ( rule__TimedAction__UpperTimeAssignment_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:7885:1: ( ( rule__TimedAction__UpperTimeAssignment_3_1 ) ) { - // InternalBehaviorAnnexParser.g:7709:1: ( ( rule__TimedAction__UpperTimeAssignment_3_1 ) ) - // InternalBehaviorAnnexParser.g:7710:2: ( rule__TimedAction__UpperTimeAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:7885:1: ( ( rule__TimedAction__UpperTimeAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:7886:2: ( rule__TimedAction__UpperTimeAssignment_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getUpperTimeAssignment_3_1()); } - // InternalBehaviorAnnexParser.g:7711:2: ( rule__TimedAction__UpperTimeAssignment_3_1 ) - // InternalBehaviorAnnexParser.g:7711:3: rule__TimedAction__UpperTimeAssignment_3_1 + // InternalBehaviorAnnexParser.g:7887:2: ( rule__TimedAction__UpperTimeAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:7887:3: rule__TimedAction__UpperTimeAssignment_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__TimedAction__UpperTimeAssignment_3_1(); @@ -26308,14 +26939,14 @@ public final void rule__TimedAction__Group_3__1__Impl() throws RecognitionExcept // $ANTLR start "rule__TimedAction__Group_5__0" - // InternalBehaviorAnnexParser.g:7720:1: rule__TimedAction__Group_5__0 : rule__TimedAction__Group_5__0__Impl rule__TimedAction__Group_5__1 ; + // InternalBehaviorAnnexParser.g:7896:1: rule__TimedAction__Group_5__0 : rule__TimedAction__Group_5__0__Impl rule__TimedAction__Group_5__1 ; public final void rule__TimedAction__Group_5__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7724:1: ( rule__TimedAction__Group_5__0__Impl rule__TimedAction__Group_5__1 ) - // InternalBehaviorAnnexParser.g:7725:2: rule__TimedAction__Group_5__0__Impl rule__TimedAction__Group_5__1 + // InternalBehaviorAnnexParser.g:7900:1: ( rule__TimedAction__Group_5__0__Impl rule__TimedAction__Group_5__1 ) + // InternalBehaviorAnnexParser.g:7901:2: rule__TimedAction__Group_5__0__Impl rule__TimedAction__Group_5__1 { pushFollow(FollowSets000.FOLLOW_51); rule__TimedAction__Group_5__0__Impl(); @@ -26346,17 +26977,17 @@ public final void rule__TimedAction__Group_5__0() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group_5__0__Impl" - // InternalBehaviorAnnexParser.g:7732:1: rule__TimedAction__Group_5__0__Impl : ( In ) ; + // InternalBehaviorAnnexParser.g:7908:1: rule__TimedAction__Group_5__0__Impl : ( In ) ; public final void rule__TimedAction__Group_5__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7736:1: ( ( In ) ) - // InternalBehaviorAnnexParser.g:7737:1: ( In ) + // InternalBehaviorAnnexParser.g:7912:1: ( ( In ) ) + // InternalBehaviorAnnexParser.g:7913:1: ( In ) { - // InternalBehaviorAnnexParser.g:7737:1: ( In ) - // InternalBehaviorAnnexParser.g:7738:2: In + // InternalBehaviorAnnexParser.g:7913:1: ( In ) + // InternalBehaviorAnnexParser.g:7914:2: In { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getInKeyword_5_0()); @@ -26387,14 +27018,14 @@ public final void rule__TimedAction__Group_5__0__Impl() throws RecognitionExcept // $ANTLR start "rule__TimedAction__Group_5__1" - // InternalBehaviorAnnexParser.g:7747:1: rule__TimedAction__Group_5__1 : rule__TimedAction__Group_5__1__Impl rule__TimedAction__Group_5__2 ; + // InternalBehaviorAnnexParser.g:7923:1: rule__TimedAction__Group_5__1 : rule__TimedAction__Group_5__1__Impl rule__TimedAction__Group_5__2 ; public final void rule__TimedAction__Group_5__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7751:1: ( rule__TimedAction__Group_5__1__Impl rule__TimedAction__Group_5__2 ) - // InternalBehaviorAnnexParser.g:7752:2: rule__TimedAction__Group_5__1__Impl rule__TimedAction__Group_5__2 + // InternalBehaviorAnnexParser.g:7927:1: ( rule__TimedAction__Group_5__1__Impl rule__TimedAction__Group_5__2 ) + // InternalBehaviorAnnexParser.g:7928:2: rule__TimedAction__Group_5__1__Impl rule__TimedAction__Group_5__2 { pushFollow(FollowSets000.FOLLOW_27); rule__TimedAction__Group_5__1__Impl(); @@ -26425,17 +27056,17 @@ public final void rule__TimedAction__Group_5__1() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group_5__1__Impl" - // InternalBehaviorAnnexParser.g:7759:1: rule__TimedAction__Group_5__1__Impl : ( Binding ) ; + // InternalBehaviorAnnexParser.g:7935:1: rule__TimedAction__Group_5__1__Impl : ( Binding ) ; public final void rule__TimedAction__Group_5__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7763:1: ( ( Binding ) ) - // InternalBehaviorAnnexParser.g:7764:1: ( Binding ) + // InternalBehaviorAnnexParser.g:7939:1: ( ( Binding ) ) + // InternalBehaviorAnnexParser.g:7940:1: ( Binding ) { - // InternalBehaviorAnnexParser.g:7764:1: ( Binding ) - // InternalBehaviorAnnexParser.g:7765:2: Binding + // InternalBehaviorAnnexParser.g:7940:1: ( Binding ) + // InternalBehaviorAnnexParser.g:7941:2: Binding { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getBindingKeyword_5_1()); @@ -26466,14 +27097,14 @@ public final void rule__TimedAction__Group_5__1__Impl() throws RecognitionExcept // $ANTLR start "rule__TimedAction__Group_5__2" - // InternalBehaviorAnnexParser.g:7774:1: rule__TimedAction__Group_5__2 : rule__TimedAction__Group_5__2__Impl rule__TimedAction__Group_5__3 ; + // InternalBehaviorAnnexParser.g:7950:1: rule__TimedAction__Group_5__2 : rule__TimedAction__Group_5__2__Impl rule__TimedAction__Group_5__3 ; public final void rule__TimedAction__Group_5__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7778:1: ( rule__TimedAction__Group_5__2__Impl rule__TimedAction__Group_5__3 ) - // InternalBehaviorAnnexParser.g:7779:2: rule__TimedAction__Group_5__2__Impl rule__TimedAction__Group_5__3 + // InternalBehaviorAnnexParser.g:7954:1: ( rule__TimedAction__Group_5__2__Impl rule__TimedAction__Group_5__3 ) + // InternalBehaviorAnnexParser.g:7955:2: rule__TimedAction__Group_5__2__Impl rule__TimedAction__Group_5__3 { pushFollow(FollowSets000.FOLLOW_4); rule__TimedAction__Group_5__2__Impl(); @@ -26504,17 +27135,17 @@ public final void rule__TimedAction__Group_5__2() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group_5__2__Impl" - // InternalBehaviorAnnexParser.g:7786:1: rule__TimedAction__Group_5__2__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:7962:1: rule__TimedAction__Group_5__2__Impl : ( LeftParenthesis ) ; public final void rule__TimedAction__Group_5__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7790:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:7791:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:7966:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:7967:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:7791:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:7792:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:7967:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:7968:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getLeftParenthesisKeyword_5_2()); @@ -26545,14 +27176,14 @@ public final void rule__TimedAction__Group_5__2__Impl() throws RecognitionExcept // $ANTLR start "rule__TimedAction__Group_5__3" - // InternalBehaviorAnnexParser.g:7801:1: rule__TimedAction__Group_5__3 : rule__TimedAction__Group_5__3__Impl rule__TimedAction__Group_5__4 ; + // InternalBehaviorAnnexParser.g:7977:1: rule__TimedAction__Group_5__3 : rule__TimedAction__Group_5__3__Impl rule__TimedAction__Group_5__4 ; public final void rule__TimedAction__Group_5__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7805:1: ( rule__TimedAction__Group_5__3__Impl rule__TimedAction__Group_5__4 ) - // InternalBehaviorAnnexParser.g:7806:2: rule__TimedAction__Group_5__3__Impl rule__TimedAction__Group_5__4 + // InternalBehaviorAnnexParser.g:7981:1: ( rule__TimedAction__Group_5__3__Impl rule__TimedAction__Group_5__4 ) + // InternalBehaviorAnnexParser.g:7982:2: rule__TimedAction__Group_5__3__Impl rule__TimedAction__Group_5__4 { pushFollow(FollowSets000.FOLLOW_28); rule__TimedAction__Group_5__3__Impl(); @@ -26583,23 +27214,23 @@ public final void rule__TimedAction__Group_5__3() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group_5__3__Impl" - // InternalBehaviorAnnexParser.g:7813:1: rule__TimedAction__Group_5__3__Impl : ( ( rule__TimedAction__ProcessorsAssignment_5_3 ) ) ; + // InternalBehaviorAnnexParser.g:7989:1: rule__TimedAction__Group_5__3__Impl : ( ( rule__TimedAction__ProcessorsAssignment_5_3 ) ) ; public final void rule__TimedAction__Group_5__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7817:1: ( ( ( rule__TimedAction__ProcessorsAssignment_5_3 ) ) ) - // InternalBehaviorAnnexParser.g:7818:1: ( ( rule__TimedAction__ProcessorsAssignment_5_3 ) ) + // InternalBehaviorAnnexParser.g:7993:1: ( ( ( rule__TimedAction__ProcessorsAssignment_5_3 ) ) ) + // InternalBehaviorAnnexParser.g:7994:1: ( ( rule__TimedAction__ProcessorsAssignment_5_3 ) ) { - // InternalBehaviorAnnexParser.g:7818:1: ( ( rule__TimedAction__ProcessorsAssignment_5_3 ) ) - // InternalBehaviorAnnexParser.g:7819:2: ( rule__TimedAction__ProcessorsAssignment_5_3 ) + // InternalBehaviorAnnexParser.g:7994:1: ( ( rule__TimedAction__ProcessorsAssignment_5_3 ) ) + // InternalBehaviorAnnexParser.g:7995:2: ( rule__TimedAction__ProcessorsAssignment_5_3 ) { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getProcessorsAssignment_5_3()); } - // InternalBehaviorAnnexParser.g:7820:2: ( rule__TimedAction__ProcessorsAssignment_5_3 ) - // InternalBehaviorAnnexParser.g:7820:3: rule__TimedAction__ProcessorsAssignment_5_3 + // InternalBehaviorAnnexParser.g:7996:2: ( rule__TimedAction__ProcessorsAssignment_5_3 ) + // InternalBehaviorAnnexParser.g:7996:3: rule__TimedAction__ProcessorsAssignment_5_3 { pushFollow(FollowSets000.FOLLOW_2); rule__TimedAction__ProcessorsAssignment_5_3(); @@ -26634,14 +27265,14 @@ public final void rule__TimedAction__Group_5__3__Impl() throws RecognitionExcept // $ANTLR start "rule__TimedAction__Group_5__4" - // InternalBehaviorAnnexParser.g:7828:1: rule__TimedAction__Group_5__4 : rule__TimedAction__Group_5__4__Impl rule__TimedAction__Group_5__5 ; + // InternalBehaviorAnnexParser.g:8004:1: rule__TimedAction__Group_5__4 : rule__TimedAction__Group_5__4__Impl rule__TimedAction__Group_5__5 ; public final void rule__TimedAction__Group_5__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7832:1: ( rule__TimedAction__Group_5__4__Impl rule__TimedAction__Group_5__5 ) - // InternalBehaviorAnnexParser.g:7833:2: rule__TimedAction__Group_5__4__Impl rule__TimedAction__Group_5__5 + // InternalBehaviorAnnexParser.g:8008:1: ( rule__TimedAction__Group_5__4__Impl rule__TimedAction__Group_5__5 ) + // InternalBehaviorAnnexParser.g:8009:2: rule__TimedAction__Group_5__4__Impl rule__TimedAction__Group_5__5 { pushFollow(FollowSets000.FOLLOW_28); rule__TimedAction__Group_5__4__Impl(); @@ -26672,35 +27303,35 @@ public final void rule__TimedAction__Group_5__4() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group_5__4__Impl" - // InternalBehaviorAnnexParser.g:7840:1: rule__TimedAction__Group_5__4__Impl : ( ( rule__TimedAction__Group_5_4__0 )* ) ; + // InternalBehaviorAnnexParser.g:8016:1: rule__TimedAction__Group_5__4__Impl : ( ( rule__TimedAction__Group_5_4__0 )* ) ; public final void rule__TimedAction__Group_5__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7844:1: ( ( ( rule__TimedAction__Group_5_4__0 )* ) ) - // InternalBehaviorAnnexParser.g:7845:1: ( ( rule__TimedAction__Group_5_4__0 )* ) + // InternalBehaviorAnnexParser.g:8020:1: ( ( ( rule__TimedAction__Group_5_4__0 )* ) ) + // InternalBehaviorAnnexParser.g:8021:1: ( ( rule__TimedAction__Group_5_4__0 )* ) { - // InternalBehaviorAnnexParser.g:7845:1: ( ( rule__TimedAction__Group_5_4__0 )* ) - // InternalBehaviorAnnexParser.g:7846:2: ( rule__TimedAction__Group_5_4__0 )* + // InternalBehaviorAnnexParser.g:8021:1: ( ( rule__TimedAction__Group_5_4__0 )* ) + // InternalBehaviorAnnexParser.g:8022:2: ( rule__TimedAction__Group_5_4__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getGroup_5_4()); } - // InternalBehaviorAnnexParser.g:7847:2: ( rule__TimedAction__Group_5_4__0 )* - loop76: + // InternalBehaviorAnnexParser.g:8023:2: ( rule__TimedAction__Group_5_4__0 )* + loop79: do { - int alt76=2; - int LA76_0 = input.LA(1); + int alt79=2; + int LA79_0 = input.LA(1); - if ( (LA76_0==Comma) ) { - alt76=1; + if ( (LA79_0==Comma) ) { + alt79=1; } - switch (alt76) { + switch (alt79) { case 1 : - // InternalBehaviorAnnexParser.g:7847:3: rule__TimedAction__Group_5_4__0 + // InternalBehaviorAnnexParser.g:8023:3: rule__TimedAction__Group_5_4__0 { pushFollow(FollowSets000.FOLLOW_7); rule__TimedAction__Group_5_4__0(); @@ -26712,7 +27343,7 @@ public final void rule__TimedAction__Group_5__4__Impl() throws RecognitionExcept break; default : - break loop76; + break loop79; } } while (true); @@ -26741,14 +27372,14 @@ public final void rule__TimedAction__Group_5__4__Impl() throws RecognitionExcept // $ANTLR start "rule__TimedAction__Group_5__5" - // InternalBehaviorAnnexParser.g:7855:1: rule__TimedAction__Group_5__5 : rule__TimedAction__Group_5__5__Impl ; + // InternalBehaviorAnnexParser.g:8031:1: rule__TimedAction__Group_5__5 : rule__TimedAction__Group_5__5__Impl ; public final void rule__TimedAction__Group_5__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7859:1: ( rule__TimedAction__Group_5__5__Impl ) - // InternalBehaviorAnnexParser.g:7860:2: rule__TimedAction__Group_5__5__Impl + // InternalBehaviorAnnexParser.g:8035:1: ( rule__TimedAction__Group_5__5__Impl ) + // InternalBehaviorAnnexParser.g:8036:2: rule__TimedAction__Group_5__5__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__TimedAction__Group_5__5__Impl(); @@ -26774,17 +27405,17 @@ public final void rule__TimedAction__Group_5__5() throws RecognitionException { // $ANTLR start "rule__TimedAction__Group_5__5__Impl" - // InternalBehaviorAnnexParser.g:7866:1: rule__TimedAction__Group_5__5__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:8042:1: rule__TimedAction__Group_5__5__Impl : ( RightParenthesis ) ; public final void rule__TimedAction__Group_5__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7870:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:7871:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8046:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:8047:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:7871:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:7872:2: RightParenthesis + // InternalBehaviorAnnexParser.g:8047:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8048:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getRightParenthesisKeyword_5_5()); @@ -26815,14 +27446,14 @@ public final void rule__TimedAction__Group_5__5__Impl() throws RecognitionExcept // $ANTLR start "rule__TimedAction__Group_5_4__0" - // InternalBehaviorAnnexParser.g:7882:1: rule__TimedAction__Group_5_4__0 : rule__TimedAction__Group_5_4__0__Impl rule__TimedAction__Group_5_4__1 ; + // InternalBehaviorAnnexParser.g:8058:1: rule__TimedAction__Group_5_4__0 : rule__TimedAction__Group_5_4__0__Impl rule__TimedAction__Group_5_4__1 ; public final void rule__TimedAction__Group_5_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7886:1: ( rule__TimedAction__Group_5_4__0__Impl rule__TimedAction__Group_5_4__1 ) - // InternalBehaviorAnnexParser.g:7887:2: rule__TimedAction__Group_5_4__0__Impl rule__TimedAction__Group_5_4__1 + // InternalBehaviorAnnexParser.g:8062:1: ( rule__TimedAction__Group_5_4__0__Impl rule__TimedAction__Group_5_4__1 ) + // InternalBehaviorAnnexParser.g:8063:2: rule__TimedAction__Group_5_4__0__Impl rule__TimedAction__Group_5_4__1 { pushFollow(FollowSets000.FOLLOW_4); rule__TimedAction__Group_5_4__0__Impl(); @@ -26853,17 +27484,17 @@ public final void rule__TimedAction__Group_5_4__0() throws RecognitionException // $ANTLR start "rule__TimedAction__Group_5_4__0__Impl" - // InternalBehaviorAnnexParser.g:7894:1: rule__TimedAction__Group_5_4__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:8070:1: rule__TimedAction__Group_5_4__0__Impl : ( Comma ) ; public final void rule__TimedAction__Group_5_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7898:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:7899:1: ( Comma ) + // InternalBehaviorAnnexParser.g:8074:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:8075:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:7899:1: ( Comma ) - // InternalBehaviorAnnexParser.g:7900:2: Comma + // InternalBehaviorAnnexParser.g:8075:1: ( Comma ) + // InternalBehaviorAnnexParser.g:8076:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getCommaKeyword_5_4_0()); @@ -26894,14 +27525,14 @@ public final void rule__TimedAction__Group_5_4__0__Impl() throws RecognitionExce // $ANTLR start "rule__TimedAction__Group_5_4__1" - // InternalBehaviorAnnexParser.g:7909:1: rule__TimedAction__Group_5_4__1 : rule__TimedAction__Group_5_4__1__Impl ; + // InternalBehaviorAnnexParser.g:8085:1: rule__TimedAction__Group_5_4__1 : rule__TimedAction__Group_5_4__1__Impl ; public final void rule__TimedAction__Group_5_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7913:1: ( rule__TimedAction__Group_5_4__1__Impl ) - // InternalBehaviorAnnexParser.g:7914:2: rule__TimedAction__Group_5_4__1__Impl + // InternalBehaviorAnnexParser.g:8089:1: ( rule__TimedAction__Group_5_4__1__Impl ) + // InternalBehaviorAnnexParser.g:8090:2: rule__TimedAction__Group_5_4__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__TimedAction__Group_5_4__1__Impl(); @@ -26927,23 +27558,23 @@ public final void rule__TimedAction__Group_5_4__1() throws RecognitionException // $ANTLR start "rule__TimedAction__Group_5_4__1__Impl" - // InternalBehaviorAnnexParser.g:7920:1: rule__TimedAction__Group_5_4__1__Impl : ( ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) ) ; + // InternalBehaviorAnnexParser.g:8096:1: rule__TimedAction__Group_5_4__1__Impl : ( ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) ) ; public final void rule__TimedAction__Group_5_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7924:1: ( ( ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) ) ) - // InternalBehaviorAnnexParser.g:7925:1: ( ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) ) + // InternalBehaviorAnnexParser.g:8100:1: ( ( ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) ) ) + // InternalBehaviorAnnexParser.g:8101:1: ( ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) ) { - // InternalBehaviorAnnexParser.g:7925:1: ( ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) ) - // InternalBehaviorAnnexParser.g:7926:2: ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) + // InternalBehaviorAnnexParser.g:8101:1: ( ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) ) + // InternalBehaviorAnnexParser.g:8102:2: ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getProcessorsAssignment_5_4_1()); } - // InternalBehaviorAnnexParser.g:7927:2: ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) - // InternalBehaviorAnnexParser.g:7927:3: rule__TimedAction__ProcessorsAssignment_5_4_1 + // InternalBehaviorAnnexParser.g:8103:2: ( rule__TimedAction__ProcessorsAssignment_5_4_1 ) + // InternalBehaviorAnnexParser.g:8103:3: rule__TimedAction__ProcessorsAssignment_5_4_1 { pushFollow(FollowSets000.FOLLOW_2); rule__TimedAction__ProcessorsAssignment_5_4_1(); @@ -26978,14 +27609,14 @@ public final void rule__TimedAction__Group_5_4__1__Impl() throws RecognitionExce // $ANTLR start "rule__IfStatement__Group__0" - // InternalBehaviorAnnexParser.g:7936:1: rule__IfStatement__Group__0 : rule__IfStatement__Group__0__Impl rule__IfStatement__Group__1 ; + // InternalBehaviorAnnexParser.g:8112:1: rule__IfStatement__Group__0 : rule__IfStatement__Group__0__Impl rule__IfStatement__Group__1 ; public final void rule__IfStatement__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7940:1: ( rule__IfStatement__Group__0__Impl rule__IfStatement__Group__1 ) - // InternalBehaviorAnnexParser.g:7941:2: rule__IfStatement__Group__0__Impl rule__IfStatement__Group__1 + // InternalBehaviorAnnexParser.g:8116:1: ( rule__IfStatement__Group__0__Impl rule__IfStatement__Group__1 ) + // InternalBehaviorAnnexParser.g:8117:2: rule__IfStatement__Group__0__Impl rule__IfStatement__Group__1 { pushFollow(FollowSets000.FOLLOW_27); rule__IfStatement__Group__0__Impl(); @@ -27016,17 +27647,17 @@ public final void rule__IfStatement__Group__0() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group__0__Impl" - // InternalBehaviorAnnexParser.g:7948:1: rule__IfStatement__Group__0__Impl : ( If ) ; + // InternalBehaviorAnnexParser.g:8124:1: rule__IfStatement__Group__0__Impl : ( If ) ; public final void rule__IfStatement__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7952:1: ( ( If ) ) - // InternalBehaviorAnnexParser.g:7953:1: ( If ) + // InternalBehaviorAnnexParser.g:8128:1: ( ( If ) ) + // InternalBehaviorAnnexParser.g:8129:1: ( If ) { - // InternalBehaviorAnnexParser.g:7953:1: ( If ) - // InternalBehaviorAnnexParser.g:7954:2: If + // InternalBehaviorAnnexParser.g:8129:1: ( If ) + // InternalBehaviorAnnexParser.g:8130:2: If { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getIfKeyword_0()); @@ -27057,14 +27688,14 @@ public final void rule__IfStatement__Group__0__Impl() throws RecognitionExceptio // $ANTLR start "rule__IfStatement__Group__1" - // InternalBehaviorAnnexParser.g:7963:1: rule__IfStatement__Group__1 : rule__IfStatement__Group__1__Impl rule__IfStatement__Group__2 ; + // InternalBehaviorAnnexParser.g:8139:1: rule__IfStatement__Group__1 : rule__IfStatement__Group__1__Impl rule__IfStatement__Group__2 ; public final void rule__IfStatement__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7967:1: ( rule__IfStatement__Group__1__Impl rule__IfStatement__Group__2 ) - // InternalBehaviorAnnexParser.g:7968:2: rule__IfStatement__Group__1__Impl rule__IfStatement__Group__2 + // InternalBehaviorAnnexParser.g:8143:1: ( rule__IfStatement__Group__1__Impl rule__IfStatement__Group__2 ) + // InternalBehaviorAnnexParser.g:8144:2: rule__IfStatement__Group__1__Impl rule__IfStatement__Group__2 { pushFollow(FollowSets000.FOLLOW_47); rule__IfStatement__Group__1__Impl(); @@ -27095,17 +27726,17 @@ public final void rule__IfStatement__Group__1() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group__1__Impl" - // InternalBehaviorAnnexParser.g:7975:1: rule__IfStatement__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:8151:1: rule__IfStatement__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__IfStatement__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7979:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:7980:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:8155:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:8156:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:7980:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:7981:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:8156:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:8157:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getLeftParenthesisKeyword_1()); @@ -27136,14 +27767,14 @@ public final void rule__IfStatement__Group__1__Impl() throws RecognitionExceptio // $ANTLR start "rule__IfStatement__Group__2" - // InternalBehaviorAnnexParser.g:7990:1: rule__IfStatement__Group__2 : rule__IfStatement__Group__2__Impl rule__IfStatement__Group__3 ; + // InternalBehaviorAnnexParser.g:8166:1: rule__IfStatement__Group__2 : rule__IfStatement__Group__2__Impl rule__IfStatement__Group__3 ; public final void rule__IfStatement__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:7994:1: ( rule__IfStatement__Group__2__Impl rule__IfStatement__Group__3 ) - // InternalBehaviorAnnexParser.g:7995:2: rule__IfStatement__Group__2__Impl rule__IfStatement__Group__3 + // InternalBehaviorAnnexParser.g:8170:1: ( rule__IfStatement__Group__2__Impl rule__IfStatement__Group__3 ) + // InternalBehaviorAnnexParser.g:8171:2: rule__IfStatement__Group__2__Impl rule__IfStatement__Group__3 { pushFollow(FollowSets000.FOLLOW_37); rule__IfStatement__Group__2__Impl(); @@ -27174,23 +27805,23 @@ public final void rule__IfStatement__Group__2() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group__2__Impl" - // InternalBehaviorAnnexParser.g:8002:1: rule__IfStatement__Group__2__Impl : ( ( rule__IfStatement__ConditionAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:8178:1: rule__IfStatement__Group__2__Impl : ( ( rule__IfStatement__ConditionAssignment_2 ) ) ; public final void rule__IfStatement__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8006:1: ( ( ( rule__IfStatement__ConditionAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:8007:1: ( ( rule__IfStatement__ConditionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:8182:1: ( ( ( rule__IfStatement__ConditionAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:8183:1: ( ( rule__IfStatement__ConditionAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:8007:1: ( ( rule__IfStatement__ConditionAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:8008:2: ( rule__IfStatement__ConditionAssignment_2 ) + // InternalBehaviorAnnexParser.g:8183:1: ( ( rule__IfStatement__ConditionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:8184:2: ( rule__IfStatement__ConditionAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getConditionAssignment_2()); } - // InternalBehaviorAnnexParser.g:8009:2: ( rule__IfStatement__ConditionAssignment_2 ) - // InternalBehaviorAnnexParser.g:8009:3: rule__IfStatement__ConditionAssignment_2 + // InternalBehaviorAnnexParser.g:8185:2: ( rule__IfStatement__ConditionAssignment_2 ) + // InternalBehaviorAnnexParser.g:8185:3: rule__IfStatement__ConditionAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__IfStatement__ConditionAssignment_2(); @@ -27225,14 +27856,14 @@ public final void rule__IfStatement__Group__2__Impl() throws RecognitionExceptio // $ANTLR start "rule__IfStatement__Group__3" - // InternalBehaviorAnnexParser.g:8017:1: rule__IfStatement__Group__3 : rule__IfStatement__Group__3__Impl rule__IfStatement__Group__4 ; + // InternalBehaviorAnnexParser.g:8193:1: rule__IfStatement__Group__3 : rule__IfStatement__Group__3__Impl rule__IfStatement__Group__4 ; public final void rule__IfStatement__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8021:1: ( rule__IfStatement__Group__3__Impl rule__IfStatement__Group__4 ) - // InternalBehaviorAnnexParser.g:8022:2: rule__IfStatement__Group__3__Impl rule__IfStatement__Group__4 + // InternalBehaviorAnnexParser.g:8197:1: ( rule__IfStatement__Group__3__Impl rule__IfStatement__Group__4 ) + // InternalBehaviorAnnexParser.g:8198:2: rule__IfStatement__Group__3__Impl rule__IfStatement__Group__4 { pushFollow(FollowSets000.FOLLOW_38); rule__IfStatement__Group__3__Impl(); @@ -27263,17 +27894,17 @@ public final void rule__IfStatement__Group__3() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group__3__Impl" - // InternalBehaviorAnnexParser.g:8029:1: rule__IfStatement__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:8205:1: rule__IfStatement__Group__3__Impl : ( RightParenthesis ) ; public final void rule__IfStatement__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8033:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:8034:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8209:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:8210:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:8034:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:8035:2: RightParenthesis + // InternalBehaviorAnnexParser.g:8210:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8211:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getRightParenthesisKeyword_3()); @@ -27304,14 +27935,14 @@ public final void rule__IfStatement__Group__3__Impl() throws RecognitionExceptio // $ANTLR start "rule__IfStatement__Group__4" - // InternalBehaviorAnnexParser.g:8044:1: rule__IfStatement__Group__4 : rule__IfStatement__Group__4__Impl rule__IfStatement__Group__5 ; + // InternalBehaviorAnnexParser.g:8220:1: rule__IfStatement__Group__4 : rule__IfStatement__Group__4__Impl rule__IfStatement__Group__5 ; public final void rule__IfStatement__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8048:1: ( rule__IfStatement__Group__4__Impl rule__IfStatement__Group__5 ) - // InternalBehaviorAnnexParser.g:8049:2: rule__IfStatement__Group__4__Impl rule__IfStatement__Group__5 + // InternalBehaviorAnnexParser.g:8224:1: ( rule__IfStatement__Group__4__Impl rule__IfStatement__Group__5 ) + // InternalBehaviorAnnexParser.g:8225:2: rule__IfStatement__Group__4__Impl rule__IfStatement__Group__5 { pushFollow(FollowSets000.FOLLOW_52); rule__IfStatement__Group__4__Impl(); @@ -27342,23 +27973,23 @@ public final void rule__IfStatement__Group__4() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group__4__Impl" - // InternalBehaviorAnnexParser.g:8056:1: rule__IfStatement__Group__4__Impl : ( ( rule__IfStatement__ThenActionsAssignment_4 ) ) ; + // InternalBehaviorAnnexParser.g:8232:1: rule__IfStatement__Group__4__Impl : ( ( rule__IfStatement__ThenActionsAssignment_4 ) ) ; public final void rule__IfStatement__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8060:1: ( ( ( rule__IfStatement__ThenActionsAssignment_4 ) ) ) - // InternalBehaviorAnnexParser.g:8061:1: ( ( rule__IfStatement__ThenActionsAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:8236:1: ( ( ( rule__IfStatement__ThenActionsAssignment_4 ) ) ) + // InternalBehaviorAnnexParser.g:8237:1: ( ( rule__IfStatement__ThenActionsAssignment_4 ) ) { - // InternalBehaviorAnnexParser.g:8061:1: ( ( rule__IfStatement__ThenActionsAssignment_4 ) ) - // InternalBehaviorAnnexParser.g:8062:2: ( rule__IfStatement__ThenActionsAssignment_4 ) + // InternalBehaviorAnnexParser.g:8237:1: ( ( rule__IfStatement__ThenActionsAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:8238:2: ( rule__IfStatement__ThenActionsAssignment_4 ) { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getThenActionsAssignment_4()); } - // InternalBehaviorAnnexParser.g:8063:2: ( rule__IfStatement__ThenActionsAssignment_4 ) - // InternalBehaviorAnnexParser.g:8063:3: rule__IfStatement__ThenActionsAssignment_4 + // InternalBehaviorAnnexParser.g:8239:2: ( rule__IfStatement__ThenActionsAssignment_4 ) + // InternalBehaviorAnnexParser.g:8239:3: rule__IfStatement__ThenActionsAssignment_4 { pushFollow(FollowSets000.FOLLOW_2); rule__IfStatement__ThenActionsAssignment_4(); @@ -27393,14 +28024,14 @@ public final void rule__IfStatement__Group__4__Impl() throws RecognitionExceptio // $ANTLR start "rule__IfStatement__Group__5" - // InternalBehaviorAnnexParser.g:8071:1: rule__IfStatement__Group__5 : rule__IfStatement__Group__5__Impl rule__IfStatement__Group__6 ; + // InternalBehaviorAnnexParser.g:8247:1: rule__IfStatement__Group__5 : rule__IfStatement__Group__5__Impl rule__IfStatement__Group__6 ; public final void rule__IfStatement__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8075:1: ( rule__IfStatement__Group__5__Impl rule__IfStatement__Group__6 ) - // InternalBehaviorAnnexParser.g:8076:2: rule__IfStatement__Group__5__Impl rule__IfStatement__Group__6 + // InternalBehaviorAnnexParser.g:8251:1: ( rule__IfStatement__Group__5__Impl rule__IfStatement__Group__6 ) + // InternalBehaviorAnnexParser.g:8252:2: rule__IfStatement__Group__5__Impl rule__IfStatement__Group__6 { pushFollow(FollowSets000.FOLLOW_52); rule__IfStatement__Group__5__Impl(); @@ -27431,35 +28062,35 @@ public final void rule__IfStatement__Group__5() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group__5__Impl" - // InternalBehaviorAnnexParser.g:8083:1: rule__IfStatement__Group__5__Impl : ( ( rule__IfStatement__ElseIfsAssignment_5 )* ) ; + // InternalBehaviorAnnexParser.g:8259:1: rule__IfStatement__Group__5__Impl : ( ( rule__IfStatement__ElseIfsAssignment_5 )* ) ; public final void rule__IfStatement__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8087:1: ( ( ( rule__IfStatement__ElseIfsAssignment_5 )* ) ) - // InternalBehaviorAnnexParser.g:8088:1: ( ( rule__IfStatement__ElseIfsAssignment_5 )* ) + // InternalBehaviorAnnexParser.g:8263:1: ( ( ( rule__IfStatement__ElseIfsAssignment_5 )* ) ) + // InternalBehaviorAnnexParser.g:8264:1: ( ( rule__IfStatement__ElseIfsAssignment_5 )* ) { - // InternalBehaviorAnnexParser.g:8088:1: ( ( rule__IfStatement__ElseIfsAssignment_5 )* ) - // InternalBehaviorAnnexParser.g:8089:2: ( rule__IfStatement__ElseIfsAssignment_5 )* + // InternalBehaviorAnnexParser.g:8264:1: ( ( rule__IfStatement__ElseIfsAssignment_5 )* ) + // InternalBehaviorAnnexParser.g:8265:2: ( rule__IfStatement__ElseIfsAssignment_5 )* { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getElseIfsAssignment_5()); } - // InternalBehaviorAnnexParser.g:8090:2: ( rule__IfStatement__ElseIfsAssignment_5 )* - loop77: + // InternalBehaviorAnnexParser.g:8266:2: ( rule__IfStatement__ElseIfsAssignment_5 )* + loop80: do { - int alt77=2; - int LA77_0 = input.LA(1); + int alt80=2; + int LA80_0 = input.LA(1); - if ( (LA77_0==Elsif) ) { - alt77=1; + if ( (LA80_0==Elsif) ) { + alt80=1; } - switch (alt77) { + switch (alt80) { case 1 : - // InternalBehaviorAnnexParser.g:8090:3: rule__IfStatement__ElseIfsAssignment_5 + // InternalBehaviorAnnexParser.g:8266:3: rule__IfStatement__ElseIfsAssignment_5 { pushFollow(FollowSets000.FOLLOW_53); rule__IfStatement__ElseIfsAssignment_5(); @@ -27471,7 +28102,7 @@ public final void rule__IfStatement__Group__5__Impl() throws RecognitionExceptio break; default : - break loop77; + break loop80; } } while (true); @@ -27500,14 +28131,14 @@ public final void rule__IfStatement__Group__5__Impl() throws RecognitionExceptio // $ANTLR start "rule__IfStatement__Group__6" - // InternalBehaviorAnnexParser.g:8098:1: rule__IfStatement__Group__6 : rule__IfStatement__Group__6__Impl rule__IfStatement__Group__7 ; + // InternalBehaviorAnnexParser.g:8274:1: rule__IfStatement__Group__6 : rule__IfStatement__Group__6__Impl rule__IfStatement__Group__7 ; public final void rule__IfStatement__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8102:1: ( rule__IfStatement__Group__6__Impl rule__IfStatement__Group__7 ) - // InternalBehaviorAnnexParser.g:8103:2: rule__IfStatement__Group__6__Impl rule__IfStatement__Group__7 + // InternalBehaviorAnnexParser.g:8278:1: ( rule__IfStatement__Group__6__Impl rule__IfStatement__Group__7 ) + // InternalBehaviorAnnexParser.g:8279:2: rule__IfStatement__Group__6__Impl rule__IfStatement__Group__7 { pushFollow(FollowSets000.FOLLOW_52); rule__IfStatement__Group__6__Impl(); @@ -27538,31 +28169,31 @@ public final void rule__IfStatement__Group__6() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group__6__Impl" - // InternalBehaviorAnnexParser.g:8110:1: rule__IfStatement__Group__6__Impl : ( ( rule__IfStatement__Group_6__0 )? ) ; + // InternalBehaviorAnnexParser.g:8286:1: rule__IfStatement__Group__6__Impl : ( ( rule__IfStatement__Group_6__0 )? ) ; public final void rule__IfStatement__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8114:1: ( ( ( rule__IfStatement__Group_6__0 )? ) ) - // InternalBehaviorAnnexParser.g:8115:1: ( ( rule__IfStatement__Group_6__0 )? ) + // InternalBehaviorAnnexParser.g:8290:1: ( ( ( rule__IfStatement__Group_6__0 )? ) ) + // InternalBehaviorAnnexParser.g:8291:1: ( ( rule__IfStatement__Group_6__0 )? ) { - // InternalBehaviorAnnexParser.g:8115:1: ( ( rule__IfStatement__Group_6__0 )? ) - // InternalBehaviorAnnexParser.g:8116:2: ( rule__IfStatement__Group_6__0 )? + // InternalBehaviorAnnexParser.g:8291:1: ( ( rule__IfStatement__Group_6__0 )? ) + // InternalBehaviorAnnexParser.g:8292:2: ( rule__IfStatement__Group_6__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getGroup_6()); } - // InternalBehaviorAnnexParser.g:8117:2: ( rule__IfStatement__Group_6__0 )? - int alt78=2; - int LA78_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:8293:2: ( rule__IfStatement__Group_6__0 )? + int alt81=2; + int LA81_0 = input.LA(1); - if ( (LA78_0==Else) ) { - alt78=1; + if ( (LA81_0==Else) ) { + alt81=1; } - switch (alt78) { + switch (alt81) { case 1 : - // InternalBehaviorAnnexParser.g:8117:3: rule__IfStatement__Group_6__0 + // InternalBehaviorAnnexParser.g:8293:3: rule__IfStatement__Group_6__0 { pushFollow(FollowSets000.FOLLOW_2); rule__IfStatement__Group_6__0(); @@ -27600,14 +28231,14 @@ public final void rule__IfStatement__Group__6__Impl() throws RecognitionExceptio // $ANTLR start "rule__IfStatement__Group__7" - // InternalBehaviorAnnexParser.g:8125:1: rule__IfStatement__Group__7 : rule__IfStatement__Group__7__Impl rule__IfStatement__Group__8 ; + // InternalBehaviorAnnexParser.g:8301:1: rule__IfStatement__Group__7 : rule__IfStatement__Group__7__Impl rule__IfStatement__Group__8 ; public final void rule__IfStatement__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8129:1: ( rule__IfStatement__Group__7__Impl rule__IfStatement__Group__8 ) - // InternalBehaviorAnnexParser.g:8130:2: rule__IfStatement__Group__7__Impl rule__IfStatement__Group__8 + // InternalBehaviorAnnexParser.g:8305:1: ( rule__IfStatement__Group__7__Impl rule__IfStatement__Group__8 ) + // InternalBehaviorAnnexParser.g:8306:2: rule__IfStatement__Group__7__Impl rule__IfStatement__Group__8 { pushFollow(FollowSets000.FOLLOW_54); rule__IfStatement__Group__7__Impl(); @@ -27638,17 +28269,17 @@ public final void rule__IfStatement__Group__7() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group__7__Impl" - // InternalBehaviorAnnexParser.g:8137:1: rule__IfStatement__Group__7__Impl : ( End ) ; + // InternalBehaviorAnnexParser.g:8313:1: rule__IfStatement__Group__7__Impl : ( End ) ; public final void rule__IfStatement__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8141:1: ( ( End ) ) - // InternalBehaviorAnnexParser.g:8142:1: ( End ) + // InternalBehaviorAnnexParser.g:8317:1: ( ( End ) ) + // InternalBehaviorAnnexParser.g:8318:1: ( End ) { - // InternalBehaviorAnnexParser.g:8142:1: ( End ) - // InternalBehaviorAnnexParser.g:8143:2: End + // InternalBehaviorAnnexParser.g:8318:1: ( End ) + // InternalBehaviorAnnexParser.g:8319:2: End { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getEndKeyword_7()); @@ -27679,14 +28310,14 @@ public final void rule__IfStatement__Group__7__Impl() throws RecognitionExceptio // $ANTLR start "rule__IfStatement__Group__8" - // InternalBehaviorAnnexParser.g:8152:1: rule__IfStatement__Group__8 : rule__IfStatement__Group__8__Impl ; + // InternalBehaviorAnnexParser.g:8328:1: rule__IfStatement__Group__8 : rule__IfStatement__Group__8__Impl ; public final void rule__IfStatement__Group__8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8156:1: ( rule__IfStatement__Group__8__Impl ) - // InternalBehaviorAnnexParser.g:8157:2: rule__IfStatement__Group__8__Impl + // InternalBehaviorAnnexParser.g:8332:1: ( rule__IfStatement__Group__8__Impl ) + // InternalBehaviorAnnexParser.g:8333:2: rule__IfStatement__Group__8__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__IfStatement__Group__8__Impl(); @@ -27712,17 +28343,17 @@ public final void rule__IfStatement__Group__8() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group__8__Impl" - // InternalBehaviorAnnexParser.g:8163:1: rule__IfStatement__Group__8__Impl : ( If ) ; + // InternalBehaviorAnnexParser.g:8339:1: rule__IfStatement__Group__8__Impl : ( If ) ; public final void rule__IfStatement__Group__8__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8167:1: ( ( If ) ) - // InternalBehaviorAnnexParser.g:8168:1: ( If ) + // InternalBehaviorAnnexParser.g:8343:1: ( ( If ) ) + // InternalBehaviorAnnexParser.g:8344:1: ( If ) { - // InternalBehaviorAnnexParser.g:8168:1: ( If ) - // InternalBehaviorAnnexParser.g:8169:2: If + // InternalBehaviorAnnexParser.g:8344:1: ( If ) + // InternalBehaviorAnnexParser.g:8345:2: If { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getIfKeyword_8()); @@ -27753,14 +28384,14 @@ public final void rule__IfStatement__Group__8__Impl() throws RecognitionExceptio // $ANTLR start "rule__IfStatement__Group_6__0" - // InternalBehaviorAnnexParser.g:8179:1: rule__IfStatement__Group_6__0 : rule__IfStatement__Group_6__0__Impl rule__IfStatement__Group_6__1 ; + // InternalBehaviorAnnexParser.g:8355:1: rule__IfStatement__Group_6__0 : rule__IfStatement__Group_6__0__Impl rule__IfStatement__Group_6__1 ; public final void rule__IfStatement__Group_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8183:1: ( rule__IfStatement__Group_6__0__Impl rule__IfStatement__Group_6__1 ) - // InternalBehaviorAnnexParser.g:8184:2: rule__IfStatement__Group_6__0__Impl rule__IfStatement__Group_6__1 + // InternalBehaviorAnnexParser.g:8359:1: ( rule__IfStatement__Group_6__0__Impl rule__IfStatement__Group_6__1 ) + // InternalBehaviorAnnexParser.g:8360:2: rule__IfStatement__Group_6__0__Impl rule__IfStatement__Group_6__1 { pushFollow(FollowSets000.FOLLOW_38); rule__IfStatement__Group_6__0__Impl(); @@ -27791,17 +28422,17 @@ public final void rule__IfStatement__Group_6__0() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group_6__0__Impl" - // InternalBehaviorAnnexParser.g:8191:1: rule__IfStatement__Group_6__0__Impl : ( Else ) ; + // InternalBehaviorAnnexParser.g:8367:1: rule__IfStatement__Group_6__0__Impl : ( Else ) ; public final void rule__IfStatement__Group_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8195:1: ( ( Else ) ) - // InternalBehaviorAnnexParser.g:8196:1: ( Else ) + // InternalBehaviorAnnexParser.g:8371:1: ( ( Else ) ) + // InternalBehaviorAnnexParser.g:8372:1: ( Else ) { - // InternalBehaviorAnnexParser.g:8196:1: ( Else ) - // InternalBehaviorAnnexParser.g:8197:2: Else + // InternalBehaviorAnnexParser.g:8372:1: ( Else ) + // InternalBehaviorAnnexParser.g:8373:2: Else { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getElseKeyword_6_0()); @@ -27832,14 +28463,14 @@ public final void rule__IfStatement__Group_6__0__Impl() throws RecognitionExcept // $ANTLR start "rule__IfStatement__Group_6__1" - // InternalBehaviorAnnexParser.g:8206:1: rule__IfStatement__Group_6__1 : rule__IfStatement__Group_6__1__Impl ; + // InternalBehaviorAnnexParser.g:8382:1: rule__IfStatement__Group_6__1 : rule__IfStatement__Group_6__1__Impl ; public final void rule__IfStatement__Group_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8210:1: ( rule__IfStatement__Group_6__1__Impl ) - // InternalBehaviorAnnexParser.g:8211:2: rule__IfStatement__Group_6__1__Impl + // InternalBehaviorAnnexParser.g:8386:1: ( rule__IfStatement__Group_6__1__Impl ) + // InternalBehaviorAnnexParser.g:8387:2: rule__IfStatement__Group_6__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__IfStatement__Group_6__1__Impl(); @@ -27865,23 +28496,23 @@ public final void rule__IfStatement__Group_6__1() throws RecognitionException { // $ANTLR start "rule__IfStatement__Group_6__1__Impl" - // InternalBehaviorAnnexParser.g:8217:1: rule__IfStatement__Group_6__1__Impl : ( ( rule__IfStatement__ElseActionsAssignment_6_1 ) ) ; + // InternalBehaviorAnnexParser.g:8393:1: rule__IfStatement__Group_6__1__Impl : ( ( rule__IfStatement__ElseActionsAssignment_6_1 ) ) ; public final void rule__IfStatement__Group_6__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8221:1: ( ( ( rule__IfStatement__ElseActionsAssignment_6_1 ) ) ) - // InternalBehaviorAnnexParser.g:8222:1: ( ( rule__IfStatement__ElseActionsAssignment_6_1 ) ) + // InternalBehaviorAnnexParser.g:8397:1: ( ( ( rule__IfStatement__ElseActionsAssignment_6_1 ) ) ) + // InternalBehaviorAnnexParser.g:8398:1: ( ( rule__IfStatement__ElseActionsAssignment_6_1 ) ) { - // InternalBehaviorAnnexParser.g:8222:1: ( ( rule__IfStatement__ElseActionsAssignment_6_1 ) ) - // InternalBehaviorAnnexParser.g:8223:2: ( rule__IfStatement__ElseActionsAssignment_6_1 ) + // InternalBehaviorAnnexParser.g:8398:1: ( ( rule__IfStatement__ElseActionsAssignment_6_1 ) ) + // InternalBehaviorAnnexParser.g:8399:2: ( rule__IfStatement__ElseActionsAssignment_6_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getElseActionsAssignment_6_1()); } - // InternalBehaviorAnnexParser.g:8224:2: ( rule__IfStatement__ElseActionsAssignment_6_1 ) - // InternalBehaviorAnnexParser.g:8224:3: rule__IfStatement__ElseActionsAssignment_6_1 + // InternalBehaviorAnnexParser.g:8400:2: ( rule__IfStatement__ElseActionsAssignment_6_1 ) + // InternalBehaviorAnnexParser.g:8400:3: rule__IfStatement__ElseActionsAssignment_6_1 { pushFollow(FollowSets000.FOLLOW_2); rule__IfStatement__ElseActionsAssignment_6_1(); @@ -27916,14 +28547,14 @@ public final void rule__IfStatement__Group_6__1__Impl() throws RecognitionExcept // $ANTLR start "rule__ElseIfClause__Group__0" - // InternalBehaviorAnnexParser.g:8233:1: rule__ElseIfClause__Group__0 : rule__ElseIfClause__Group__0__Impl rule__ElseIfClause__Group__1 ; + // InternalBehaviorAnnexParser.g:8409:1: rule__ElseIfClause__Group__0 : rule__ElseIfClause__Group__0__Impl rule__ElseIfClause__Group__1 ; public final void rule__ElseIfClause__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8237:1: ( rule__ElseIfClause__Group__0__Impl rule__ElseIfClause__Group__1 ) - // InternalBehaviorAnnexParser.g:8238:2: rule__ElseIfClause__Group__0__Impl rule__ElseIfClause__Group__1 + // InternalBehaviorAnnexParser.g:8413:1: ( rule__ElseIfClause__Group__0__Impl rule__ElseIfClause__Group__1 ) + // InternalBehaviorAnnexParser.g:8414:2: rule__ElseIfClause__Group__0__Impl rule__ElseIfClause__Group__1 { pushFollow(FollowSets000.FOLLOW_27); rule__ElseIfClause__Group__0__Impl(); @@ -27954,17 +28585,17 @@ public final void rule__ElseIfClause__Group__0() throws RecognitionException { // $ANTLR start "rule__ElseIfClause__Group__0__Impl" - // InternalBehaviorAnnexParser.g:8245:1: rule__ElseIfClause__Group__0__Impl : ( Elsif ) ; + // InternalBehaviorAnnexParser.g:8421:1: rule__ElseIfClause__Group__0__Impl : ( Elsif ) ; public final void rule__ElseIfClause__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8249:1: ( ( Elsif ) ) - // InternalBehaviorAnnexParser.g:8250:1: ( Elsif ) + // InternalBehaviorAnnexParser.g:8425:1: ( ( Elsif ) ) + // InternalBehaviorAnnexParser.g:8426:1: ( Elsif ) { - // InternalBehaviorAnnexParser.g:8250:1: ( Elsif ) - // InternalBehaviorAnnexParser.g:8251:2: Elsif + // InternalBehaviorAnnexParser.g:8426:1: ( Elsif ) + // InternalBehaviorAnnexParser.g:8427:2: Elsif { if ( state.backtracking==0 ) { before(grammarAccess.getElseIfClauseAccess().getElsifKeyword_0()); @@ -27995,14 +28626,14 @@ public final void rule__ElseIfClause__Group__0__Impl() throws RecognitionExcepti // $ANTLR start "rule__ElseIfClause__Group__1" - // InternalBehaviorAnnexParser.g:8260:1: rule__ElseIfClause__Group__1 : rule__ElseIfClause__Group__1__Impl rule__ElseIfClause__Group__2 ; + // InternalBehaviorAnnexParser.g:8436:1: rule__ElseIfClause__Group__1 : rule__ElseIfClause__Group__1__Impl rule__ElseIfClause__Group__2 ; public final void rule__ElseIfClause__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8264:1: ( rule__ElseIfClause__Group__1__Impl rule__ElseIfClause__Group__2 ) - // InternalBehaviorAnnexParser.g:8265:2: rule__ElseIfClause__Group__1__Impl rule__ElseIfClause__Group__2 + // InternalBehaviorAnnexParser.g:8440:1: ( rule__ElseIfClause__Group__1__Impl rule__ElseIfClause__Group__2 ) + // InternalBehaviorAnnexParser.g:8441:2: rule__ElseIfClause__Group__1__Impl rule__ElseIfClause__Group__2 { pushFollow(FollowSets000.FOLLOW_47); rule__ElseIfClause__Group__1__Impl(); @@ -28033,17 +28664,17 @@ public final void rule__ElseIfClause__Group__1() throws RecognitionException { // $ANTLR start "rule__ElseIfClause__Group__1__Impl" - // InternalBehaviorAnnexParser.g:8272:1: rule__ElseIfClause__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:8448:1: rule__ElseIfClause__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__ElseIfClause__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8276:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:8277:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:8452:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:8453:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:8277:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:8278:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:8453:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:8454:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getElseIfClauseAccess().getLeftParenthesisKeyword_1()); @@ -28074,14 +28705,14 @@ public final void rule__ElseIfClause__Group__1__Impl() throws RecognitionExcepti // $ANTLR start "rule__ElseIfClause__Group__2" - // InternalBehaviorAnnexParser.g:8287:1: rule__ElseIfClause__Group__2 : rule__ElseIfClause__Group__2__Impl rule__ElseIfClause__Group__3 ; + // InternalBehaviorAnnexParser.g:8463:1: rule__ElseIfClause__Group__2 : rule__ElseIfClause__Group__2__Impl rule__ElseIfClause__Group__3 ; public final void rule__ElseIfClause__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8291:1: ( rule__ElseIfClause__Group__2__Impl rule__ElseIfClause__Group__3 ) - // InternalBehaviorAnnexParser.g:8292:2: rule__ElseIfClause__Group__2__Impl rule__ElseIfClause__Group__3 + // InternalBehaviorAnnexParser.g:8467:1: ( rule__ElseIfClause__Group__2__Impl rule__ElseIfClause__Group__3 ) + // InternalBehaviorAnnexParser.g:8468:2: rule__ElseIfClause__Group__2__Impl rule__ElseIfClause__Group__3 { pushFollow(FollowSets000.FOLLOW_37); rule__ElseIfClause__Group__2__Impl(); @@ -28112,23 +28743,23 @@ public final void rule__ElseIfClause__Group__2() throws RecognitionException { // $ANTLR start "rule__ElseIfClause__Group__2__Impl" - // InternalBehaviorAnnexParser.g:8299:1: rule__ElseIfClause__Group__2__Impl : ( ( rule__ElseIfClause__ConditionAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:8475:1: rule__ElseIfClause__Group__2__Impl : ( ( rule__ElseIfClause__ConditionAssignment_2 ) ) ; public final void rule__ElseIfClause__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8303:1: ( ( ( rule__ElseIfClause__ConditionAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:8304:1: ( ( rule__ElseIfClause__ConditionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:8479:1: ( ( ( rule__ElseIfClause__ConditionAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:8480:1: ( ( rule__ElseIfClause__ConditionAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:8304:1: ( ( rule__ElseIfClause__ConditionAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:8305:2: ( rule__ElseIfClause__ConditionAssignment_2 ) + // InternalBehaviorAnnexParser.g:8480:1: ( ( rule__ElseIfClause__ConditionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:8481:2: ( rule__ElseIfClause__ConditionAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getElseIfClauseAccess().getConditionAssignment_2()); } - // InternalBehaviorAnnexParser.g:8306:2: ( rule__ElseIfClause__ConditionAssignment_2 ) - // InternalBehaviorAnnexParser.g:8306:3: rule__ElseIfClause__ConditionAssignment_2 + // InternalBehaviorAnnexParser.g:8482:2: ( rule__ElseIfClause__ConditionAssignment_2 ) + // InternalBehaviorAnnexParser.g:8482:3: rule__ElseIfClause__ConditionAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ElseIfClause__ConditionAssignment_2(); @@ -28163,14 +28794,14 @@ public final void rule__ElseIfClause__Group__2__Impl() throws RecognitionExcepti // $ANTLR start "rule__ElseIfClause__Group__3" - // InternalBehaviorAnnexParser.g:8314:1: rule__ElseIfClause__Group__3 : rule__ElseIfClause__Group__3__Impl rule__ElseIfClause__Group__4 ; + // InternalBehaviorAnnexParser.g:8490:1: rule__ElseIfClause__Group__3 : rule__ElseIfClause__Group__3__Impl rule__ElseIfClause__Group__4 ; public final void rule__ElseIfClause__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8318:1: ( rule__ElseIfClause__Group__3__Impl rule__ElseIfClause__Group__4 ) - // InternalBehaviorAnnexParser.g:8319:2: rule__ElseIfClause__Group__3__Impl rule__ElseIfClause__Group__4 + // InternalBehaviorAnnexParser.g:8494:1: ( rule__ElseIfClause__Group__3__Impl rule__ElseIfClause__Group__4 ) + // InternalBehaviorAnnexParser.g:8495:2: rule__ElseIfClause__Group__3__Impl rule__ElseIfClause__Group__4 { pushFollow(FollowSets000.FOLLOW_38); rule__ElseIfClause__Group__3__Impl(); @@ -28201,17 +28832,17 @@ public final void rule__ElseIfClause__Group__3() throws RecognitionException { // $ANTLR start "rule__ElseIfClause__Group__3__Impl" - // InternalBehaviorAnnexParser.g:8326:1: rule__ElseIfClause__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:8502:1: rule__ElseIfClause__Group__3__Impl : ( RightParenthesis ) ; public final void rule__ElseIfClause__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8330:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:8331:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8506:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:8507:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:8331:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:8332:2: RightParenthesis + // InternalBehaviorAnnexParser.g:8507:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8508:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getElseIfClauseAccess().getRightParenthesisKeyword_3()); @@ -28242,14 +28873,14 @@ public final void rule__ElseIfClause__Group__3__Impl() throws RecognitionExcepti // $ANTLR start "rule__ElseIfClause__Group__4" - // InternalBehaviorAnnexParser.g:8341:1: rule__ElseIfClause__Group__4 : rule__ElseIfClause__Group__4__Impl ; + // InternalBehaviorAnnexParser.g:8517:1: rule__ElseIfClause__Group__4 : rule__ElseIfClause__Group__4__Impl ; public final void rule__ElseIfClause__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8345:1: ( rule__ElseIfClause__Group__4__Impl ) - // InternalBehaviorAnnexParser.g:8346:2: rule__ElseIfClause__Group__4__Impl + // InternalBehaviorAnnexParser.g:8521:1: ( rule__ElseIfClause__Group__4__Impl ) + // InternalBehaviorAnnexParser.g:8522:2: rule__ElseIfClause__Group__4__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ElseIfClause__Group__4__Impl(); @@ -28275,23 +28906,23 @@ public final void rule__ElseIfClause__Group__4() throws RecognitionException { // $ANTLR start "rule__ElseIfClause__Group__4__Impl" - // InternalBehaviorAnnexParser.g:8352:1: rule__ElseIfClause__Group__4__Impl : ( ( rule__ElseIfClause__ActionsAssignment_4 ) ) ; + // InternalBehaviorAnnexParser.g:8528:1: rule__ElseIfClause__Group__4__Impl : ( ( rule__ElseIfClause__ActionsAssignment_4 ) ) ; public final void rule__ElseIfClause__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8356:1: ( ( ( rule__ElseIfClause__ActionsAssignment_4 ) ) ) - // InternalBehaviorAnnexParser.g:8357:1: ( ( rule__ElseIfClause__ActionsAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:8532:1: ( ( ( rule__ElseIfClause__ActionsAssignment_4 ) ) ) + // InternalBehaviorAnnexParser.g:8533:1: ( ( rule__ElseIfClause__ActionsAssignment_4 ) ) { - // InternalBehaviorAnnexParser.g:8357:1: ( ( rule__ElseIfClause__ActionsAssignment_4 ) ) - // InternalBehaviorAnnexParser.g:8358:2: ( rule__ElseIfClause__ActionsAssignment_4 ) + // InternalBehaviorAnnexParser.g:8533:1: ( ( rule__ElseIfClause__ActionsAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:8534:2: ( rule__ElseIfClause__ActionsAssignment_4 ) { if ( state.backtracking==0 ) { before(grammarAccess.getElseIfClauseAccess().getActionsAssignment_4()); } - // InternalBehaviorAnnexParser.g:8359:2: ( rule__ElseIfClause__ActionsAssignment_4 ) - // InternalBehaviorAnnexParser.g:8359:3: rule__ElseIfClause__ActionsAssignment_4 + // InternalBehaviorAnnexParser.g:8535:2: ( rule__ElseIfClause__ActionsAssignment_4 ) + // InternalBehaviorAnnexParser.g:8535:3: rule__ElseIfClause__ActionsAssignment_4 { pushFollow(FollowSets000.FOLLOW_2); rule__ElseIfClause__ActionsAssignment_4(); @@ -28326,14 +28957,14 @@ public final void rule__ElseIfClause__Group__4__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__0" - // InternalBehaviorAnnexParser.g:8368:1: rule__ForStatement__Group__0 : rule__ForStatement__Group__0__Impl rule__ForStatement__Group__1 ; + // InternalBehaviorAnnexParser.g:8544:1: rule__ForStatement__Group__0 : rule__ForStatement__Group__0__Impl rule__ForStatement__Group__1 ; public final void rule__ForStatement__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8372:1: ( rule__ForStatement__Group__0__Impl rule__ForStatement__Group__1 ) - // InternalBehaviorAnnexParser.g:8373:2: rule__ForStatement__Group__0__Impl rule__ForStatement__Group__1 + // InternalBehaviorAnnexParser.g:8548:1: ( rule__ForStatement__Group__0__Impl rule__ForStatement__Group__1 ) + // InternalBehaviorAnnexParser.g:8549:2: rule__ForStatement__Group__0__Impl rule__ForStatement__Group__1 { pushFollow(FollowSets000.FOLLOW_27); rule__ForStatement__Group__0__Impl(); @@ -28364,23 +28995,23 @@ public final void rule__ForStatement__Group__0() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__0__Impl" - // InternalBehaviorAnnexParser.g:8380:1: rule__ForStatement__Group__0__Impl : ( ( rule__ForStatement__Alternatives_0 ) ) ; + // InternalBehaviorAnnexParser.g:8556:1: rule__ForStatement__Group__0__Impl : ( ( rule__ForStatement__Alternatives_0 ) ) ; public final void rule__ForStatement__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8384:1: ( ( ( rule__ForStatement__Alternatives_0 ) ) ) - // InternalBehaviorAnnexParser.g:8385:1: ( ( rule__ForStatement__Alternatives_0 ) ) + // InternalBehaviorAnnexParser.g:8560:1: ( ( ( rule__ForStatement__Alternatives_0 ) ) ) + // InternalBehaviorAnnexParser.g:8561:1: ( ( rule__ForStatement__Alternatives_0 ) ) { - // InternalBehaviorAnnexParser.g:8385:1: ( ( rule__ForStatement__Alternatives_0 ) ) - // InternalBehaviorAnnexParser.g:8386:2: ( rule__ForStatement__Alternatives_0 ) + // InternalBehaviorAnnexParser.g:8561:1: ( ( rule__ForStatement__Alternatives_0 ) ) + // InternalBehaviorAnnexParser.g:8562:2: ( rule__ForStatement__Alternatives_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getAlternatives_0()); } - // InternalBehaviorAnnexParser.g:8387:2: ( rule__ForStatement__Alternatives_0 ) - // InternalBehaviorAnnexParser.g:8387:3: rule__ForStatement__Alternatives_0 + // InternalBehaviorAnnexParser.g:8563:2: ( rule__ForStatement__Alternatives_0 ) + // InternalBehaviorAnnexParser.g:8563:3: rule__ForStatement__Alternatives_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ForStatement__Alternatives_0(); @@ -28415,14 +29046,14 @@ public final void rule__ForStatement__Group__0__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__1" - // InternalBehaviorAnnexParser.g:8395:1: rule__ForStatement__Group__1 : rule__ForStatement__Group__1__Impl rule__ForStatement__Group__2 ; + // InternalBehaviorAnnexParser.g:8571:1: rule__ForStatement__Group__1 : rule__ForStatement__Group__1__Impl rule__ForStatement__Group__2 ; public final void rule__ForStatement__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8399:1: ( rule__ForStatement__Group__1__Impl rule__ForStatement__Group__2 ) - // InternalBehaviorAnnexParser.g:8400:2: rule__ForStatement__Group__1__Impl rule__ForStatement__Group__2 + // InternalBehaviorAnnexParser.g:8575:1: ( rule__ForStatement__Group__1__Impl rule__ForStatement__Group__2 ) + // InternalBehaviorAnnexParser.g:8576:2: rule__ForStatement__Group__1__Impl rule__ForStatement__Group__2 { pushFollow(FollowSets000.FOLLOW_4); rule__ForStatement__Group__1__Impl(); @@ -28453,17 +29084,17 @@ public final void rule__ForStatement__Group__1() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__1__Impl" - // InternalBehaviorAnnexParser.g:8407:1: rule__ForStatement__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:8583:1: rule__ForStatement__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__ForStatement__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8411:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:8412:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:8587:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:8588:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:8412:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:8413:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:8588:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:8589:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getLeftParenthesisKeyword_1()); @@ -28494,14 +29125,14 @@ public final void rule__ForStatement__Group__1__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__2" - // InternalBehaviorAnnexParser.g:8422:1: rule__ForStatement__Group__2 : rule__ForStatement__Group__2__Impl rule__ForStatement__Group__3 ; + // InternalBehaviorAnnexParser.g:8598:1: rule__ForStatement__Group__2 : rule__ForStatement__Group__2__Impl rule__ForStatement__Group__3 ; public final void rule__ForStatement__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8426:1: ( rule__ForStatement__Group__2__Impl rule__ForStatement__Group__3 ) - // InternalBehaviorAnnexParser.g:8427:2: rule__ForStatement__Group__2__Impl rule__ForStatement__Group__3 + // InternalBehaviorAnnexParser.g:8602:1: ( rule__ForStatement__Group__2__Impl rule__ForStatement__Group__3 ) + // InternalBehaviorAnnexParser.g:8603:2: rule__ForStatement__Group__2__Impl rule__ForStatement__Group__3 { pushFollow(FollowSets000.FOLLOW_55); rule__ForStatement__Group__2__Impl(); @@ -28532,23 +29163,23 @@ public final void rule__ForStatement__Group__2() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__2__Impl" - // InternalBehaviorAnnexParser.g:8434:1: rule__ForStatement__Group__2__Impl : ( ( rule__ForStatement__VariableAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:8610:1: rule__ForStatement__Group__2__Impl : ( ( rule__ForStatement__VariableAssignment_2 ) ) ; public final void rule__ForStatement__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8438:1: ( ( ( rule__ForStatement__VariableAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:8439:1: ( ( rule__ForStatement__VariableAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:8614:1: ( ( ( rule__ForStatement__VariableAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:8615:1: ( ( rule__ForStatement__VariableAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:8439:1: ( ( rule__ForStatement__VariableAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:8440:2: ( rule__ForStatement__VariableAssignment_2 ) + // InternalBehaviorAnnexParser.g:8615:1: ( ( rule__ForStatement__VariableAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:8616:2: ( rule__ForStatement__VariableAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getVariableAssignment_2()); } - // InternalBehaviorAnnexParser.g:8441:2: ( rule__ForStatement__VariableAssignment_2 ) - // InternalBehaviorAnnexParser.g:8441:3: rule__ForStatement__VariableAssignment_2 + // InternalBehaviorAnnexParser.g:8617:2: ( rule__ForStatement__VariableAssignment_2 ) + // InternalBehaviorAnnexParser.g:8617:3: rule__ForStatement__VariableAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ForStatement__VariableAssignment_2(); @@ -28583,14 +29214,14 @@ public final void rule__ForStatement__Group__2__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__3" - // InternalBehaviorAnnexParser.g:8449:1: rule__ForStatement__Group__3 : rule__ForStatement__Group__3__Impl rule__ForStatement__Group__4 ; + // InternalBehaviorAnnexParser.g:8625:1: rule__ForStatement__Group__3 : rule__ForStatement__Group__3__Impl rule__ForStatement__Group__4 ; public final void rule__ForStatement__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8453:1: ( rule__ForStatement__Group__3__Impl rule__ForStatement__Group__4 ) - // InternalBehaviorAnnexParser.g:8454:2: rule__ForStatement__Group__3__Impl rule__ForStatement__Group__4 + // 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); rule__ForStatement__Group__3__Impl(); @@ -28621,17 +29252,17 @@ public final void rule__ForStatement__Group__3() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__3__Impl" - // InternalBehaviorAnnexParser.g:8461:1: rule__ForStatement__Group__3__Impl : ( Colon ) ; + // InternalBehaviorAnnexParser.g:8637:1: rule__ForStatement__Group__3__Impl : ( Colon ) ; public final void rule__ForStatement__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8465:1: ( ( Colon ) ) - // InternalBehaviorAnnexParser.g:8466:1: ( Colon ) + // InternalBehaviorAnnexParser.g:8641:1: ( ( Colon ) ) + // InternalBehaviorAnnexParser.g:8642:1: ( Colon ) { - // InternalBehaviorAnnexParser.g:8466:1: ( Colon ) - // InternalBehaviorAnnexParser.g:8467:2: Colon + // InternalBehaviorAnnexParser.g:8642:1: ( Colon ) + // InternalBehaviorAnnexParser.g:8643:2: Colon { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getColonKeyword_3()); @@ -28662,14 +29293,14 @@ public final void rule__ForStatement__Group__3__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__4" - // InternalBehaviorAnnexParser.g:8476:1: rule__ForStatement__Group__4 : rule__ForStatement__Group__4__Impl rule__ForStatement__Group__5 ; + // InternalBehaviorAnnexParser.g:8652:1: rule__ForStatement__Group__4 : rule__ForStatement__Group__4__Impl rule__ForStatement__Group__5 ; public final void rule__ForStatement__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8480:1: ( rule__ForStatement__Group__4__Impl rule__ForStatement__Group__5 ) - // InternalBehaviorAnnexParser.g:8481:2: rule__ForStatement__Group__4__Impl rule__ForStatement__Group__5 + // 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); rule__ForStatement__Group__4__Impl(); @@ -28700,23 +29331,23 @@ public final void rule__ForStatement__Group__4() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__4__Impl" - // InternalBehaviorAnnexParser.g:8488:1: rule__ForStatement__Group__4__Impl : ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) ; + // InternalBehaviorAnnexParser.g:8664:1: rule__ForStatement__Group__4__Impl : ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) ; public final void rule__ForStatement__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8492:1: ( ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) ) - // InternalBehaviorAnnexParser.g:8493:1: ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:8668:1: ( ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) ) + // InternalBehaviorAnnexParser.g:8669:1: ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) { - // InternalBehaviorAnnexParser.g:8493:1: ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) - // InternalBehaviorAnnexParser.g:8494:2: ( rule__ForStatement__DataClassifierAssignment_4 ) + // InternalBehaviorAnnexParser.g:8669:1: ( ( rule__ForStatement__DataClassifierAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:8670:2: ( rule__ForStatement__DataClassifierAssignment_4 ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getDataClassifierAssignment_4()); } - // InternalBehaviorAnnexParser.g:8495:2: ( rule__ForStatement__DataClassifierAssignment_4 ) - // InternalBehaviorAnnexParser.g:8495:3: rule__ForStatement__DataClassifierAssignment_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(); @@ -28751,14 +29382,14 @@ public final void rule__ForStatement__Group__4__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__5" - // InternalBehaviorAnnexParser.g:8503:1: rule__ForStatement__Group__5 : rule__ForStatement__Group__5__Impl rule__ForStatement__Group__6 ; + // InternalBehaviorAnnexParser.g:8679:1: rule__ForStatement__Group__5 : rule__ForStatement__Group__5__Impl rule__ForStatement__Group__6 ; public final void rule__ForStatement__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8507:1: ( rule__ForStatement__Group__5__Impl rule__ForStatement__Group__6 ) - // InternalBehaviorAnnexParser.g:8508:2: rule__ForStatement__Group__5__Impl rule__ForStatement__Group__6 + // 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); rule__ForStatement__Group__5__Impl(); @@ -28789,17 +29420,17 @@ public final void rule__ForStatement__Group__5() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__5__Impl" - // InternalBehaviorAnnexParser.g:8515:1: rule__ForStatement__Group__5__Impl : ( In ) ; + // InternalBehaviorAnnexParser.g:8691:1: rule__ForStatement__Group__5__Impl : ( In ) ; public final void rule__ForStatement__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8519:1: ( ( In ) ) - // InternalBehaviorAnnexParser.g:8520:1: ( In ) + // InternalBehaviorAnnexParser.g:8695:1: ( ( In ) ) + // InternalBehaviorAnnexParser.g:8696:1: ( In ) { - // InternalBehaviorAnnexParser.g:8520:1: ( In ) - // InternalBehaviorAnnexParser.g:8521:2: In + // InternalBehaviorAnnexParser.g:8696:1: ( In ) + // InternalBehaviorAnnexParser.g:8697:2: In { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getInKeyword_5()); @@ -28830,14 +29461,14 @@ public final void rule__ForStatement__Group__5__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__6" - // InternalBehaviorAnnexParser.g:8530:1: rule__ForStatement__Group__6 : rule__ForStatement__Group__6__Impl rule__ForStatement__Group__7 ; + // InternalBehaviorAnnexParser.g:8706:1: rule__ForStatement__Group__6 : rule__ForStatement__Group__6__Impl rule__ForStatement__Group__7 ; public final void rule__ForStatement__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8534:1: ( rule__ForStatement__Group__6__Impl rule__ForStatement__Group__7 ) - // InternalBehaviorAnnexParser.g:8535:2: rule__ForStatement__Group__6__Impl rule__ForStatement__Group__7 + // 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); rule__ForStatement__Group__6__Impl(); @@ -28868,23 +29499,23 @@ public final void rule__ForStatement__Group__6() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__6__Impl" - // InternalBehaviorAnnexParser.g:8542:1: rule__ForStatement__Group__6__Impl : ( ( rule__ForStatement__ValuesAssignment_6 ) ) ; + // InternalBehaviorAnnexParser.g:8718:1: rule__ForStatement__Group__6__Impl : ( ( rule__ForStatement__ValuesAssignment_6 ) ) ; public final void rule__ForStatement__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8546:1: ( ( ( rule__ForStatement__ValuesAssignment_6 ) ) ) - // InternalBehaviorAnnexParser.g:8547:1: ( ( rule__ForStatement__ValuesAssignment_6 ) ) + // InternalBehaviorAnnexParser.g:8722:1: ( ( ( rule__ForStatement__ValuesAssignment_6 ) ) ) + // InternalBehaviorAnnexParser.g:8723:1: ( ( rule__ForStatement__ValuesAssignment_6 ) ) { - // InternalBehaviorAnnexParser.g:8547:1: ( ( rule__ForStatement__ValuesAssignment_6 ) ) - // InternalBehaviorAnnexParser.g:8548:2: ( rule__ForStatement__ValuesAssignment_6 ) + // InternalBehaviorAnnexParser.g:8723:1: ( ( rule__ForStatement__ValuesAssignment_6 ) ) + // InternalBehaviorAnnexParser.g:8724:2: ( rule__ForStatement__ValuesAssignment_6 ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getValuesAssignment_6()); } - // InternalBehaviorAnnexParser.g:8549:2: ( rule__ForStatement__ValuesAssignment_6 ) - // InternalBehaviorAnnexParser.g:8549:3: rule__ForStatement__ValuesAssignment_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(); @@ -28919,14 +29550,14 @@ public final void rule__ForStatement__Group__6__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__7" - // InternalBehaviorAnnexParser.g:8557:1: rule__ForStatement__Group__7 : rule__ForStatement__Group__7__Impl rule__ForStatement__Group__8 ; + // InternalBehaviorAnnexParser.g:8733:1: rule__ForStatement__Group__7 : rule__ForStatement__Group__7__Impl rule__ForStatement__Group__8 ; public final void rule__ForStatement__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8561:1: ( rule__ForStatement__Group__7__Impl rule__ForStatement__Group__8 ) - // InternalBehaviorAnnexParser.g:8562:2: rule__ForStatement__Group__7__Impl rule__ForStatement__Group__8 + // 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); rule__ForStatement__Group__7__Impl(); @@ -28957,17 +29588,17 @@ public final void rule__ForStatement__Group__7() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__7__Impl" - // InternalBehaviorAnnexParser.g:8569:1: rule__ForStatement__Group__7__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:8745:1: rule__ForStatement__Group__7__Impl : ( RightParenthesis ) ; public final void rule__ForStatement__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8573:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:8574:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8749:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:8750:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:8574:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:8575:2: RightParenthesis + // InternalBehaviorAnnexParser.g:8750:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8751:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_7()); @@ -28998,14 +29629,14 @@ public final void rule__ForStatement__Group__7__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__8" - // InternalBehaviorAnnexParser.g:8584:1: rule__ForStatement__Group__8 : rule__ForStatement__Group__8__Impl rule__ForStatement__Group__9 ; + // InternalBehaviorAnnexParser.g:8760:1: rule__ForStatement__Group__8 : rule__ForStatement__Group__8__Impl rule__ForStatement__Group__9 ; public final void rule__ForStatement__Group__8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8588:1: ( rule__ForStatement__Group__8__Impl rule__ForStatement__Group__9 ) - // InternalBehaviorAnnexParser.g:8589:2: rule__ForStatement__Group__8__Impl rule__ForStatement__Group__9 + // 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); rule__ForStatement__Group__8__Impl(); @@ -29036,17 +29667,17 @@ public final void rule__ForStatement__Group__8() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__8__Impl" - // InternalBehaviorAnnexParser.g:8596:1: rule__ForStatement__Group__8__Impl : ( LeftCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:8772:1: rule__ForStatement__Group__8__Impl : ( LeftCurlyBracket ) ; public final void rule__ForStatement__Group__8__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8600:1: ( ( LeftCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:8601:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:8776:1: ( ( LeftCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:8777:1: ( LeftCurlyBracket ) { - // InternalBehaviorAnnexParser.g:8601:1: ( LeftCurlyBracket ) - // InternalBehaviorAnnexParser.g:8602:2: LeftCurlyBracket + // InternalBehaviorAnnexParser.g:8777:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:8778:2: LeftCurlyBracket { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getLeftCurlyBracketKeyword_8()); @@ -29077,14 +29708,14 @@ public final void rule__ForStatement__Group__8__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__9" - // InternalBehaviorAnnexParser.g:8611: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 rule__ForStatement__Group__10 ; public final void rule__ForStatement__Group__9() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8615:1: ( rule__ForStatement__Group__9__Impl rule__ForStatement__Group__10 ) - // InternalBehaviorAnnexParser.g:8616:2: rule__ForStatement__Group__9__Impl rule__ForStatement__Group__10 + // 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 { pushFollow(FollowSets000.FOLLOW_10); rule__ForStatement__Group__9__Impl(); @@ -29115,23 +29746,23 @@ public final void rule__ForStatement__Group__9() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__9__Impl" - // InternalBehaviorAnnexParser.g:8623:1: rule__ForStatement__Group__9__Impl : ( ( rule__ForStatement__ActionsAssignment_9 ) ) ; + // InternalBehaviorAnnexParser.g:8799:1: rule__ForStatement__Group__9__Impl : ( ( rule__ForStatement__ActionsAssignment_9 ) ) ; public final void rule__ForStatement__Group__9__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8627:1: ( ( ( rule__ForStatement__ActionsAssignment_9 ) ) ) - // InternalBehaviorAnnexParser.g:8628:1: ( ( rule__ForStatement__ActionsAssignment_9 ) ) + // InternalBehaviorAnnexParser.g:8803:1: ( ( ( rule__ForStatement__ActionsAssignment_9 ) ) ) + // InternalBehaviorAnnexParser.g:8804:1: ( ( rule__ForStatement__ActionsAssignment_9 ) ) { - // InternalBehaviorAnnexParser.g:8628:1: ( ( rule__ForStatement__ActionsAssignment_9 ) ) - // InternalBehaviorAnnexParser.g:8629:2: ( rule__ForStatement__ActionsAssignment_9 ) + // InternalBehaviorAnnexParser.g:8804:1: ( ( rule__ForStatement__ActionsAssignment_9 ) ) + // InternalBehaviorAnnexParser.g:8805:2: ( rule__ForStatement__ActionsAssignment_9 ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getActionsAssignment_9()); } - // InternalBehaviorAnnexParser.g:8630:2: ( rule__ForStatement__ActionsAssignment_9 ) - // InternalBehaviorAnnexParser.g:8630:3: rule__ForStatement__ActionsAssignment_9 + // InternalBehaviorAnnexParser.g:8806:2: ( rule__ForStatement__ActionsAssignment_9 ) + // InternalBehaviorAnnexParser.g:8806:3: rule__ForStatement__ActionsAssignment_9 { pushFollow(FollowSets000.FOLLOW_2); rule__ForStatement__ActionsAssignment_9(); @@ -29166,14 +29797,14 @@ public final void rule__ForStatement__Group__9__Impl() throws RecognitionExcepti // $ANTLR start "rule__ForStatement__Group__10" - // InternalBehaviorAnnexParser.g:8638:1: rule__ForStatement__Group__10 : rule__ForStatement__Group__10__Impl ; + // InternalBehaviorAnnexParser.g:8814:1: rule__ForStatement__Group__10 : rule__ForStatement__Group__10__Impl ; public final void rule__ForStatement__Group__10() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8642:1: ( rule__ForStatement__Group__10__Impl ) - // InternalBehaviorAnnexParser.g:8643:2: rule__ForStatement__Group__10__Impl + // InternalBehaviorAnnexParser.g:8818:1: ( rule__ForStatement__Group__10__Impl ) + // InternalBehaviorAnnexParser.g:8819:2: rule__ForStatement__Group__10__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ForStatement__Group__10__Impl(); @@ -29199,17 +29830,17 @@ public final void rule__ForStatement__Group__10() throws RecognitionException { // $ANTLR start "rule__ForStatement__Group__10__Impl" - // InternalBehaviorAnnexParser.g:8649:1: rule__ForStatement__Group__10__Impl : ( RightCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:8825:1: rule__ForStatement__Group__10__Impl : ( RightCurlyBracket ) ; public final void rule__ForStatement__Group__10__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8653:1: ( ( RightCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:8654:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:8829:1: ( ( RightCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:8830:1: ( RightCurlyBracket ) { - // InternalBehaviorAnnexParser.g:8654:1: ( RightCurlyBracket ) - // InternalBehaviorAnnexParser.g:8655:2: RightCurlyBracket + // InternalBehaviorAnnexParser.g:8830:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:8831:2: RightCurlyBracket { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getRightCurlyBracketKeyword_10()); @@ -29240,14 +29871,14 @@ public final void rule__ForStatement__Group__10__Impl() throws RecognitionExcept // $ANTLR start "rule__WhileStatement__Group__0" - // InternalBehaviorAnnexParser.g:8665:1: rule__WhileStatement__Group__0 : rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 ; + // InternalBehaviorAnnexParser.g:8841: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:8669:1: ( rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 ) - // InternalBehaviorAnnexParser.g:8670:2: rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_27); rule__WhileStatement__Group__0__Impl(); @@ -29278,17 +29909,17 @@ public final void rule__WhileStatement__Group__0() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__0__Impl" - // InternalBehaviorAnnexParser.g:8677:1: rule__WhileStatement__Group__0__Impl : ( While ) ; + // InternalBehaviorAnnexParser.g:8853:1: rule__WhileStatement__Group__0__Impl : ( While ) ; public final void rule__WhileStatement__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8681:1: ( ( While ) ) - // InternalBehaviorAnnexParser.g:8682:1: ( While ) + // InternalBehaviorAnnexParser.g:8857:1: ( ( While ) ) + // InternalBehaviorAnnexParser.g:8858:1: ( While ) { - // InternalBehaviorAnnexParser.g:8682:1: ( While ) - // InternalBehaviorAnnexParser.g:8683:2: While + // InternalBehaviorAnnexParser.g:8858:1: ( While ) + // InternalBehaviorAnnexParser.g:8859:2: While { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); @@ -29319,14 +29950,14 @@ public final void rule__WhileStatement__Group__0__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__1" - // InternalBehaviorAnnexParser.g:8692:1: rule__WhileStatement__Group__1 : rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 ; + // InternalBehaviorAnnexParser.g:8868: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:8696:1: ( rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 ) - // InternalBehaviorAnnexParser.g:8697:2: rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_47); rule__WhileStatement__Group__1__Impl(); @@ -29357,17 +29988,17 @@ public final void rule__WhileStatement__Group__1() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__1__Impl" - // InternalBehaviorAnnexParser.g:8704:1: rule__WhileStatement__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:8880:1: rule__WhileStatement__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__WhileStatement__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8708:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:8709:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:8884:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:8885:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:8709:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:8710:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:8885:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:8886:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); @@ -29398,14 +30029,14 @@ public final void rule__WhileStatement__Group__1__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__2" - // InternalBehaviorAnnexParser.g:8719:1: rule__WhileStatement__Group__2 : rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 ; + // InternalBehaviorAnnexParser.g:8895: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:8723:1: ( rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 ) - // InternalBehaviorAnnexParser.g:8724:2: rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 + // 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 { pushFollow(FollowSets000.FOLLOW_37); rule__WhileStatement__Group__2__Impl(); @@ -29436,23 +30067,23 @@ public final void rule__WhileStatement__Group__2() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__2__Impl" - // InternalBehaviorAnnexParser.g:8731:1: rule__WhileStatement__Group__2__Impl : ( ( rule__WhileStatement__ConditionAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:8907: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:8735:1: ( ( ( rule__WhileStatement__ConditionAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:8736:1: ( ( rule__WhileStatement__ConditionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:8911:1: ( ( ( rule__WhileStatement__ConditionAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:8912:1: ( ( rule__WhileStatement__ConditionAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:8736:1: ( ( rule__WhileStatement__ConditionAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:8737:2: ( rule__WhileStatement__ConditionAssignment_2 ) + // InternalBehaviorAnnexParser.g:8912:1: ( ( rule__WhileStatement__ConditionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:8913:2: ( rule__WhileStatement__ConditionAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getConditionAssignment_2()); } - // InternalBehaviorAnnexParser.g:8738:2: ( rule__WhileStatement__ConditionAssignment_2 ) - // InternalBehaviorAnnexParser.g:8738:3: rule__WhileStatement__ConditionAssignment_2 + // InternalBehaviorAnnexParser.g:8914:2: ( rule__WhileStatement__ConditionAssignment_2 ) + // InternalBehaviorAnnexParser.g:8914:3: rule__WhileStatement__ConditionAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__WhileStatement__ConditionAssignment_2(); @@ -29487,14 +30118,14 @@ public final void rule__WhileStatement__Group__2__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__3" - // InternalBehaviorAnnexParser.g:8746:1: rule__WhileStatement__Group__3 : rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 ; + // InternalBehaviorAnnexParser.g:8922: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:8750:1: ( rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 ) - // InternalBehaviorAnnexParser.g:8751:2: rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 + // 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 { pushFollow(FollowSets000.FOLLOW_56); rule__WhileStatement__Group__3__Impl(); @@ -29525,17 +30156,17 @@ public final void rule__WhileStatement__Group__3() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__3__Impl" - // InternalBehaviorAnnexParser.g:8758:1: rule__WhileStatement__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:8934:1: rule__WhileStatement__Group__3__Impl : ( RightParenthesis ) ; public final void rule__WhileStatement__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8762:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:8763:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8938:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:8939:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:8763:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:8764:2: RightParenthesis + // InternalBehaviorAnnexParser.g:8939:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:8940:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); @@ -29566,14 +30197,14 @@ public final void rule__WhileStatement__Group__3__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__4" - // InternalBehaviorAnnexParser.g:8773:1: rule__WhileStatement__Group__4 : rule__WhileStatement__Group__4__Impl rule__WhileStatement__Group__5 ; + // InternalBehaviorAnnexParser.g:8949: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:8777:1: ( rule__WhileStatement__Group__4__Impl rule__WhileStatement__Group__5 ) - // InternalBehaviorAnnexParser.g:8778:2: rule__WhileStatement__Group__4__Impl rule__WhileStatement__Group__5 + // 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 { pushFollow(FollowSets000.FOLLOW_38); rule__WhileStatement__Group__4__Impl(); @@ -29604,17 +30235,17 @@ public final void rule__WhileStatement__Group__4() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__4__Impl" - // InternalBehaviorAnnexParser.g:8785:1: rule__WhileStatement__Group__4__Impl : ( LeftCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:8961:1: rule__WhileStatement__Group__4__Impl : ( LeftCurlyBracket ) ; public final void rule__WhileStatement__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8789:1: ( ( LeftCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:8790:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:8965:1: ( ( LeftCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:8966:1: ( LeftCurlyBracket ) { - // InternalBehaviorAnnexParser.g:8790:1: ( LeftCurlyBracket ) - // InternalBehaviorAnnexParser.g:8791:2: LeftCurlyBracket + // InternalBehaviorAnnexParser.g:8966:1: ( LeftCurlyBracket ) + // InternalBehaviorAnnexParser.g:8967:2: LeftCurlyBracket { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getLeftCurlyBracketKeyword_4()); @@ -29645,14 +30276,14 @@ public final void rule__WhileStatement__Group__4__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__5" - // InternalBehaviorAnnexParser.g:8800:1: rule__WhileStatement__Group__5 : rule__WhileStatement__Group__5__Impl rule__WhileStatement__Group__6 ; + // InternalBehaviorAnnexParser.g:8976: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:8804:1: ( rule__WhileStatement__Group__5__Impl rule__WhileStatement__Group__6 ) - // InternalBehaviorAnnexParser.g:8805:2: rule__WhileStatement__Group__5__Impl rule__WhileStatement__Group__6 + // 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 { pushFollow(FollowSets000.FOLLOW_10); rule__WhileStatement__Group__5__Impl(); @@ -29683,23 +30314,23 @@ public final void rule__WhileStatement__Group__5() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__5__Impl" - // InternalBehaviorAnnexParser.g:8812:1: rule__WhileStatement__Group__5__Impl : ( ( rule__WhileStatement__ActionsAssignment_5 ) ) ; + // InternalBehaviorAnnexParser.g:8988: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:8816:1: ( ( ( rule__WhileStatement__ActionsAssignment_5 ) ) ) - // InternalBehaviorAnnexParser.g:8817:1: ( ( rule__WhileStatement__ActionsAssignment_5 ) ) + // InternalBehaviorAnnexParser.g:8992:1: ( ( ( rule__WhileStatement__ActionsAssignment_5 ) ) ) + // InternalBehaviorAnnexParser.g:8993:1: ( ( rule__WhileStatement__ActionsAssignment_5 ) ) { - // InternalBehaviorAnnexParser.g:8817:1: ( ( rule__WhileStatement__ActionsAssignment_5 ) ) - // InternalBehaviorAnnexParser.g:8818:2: ( rule__WhileStatement__ActionsAssignment_5 ) + // InternalBehaviorAnnexParser.g:8993:1: ( ( rule__WhileStatement__ActionsAssignment_5 ) ) + // InternalBehaviorAnnexParser.g:8994:2: ( rule__WhileStatement__ActionsAssignment_5 ) { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getActionsAssignment_5()); } - // InternalBehaviorAnnexParser.g:8819:2: ( rule__WhileStatement__ActionsAssignment_5 ) - // InternalBehaviorAnnexParser.g:8819:3: rule__WhileStatement__ActionsAssignment_5 + // InternalBehaviorAnnexParser.g:8995:2: ( rule__WhileStatement__ActionsAssignment_5 ) + // InternalBehaviorAnnexParser.g:8995:3: rule__WhileStatement__ActionsAssignment_5 { pushFollow(FollowSets000.FOLLOW_2); rule__WhileStatement__ActionsAssignment_5(); @@ -29734,14 +30365,14 @@ public final void rule__WhileStatement__Group__5__Impl() throws RecognitionExcep // $ANTLR start "rule__WhileStatement__Group__6" - // InternalBehaviorAnnexParser.g:8827:1: rule__WhileStatement__Group__6 : rule__WhileStatement__Group__6__Impl ; + // InternalBehaviorAnnexParser.g:9003: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:8831:1: ( rule__WhileStatement__Group__6__Impl ) - // InternalBehaviorAnnexParser.g:8832:2: rule__WhileStatement__Group__6__Impl + // InternalBehaviorAnnexParser.g:9007:1: ( rule__WhileStatement__Group__6__Impl ) + // InternalBehaviorAnnexParser.g:9008:2: rule__WhileStatement__Group__6__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__WhileStatement__Group__6__Impl(); @@ -29767,17 +30398,17 @@ public final void rule__WhileStatement__Group__6() throws RecognitionException { // $ANTLR start "rule__WhileStatement__Group__6__Impl" - // InternalBehaviorAnnexParser.g:8838:1: rule__WhileStatement__Group__6__Impl : ( RightCurlyBracket ) ; + // InternalBehaviorAnnexParser.g:9014:1: rule__WhileStatement__Group__6__Impl : ( RightCurlyBracket ) ; public final void rule__WhileStatement__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8842:1: ( ( RightCurlyBracket ) ) - // InternalBehaviorAnnexParser.g:8843:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:9018:1: ( ( RightCurlyBracket ) ) + // InternalBehaviorAnnexParser.g:9019:1: ( RightCurlyBracket ) { - // InternalBehaviorAnnexParser.g:8843:1: ( RightCurlyBracket ) - // InternalBehaviorAnnexParser.g:8844:2: RightCurlyBracket + // InternalBehaviorAnnexParser.g:9019:1: ( RightCurlyBracket ) + // InternalBehaviorAnnexParser.g:9020:2: RightCurlyBracket { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getRightCurlyBracketKeyword_6()); @@ -29808,14 +30439,14 @@ public final void rule__WhileStatement__Group__6__Impl() throws RecognitionExcep // $ANTLR start "rule__DoUntilStatement__Group__0" - // InternalBehaviorAnnexParser.g:8854:1: rule__DoUntilStatement__Group__0 : rule__DoUntilStatement__Group__0__Impl rule__DoUntilStatement__Group__1 ; + // InternalBehaviorAnnexParser.g:9030: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:8858:1: ( rule__DoUntilStatement__Group__0__Impl rule__DoUntilStatement__Group__1 ) - // InternalBehaviorAnnexParser.g:8859:2: rule__DoUntilStatement__Group__0__Impl rule__DoUntilStatement__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_38); rule__DoUntilStatement__Group__0__Impl(); @@ -29846,17 +30477,17 @@ public final void rule__DoUntilStatement__Group__0() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__0__Impl" - // InternalBehaviorAnnexParser.g:8866:1: rule__DoUntilStatement__Group__0__Impl : ( Do ) ; + // InternalBehaviorAnnexParser.g:9042:1: rule__DoUntilStatement__Group__0__Impl : ( Do ) ; public final void rule__DoUntilStatement__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8870:1: ( ( Do ) ) - // InternalBehaviorAnnexParser.g:8871:1: ( Do ) + // InternalBehaviorAnnexParser.g:9046:1: ( ( Do ) ) + // InternalBehaviorAnnexParser.g:9047:1: ( Do ) { - // InternalBehaviorAnnexParser.g:8871:1: ( Do ) - // InternalBehaviorAnnexParser.g:8872:2: Do + // InternalBehaviorAnnexParser.g:9047:1: ( Do ) + // InternalBehaviorAnnexParser.g:9048:2: Do { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getDoKeyword_0()); @@ -29887,14 +30518,14 @@ public final void rule__DoUntilStatement__Group__0__Impl() throws RecognitionExc // $ANTLR start "rule__DoUntilStatement__Group__1" - // InternalBehaviorAnnexParser.g:8881:1: rule__DoUntilStatement__Group__1 : rule__DoUntilStatement__Group__1__Impl rule__DoUntilStatement__Group__2 ; + // InternalBehaviorAnnexParser.g:9057: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:8885:1: ( rule__DoUntilStatement__Group__1__Impl rule__DoUntilStatement__Group__2 ) - // InternalBehaviorAnnexParser.g:8886:2: rule__DoUntilStatement__Group__1__Impl rule__DoUntilStatement__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_57); rule__DoUntilStatement__Group__1__Impl(); @@ -29925,23 +30556,23 @@ public final void rule__DoUntilStatement__Group__1() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__1__Impl" - // InternalBehaviorAnnexParser.g:8893:1: rule__DoUntilStatement__Group__1__Impl : ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:9069: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:8897:1: ( ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:8898:1: ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:9073:1: ( ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:9074:1: ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:8898:1: ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:8899:2: ( rule__DoUntilStatement__ActionsAssignment_1 ) + // InternalBehaviorAnnexParser.g:9074:1: ( ( rule__DoUntilStatement__ActionsAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:9075:2: ( rule__DoUntilStatement__ActionsAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getActionsAssignment_1()); } - // InternalBehaviorAnnexParser.g:8900:2: ( rule__DoUntilStatement__ActionsAssignment_1 ) - // InternalBehaviorAnnexParser.g:8900:3: rule__DoUntilStatement__ActionsAssignment_1 + // InternalBehaviorAnnexParser.g:9076:2: ( rule__DoUntilStatement__ActionsAssignment_1 ) + // InternalBehaviorAnnexParser.g:9076:3: rule__DoUntilStatement__ActionsAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__DoUntilStatement__ActionsAssignment_1(); @@ -29976,14 +30607,14 @@ public final void rule__DoUntilStatement__Group__1__Impl() throws RecognitionExc // $ANTLR start "rule__DoUntilStatement__Group__2" - // InternalBehaviorAnnexParser.g:8908:1: rule__DoUntilStatement__Group__2 : rule__DoUntilStatement__Group__2__Impl rule__DoUntilStatement__Group__3 ; + // InternalBehaviorAnnexParser.g:9084: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:8912:1: ( rule__DoUntilStatement__Group__2__Impl rule__DoUntilStatement__Group__3 ) - // InternalBehaviorAnnexParser.g:8913:2: rule__DoUntilStatement__Group__2__Impl rule__DoUntilStatement__Group__3 + // 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 { pushFollow(FollowSets000.FOLLOW_27); rule__DoUntilStatement__Group__2__Impl(); @@ -30014,17 +30645,17 @@ public final void rule__DoUntilStatement__Group__2() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__2__Impl" - // InternalBehaviorAnnexParser.g:8920:1: rule__DoUntilStatement__Group__2__Impl : ( Until ) ; + // InternalBehaviorAnnexParser.g:9096:1: rule__DoUntilStatement__Group__2__Impl : ( Until ) ; public final void rule__DoUntilStatement__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8924:1: ( ( Until ) ) - // InternalBehaviorAnnexParser.g:8925:1: ( Until ) + // InternalBehaviorAnnexParser.g:9100:1: ( ( Until ) ) + // InternalBehaviorAnnexParser.g:9101:1: ( Until ) { - // InternalBehaviorAnnexParser.g:8925:1: ( Until ) - // InternalBehaviorAnnexParser.g:8926:2: Until + // InternalBehaviorAnnexParser.g:9101:1: ( Until ) + // InternalBehaviorAnnexParser.g:9102:2: Until { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getUntilKeyword_2()); @@ -30055,14 +30686,14 @@ public final void rule__DoUntilStatement__Group__2__Impl() throws RecognitionExc // $ANTLR start "rule__DoUntilStatement__Group__3" - // InternalBehaviorAnnexParser.g:8935:1: rule__DoUntilStatement__Group__3 : rule__DoUntilStatement__Group__3__Impl rule__DoUntilStatement__Group__4 ; + // InternalBehaviorAnnexParser.g:9111: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:8939:1: ( rule__DoUntilStatement__Group__3__Impl rule__DoUntilStatement__Group__4 ) - // InternalBehaviorAnnexParser.g:8940:2: rule__DoUntilStatement__Group__3__Impl rule__DoUntilStatement__Group__4 + // 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 { pushFollow(FollowSets000.FOLLOW_47); rule__DoUntilStatement__Group__3__Impl(); @@ -30093,17 +30724,17 @@ public final void rule__DoUntilStatement__Group__3() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__3__Impl" - // InternalBehaviorAnnexParser.g:8947:1: rule__DoUntilStatement__Group__3__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:9123:1: rule__DoUntilStatement__Group__3__Impl : ( LeftParenthesis ) ; public final void rule__DoUntilStatement__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:8951:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:8952:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:9127:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:9128:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:8952:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:8953:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:9128:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:9129:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getLeftParenthesisKeyword_3()); @@ -30134,14 +30765,14 @@ public final void rule__DoUntilStatement__Group__3__Impl() throws RecognitionExc // $ANTLR start "rule__DoUntilStatement__Group__4" - // InternalBehaviorAnnexParser.g:8962:1: rule__DoUntilStatement__Group__4 : rule__DoUntilStatement__Group__4__Impl rule__DoUntilStatement__Group__5 ; + // InternalBehaviorAnnexParser.g:9138: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:8966:1: ( rule__DoUntilStatement__Group__4__Impl rule__DoUntilStatement__Group__5 ) - // InternalBehaviorAnnexParser.g:8967:2: rule__DoUntilStatement__Group__4__Impl rule__DoUntilStatement__Group__5 + // 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 { pushFollow(FollowSets000.FOLLOW_37); rule__DoUntilStatement__Group__4__Impl(); @@ -30172,23 +30803,23 @@ public final void rule__DoUntilStatement__Group__4() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__4__Impl" - // InternalBehaviorAnnexParser.g:8974:1: rule__DoUntilStatement__Group__4__Impl : ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) ; + // InternalBehaviorAnnexParser.g:9150: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:8978:1: ( ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) ) - // InternalBehaviorAnnexParser.g:8979:1: ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:9154:1: ( ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) ) + // InternalBehaviorAnnexParser.g:9155:1: ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) { - // InternalBehaviorAnnexParser.g:8979:1: ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) - // InternalBehaviorAnnexParser.g:8980:2: ( rule__DoUntilStatement__ConditionAssignment_4 ) + // InternalBehaviorAnnexParser.g:9155:1: ( ( rule__DoUntilStatement__ConditionAssignment_4 ) ) + // InternalBehaviorAnnexParser.g:9156:2: ( rule__DoUntilStatement__ConditionAssignment_4 ) { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getConditionAssignment_4()); } - // InternalBehaviorAnnexParser.g:8981:2: ( rule__DoUntilStatement__ConditionAssignment_4 ) - // InternalBehaviorAnnexParser.g:8981:3: rule__DoUntilStatement__ConditionAssignment_4 + // InternalBehaviorAnnexParser.g:9157:2: ( rule__DoUntilStatement__ConditionAssignment_4 ) + // InternalBehaviorAnnexParser.g:9157:3: rule__DoUntilStatement__ConditionAssignment_4 { pushFollow(FollowSets000.FOLLOW_2); rule__DoUntilStatement__ConditionAssignment_4(); @@ -30223,14 +30854,14 @@ public final void rule__DoUntilStatement__Group__4__Impl() throws RecognitionExc // $ANTLR start "rule__DoUntilStatement__Group__5" - // InternalBehaviorAnnexParser.g:8989:1: rule__DoUntilStatement__Group__5 : rule__DoUntilStatement__Group__5__Impl ; + // InternalBehaviorAnnexParser.g:9165: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:8993:1: ( rule__DoUntilStatement__Group__5__Impl ) - // InternalBehaviorAnnexParser.g:8994:2: rule__DoUntilStatement__Group__5__Impl + // InternalBehaviorAnnexParser.g:9169:1: ( rule__DoUntilStatement__Group__5__Impl ) + // InternalBehaviorAnnexParser.g:9170:2: rule__DoUntilStatement__Group__5__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__DoUntilStatement__Group__5__Impl(); @@ -30256,17 +30887,17 @@ public final void rule__DoUntilStatement__Group__5() throws RecognitionException // $ANTLR start "rule__DoUntilStatement__Group__5__Impl" - // InternalBehaviorAnnexParser.g:9000:1: rule__DoUntilStatement__Group__5__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:9176:1: rule__DoUntilStatement__Group__5__Impl : ( RightParenthesis ) ; public final void rule__DoUntilStatement__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9004:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:9005:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:9180:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:9181:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:9005:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:9006:2: RightParenthesis + // InternalBehaviorAnnexParser.g:9181:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:9182:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getRightParenthesisKeyword_5()); @@ -30297,14 +30928,14 @@ public final void rule__DoUntilStatement__Group__5__Impl() throws RecognitionExc // $ANTLR start "rule__ElementValues__Group__0" - // InternalBehaviorAnnexParser.g:9016:1: rule__ElementValues__Group__0 : rule__ElementValues__Group__0__Impl rule__ElementValues__Group__1 ; + // InternalBehaviorAnnexParser.g:9192: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:9020:1: ( rule__ElementValues__Group__0__Impl rule__ElementValues__Group__1 ) - // InternalBehaviorAnnexParser.g:9021:2: rule__ElementValues__Group__0__Impl rule__ElementValues__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_58); rule__ElementValues__Group__0__Impl(); @@ -30335,23 +30966,23 @@ public final void rule__ElementValues__Group__0() throws RecognitionException { // $ANTLR start "rule__ElementValues__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9028:1: rule__ElementValues__Group__0__Impl : ( ( rule__ElementValues__LowerAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:9204: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:9032:1: ( ( ( rule__ElementValues__LowerAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:9033:1: ( ( rule__ElementValues__LowerAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:9208:1: ( ( ( rule__ElementValues__LowerAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:9209:1: ( ( rule__ElementValues__LowerAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:9033:1: ( ( rule__ElementValues__LowerAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:9034:2: ( rule__ElementValues__LowerAssignment_0 ) + // InternalBehaviorAnnexParser.g:9209:1: ( ( rule__ElementValues__LowerAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:9210:2: ( rule__ElementValues__LowerAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getLowerAssignment_0()); } - // InternalBehaviorAnnexParser.g:9035:2: ( rule__ElementValues__LowerAssignment_0 ) - // InternalBehaviorAnnexParser.g:9035:3: rule__ElementValues__LowerAssignment_0 + // InternalBehaviorAnnexParser.g:9211:2: ( rule__ElementValues__LowerAssignment_0 ) + // InternalBehaviorAnnexParser.g:9211:3: rule__ElementValues__LowerAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ElementValues__LowerAssignment_0(); @@ -30386,14 +31017,14 @@ public final void rule__ElementValues__Group__0__Impl() throws RecognitionExcept // $ANTLR start "rule__ElementValues__Group__1" - // InternalBehaviorAnnexParser.g:9043:1: rule__ElementValues__Group__1 : rule__ElementValues__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:9219: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:9047:1: ( rule__ElementValues__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9048:2: rule__ElementValues__Group__1__Impl + // InternalBehaviorAnnexParser.g:9223:1: ( rule__ElementValues__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9224:2: rule__ElementValues__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ElementValues__Group__1__Impl(); @@ -30419,31 +31050,31 @@ public final void rule__ElementValues__Group__1() throws RecognitionException { // $ANTLR start "rule__ElementValues__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9054:1: rule__ElementValues__Group__1__Impl : ( ( rule__ElementValues__Group_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:9230: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:9058:1: ( ( ( rule__ElementValues__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:9059:1: ( ( rule__ElementValues__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:9234:1: ( ( ( rule__ElementValues__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:9235:1: ( ( rule__ElementValues__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:9059:1: ( ( rule__ElementValues__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:9060:2: ( rule__ElementValues__Group_1__0 )? + // InternalBehaviorAnnexParser.g:9235:1: ( ( rule__ElementValues__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:9236:2: ( rule__ElementValues__Group_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:9061:2: ( rule__ElementValues__Group_1__0 )? - int alt79=2; - int LA79_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:9237:2: ( rule__ElementValues__Group_1__0 )? + int alt82=2; + int LA82_0 = input.LA(1); - if ( (LA79_0==FullStopFullStop) ) { - alt79=1; + if ( (LA82_0==FullStopFullStop) ) { + alt82=1; } - switch (alt79) { + switch (alt82) { case 1 : - // InternalBehaviorAnnexParser.g:9061:3: rule__ElementValues__Group_1__0 + // InternalBehaviorAnnexParser.g:9237:3: rule__ElementValues__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ElementValues__Group_1__0(); @@ -30481,14 +31112,14 @@ public final void rule__ElementValues__Group__1__Impl() throws RecognitionExcept // $ANTLR start "rule__ElementValues__Group_1__0" - // InternalBehaviorAnnexParser.g:9070:1: rule__ElementValues__Group_1__0 : rule__ElementValues__Group_1__0__Impl rule__ElementValues__Group_1__1 ; + // InternalBehaviorAnnexParser.g:9246: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:9074:1: ( rule__ElementValues__Group_1__0__Impl rule__ElementValues__Group_1__1 ) - // InternalBehaviorAnnexParser.g:9075:2: rule__ElementValues__Group_1__0__Impl rule__ElementValues__Group_1__1 + // 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 { pushFollow(FollowSets000.FOLLOW_13); rule__ElementValues__Group_1__0__Impl(); @@ -30519,17 +31150,17 @@ public final void rule__ElementValues__Group_1__0() throws RecognitionException // $ANTLR start "rule__ElementValues__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:9082:1: rule__ElementValues__Group_1__0__Impl : ( FullStopFullStop ) ; + // InternalBehaviorAnnexParser.g:9258: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:9086:1: ( ( FullStopFullStop ) ) - // InternalBehaviorAnnexParser.g:9087:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:9262:1: ( ( FullStopFullStop ) ) + // InternalBehaviorAnnexParser.g:9263:1: ( FullStopFullStop ) { - // InternalBehaviorAnnexParser.g:9087:1: ( FullStopFullStop ) - // InternalBehaviorAnnexParser.g:9088:2: FullStopFullStop + // InternalBehaviorAnnexParser.g:9263:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:9264:2: FullStopFullStop { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getFullStopFullStopKeyword_1_0()); @@ -30560,14 +31191,14 @@ public final void rule__ElementValues__Group_1__0__Impl() throws RecognitionExce // $ANTLR start "rule__ElementValues__Group_1__1" - // InternalBehaviorAnnexParser.g:9097:1: rule__ElementValues__Group_1__1 : rule__ElementValues__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:9273: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:9101:1: ( rule__ElementValues__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:9102:2: rule__ElementValues__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:9277:1: ( rule__ElementValues__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:9278:2: rule__ElementValues__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ElementValues__Group_1__1__Impl(); @@ -30593,23 +31224,23 @@ public final void rule__ElementValues__Group_1__1() throws RecognitionException // $ANTLR start "rule__ElementValues__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:9108:1: rule__ElementValues__Group_1__1__Impl : ( ( rule__ElementValues__UpperAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:9284: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:9112:1: ( ( ( rule__ElementValues__UpperAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:9113:1: ( ( rule__ElementValues__UpperAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9288:1: ( ( ( rule__ElementValues__UpperAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:9289:1: ( ( rule__ElementValues__UpperAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:9113:1: ( ( rule__ElementValues__UpperAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:9114:2: ( rule__ElementValues__UpperAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9289:1: ( ( rule__ElementValues__UpperAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9290:2: ( rule__ElementValues__UpperAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getUpperAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:9115:2: ( rule__ElementValues__UpperAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:9115:3: rule__ElementValues__UpperAssignment_1_1 + // InternalBehaviorAnnexParser.g:9291:2: ( rule__ElementValues__UpperAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9291:3: rule__ElementValues__UpperAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ElementValues__UpperAssignment_1_1(); @@ -30644,14 +31275,14 @@ public final void rule__ElementValues__Group_1__1__Impl() throws RecognitionExce // $ANTLR start "rule__BehaviorTime__Group__0" - // InternalBehaviorAnnexParser.g:9124:1: rule__BehaviorTime__Group__0 : rule__BehaviorTime__Group__0__Impl rule__BehaviorTime__Group__1 ; + // InternalBehaviorAnnexParser.g:9300: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:9128:1: ( rule__BehaviorTime__Group__0__Impl rule__BehaviorTime__Group__1 ) - // InternalBehaviorAnnexParser.g:9129:2: rule__BehaviorTime__Group__0__Impl rule__BehaviorTime__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__BehaviorTime__Group__0__Impl(); @@ -30682,23 +31313,23 @@ public final void rule__BehaviorTime__Group__0() throws RecognitionException { // $ANTLR start "rule__BehaviorTime__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9136:1: rule__BehaviorTime__Group__0__Impl : ( ( rule__BehaviorTime__ValueAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:9312: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:9140:1: ( ( ( rule__BehaviorTime__ValueAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:9141:1: ( ( rule__BehaviorTime__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:9316:1: ( ( ( rule__BehaviorTime__ValueAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:9317:1: ( ( rule__BehaviorTime__ValueAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:9141:1: ( ( rule__BehaviorTime__ValueAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:9142:2: ( rule__BehaviorTime__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:9317:1: ( ( rule__BehaviorTime__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:9318:2: ( rule__BehaviorTime__ValueAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTimeAccess().getValueAssignment_0()); } - // InternalBehaviorAnnexParser.g:9143:2: ( rule__BehaviorTime__ValueAssignment_0 ) - // InternalBehaviorAnnexParser.g:9143:3: rule__BehaviorTime__ValueAssignment_0 + // InternalBehaviorAnnexParser.g:9319:2: ( rule__BehaviorTime__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:9319:3: rule__BehaviorTime__ValueAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTime__ValueAssignment_0(); @@ -30733,14 +31364,14 @@ public final void rule__BehaviorTime__Group__0__Impl() throws RecognitionExcepti // $ANTLR start "rule__BehaviorTime__Group__1" - // InternalBehaviorAnnexParser.g:9151:1: rule__BehaviorTime__Group__1 : rule__BehaviorTime__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:9327: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:9155:1: ( rule__BehaviorTime__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9156:2: rule__BehaviorTime__Group__1__Impl + // InternalBehaviorAnnexParser.g:9331:1: ( rule__BehaviorTime__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9332:2: rule__BehaviorTime__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTime__Group__1__Impl(); @@ -30766,23 +31397,23 @@ public final void rule__BehaviorTime__Group__1() throws RecognitionException { // $ANTLR start "rule__BehaviorTime__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9162:1: rule__BehaviorTime__Group__1__Impl : ( ( rule__BehaviorTime__UnitAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:9338: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:9166:1: ( ( ( rule__BehaviorTime__UnitAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:9167:1: ( ( rule__BehaviorTime__UnitAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:9342:1: ( ( ( rule__BehaviorTime__UnitAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:9343:1: ( ( rule__BehaviorTime__UnitAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:9167:1: ( ( rule__BehaviorTime__UnitAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:9168:2: ( rule__BehaviorTime__UnitAssignment_1 ) + // InternalBehaviorAnnexParser.g:9343:1: ( ( rule__BehaviorTime__UnitAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:9344:2: ( rule__BehaviorTime__UnitAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTimeAccess().getUnitAssignment_1()); } - // InternalBehaviorAnnexParser.g:9169:2: ( rule__BehaviorTime__UnitAssignment_1 ) - // InternalBehaviorAnnexParser.g:9169:3: rule__BehaviorTime__UnitAssignment_1 + // InternalBehaviorAnnexParser.g:9345:2: ( rule__BehaviorTime__UnitAssignment_1 ) + // InternalBehaviorAnnexParser.g:9345:3: rule__BehaviorTime__UnitAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorTime__UnitAssignment_1(); @@ -30816,371 +31447,23 @@ public final void rule__BehaviorTime__Group__1__Impl() throws RecognitionExcepti // $ANTLR end "rule__BehaviorTime__Group__1__Impl" - // $ANTLR start "rule__LogicalOrExpression__Group__0" - // InternalBehaviorAnnexParser.g:9178:1: rule__LogicalOrExpression__Group__0 : rule__LogicalOrExpression__Group__0__Impl rule__LogicalOrExpression__Group__1 ; - public final void rule__LogicalOrExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__ValueExpression__Group__0" + // InternalBehaviorAnnexParser.g:9354: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:9182:1: ( rule__LogicalOrExpression__Group__0__Impl rule__LogicalOrExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:9183:2: rule__LogicalOrExpression__Group__0__Impl rule__LogicalOrExpression__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_35); - rule__LogicalOrExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalOrExpression__Group__1(); - - state._fsp--; - if (state.failed) return ; - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__LogicalOrExpression__Group__0" - - - // $ANTLR start "rule__LogicalOrExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9190:1: rule__LogicalOrExpression__Group__0__Impl : ( ruleLogicalAndExpression ) ; - public final void rule__LogicalOrExpression__Group__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalBehaviorAnnexParser.g:9194:1: ( ( ruleLogicalAndExpression ) ) - // InternalBehaviorAnnexParser.g:9195:1: ( ruleLogicalAndExpression ) - { - // InternalBehaviorAnnexParser.g:9195:1: ( ruleLogicalAndExpression ) - // InternalBehaviorAnnexParser.g:9196:2: ruleLogicalAndExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrExpressionAccess().getLogicalAndExpressionParserRuleCall_0()); - } - pushFollow(FollowSets000.FOLLOW_2); - ruleLogicalAndExpression(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrExpressionAccess().getLogicalAndExpressionParserRuleCall_0()); - } - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__LogicalOrExpression__Group__0__Impl" - - - // $ANTLR start "rule__LogicalOrExpression__Group__1" - // InternalBehaviorAnnexParser.g:9205:1: rule__LogicalOrExpression__Group__1 : rule__LogicalOrExpression__Group__1__Impl ; - public final void rule__LogicalOrExpression__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalBehaviorAnnexParser.g:9209:1: ( rule__LogicalOrExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9210:2: rule__LogicalOrExpression__Group__1__Impl - { - pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalOrExpression__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__LogicalOrExpression__Group__1" - - - // $ANTLR start "rule__LogicalOrExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9216:1: rule__LogicalOrExpression__Group__1__Impl : ( ( rule__LogicalOrExpression__Group_1__0 )* ) ; - public final void rule__LogicalOrExpression__Group__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalBehaviorAnnexParser.g:9220:1: ( ( ( rule__LogicalOrExpression__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:9221:1: ( ( rule__LogicalOrExpression__Group_1__0 )* ) - { - // InternalBehaviorAnnexParser.g:9221:1: ( ( rule__LogicalOrExpression__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:9222:2: ( rule__LogicalOrExpression__Group_1__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrExpressionAccess().getGroup_1()); - } - // InternalBehaviorAnnexParser.g:9223:2: ( rule__LogicalOrExpression__Group_1__0 )* - loop80: - do { - int alt80=2; - int LA80_0 = input.LA(1); - - if ( (LA80_0==Xor||LA80_0==Or) ) { - alt80=1; - } - - - switch (alt80) { - case 1 : - // InternalBehaviorAnnexParser.g:9223:3: rule__LogicalOrExpression__Group_1__0 - { - pushFollow(FollowSets000.FOLLOW_36); - rule__LogicalOrExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop80; - } - } while (true); - - if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrExpressionAccess().getGroup_1()); - } - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__LogicalOrExpression__Group__1__Impl" - - - // $ANTLR start "rule__LogicalOrExpression__Group_1__0" - // InternalBehaviorAnnexParser.g:9232:1: rule__LogicalOrExpression__Group_1__0 : rule__LogicalOrExpression__Group_1__0__Impl rule__LogicalOrExpression__Group_1__1 ; - public final void rule__LogicalOrExpression__Group_1__0() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalBehaviorAnnexParser.g:9236:1: ( rule__LogicalOrExpression__Group_1__0__Impl rule__LogicalOrExpression__Group_1__1 ) - // InternalBehaviorAnnexParser.g:9237:2: rule__LogicalOrExpression__Group_1__0__Impl rule__LogicalOrExpression__Group_1__1 - { - pushFollow(FollowSets000.FOLLOW_35); - rule__LogicalOrExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalOrExpression__Group_1__1(); - - state._fsp--; - if (state.failed) return ; - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__LogicalOrExpression__Group_1__0" - - - // $ANTLR start "rule__LogicalOrExpression__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:9244:1: rule__LogicalOrExpression__Group_1__0__Impl : ( () ) ; - public final void rule__LogicalOrExpression__Group_1__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalBehaviorAnnexParser.g:9248:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:9249:1: ( () ) - { - // InternalBehaviorAnnexParser.g:9249:1: ( () ) - // InternalBehaviorAnnexParser.g:9250:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrExpressionAccess().getBinaryExpressionLeftAction_1_0()); - } - // InternalBehaviorAnnexParser.g:9251:2: () - // InternalBehaviorAnnexParser.g:9251:3: - { - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrExpressionAccess().getBinaryExpressionLeftAction_1_0()); - } - - } - - - } - - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__LogicalOrExpression__Group_1__0__Impl" - - - // $ANTLR start "rule__LogicalOrExpression__Group_1__1" - // InternalBehaviorAnnexParser.g:9259:1: rule__LogicalOrExpression__Group_1__1 : rule__LogicalOrExpression__Group_1__1__Impl rule__LogicalOrExpression__Group_1__2 ; - public final void rule__LogicalOrExpression__Group_1__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalBehaviorAnnexParser.g:9263:1: ( rule__LogicalOrExpression__Group_1__1__Impl rule__LogicalOrExpression__Group_1__2 ) - // InternalBehaviorAnnexParser.g:9264:2: rule__LogicalOrExpression__Group_1__1__Impl rule__LogicalOrExpression__Group_1__2 - { - pushFollow(FollowSets000.FOLLOW_47); - rule__LogicalOrExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalOrExpression__Group_1__2(); - - state._fsp--; - if (state.failed) return ; - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__LogicalOrExpression__Group_1__1" - - - // $ANTLR start "rule__LogicalOrExpression__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:9271:1: rule__LogicalOrExpression__Group_1__1__Impl : ( ( rule__LogicalOrExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__LogicalOrExpression__Group_1__1__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalBehaviorAnnexParser.g:9275:1: ( ( ( rule__LogicalOrExpression__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:9276:1: ( ( rule__LogicalOrExpression__OperatorAssignment_1_1 ) ) - { - // InternalBehaviorAnnexParser.g:9276:1: ( ( rule__LogicalOrExpression__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:9277:2: ( rule__LogicalOrExpression__OperatorAssignment_1_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrExpressionAccess().getOperatorAssignment_1_1()); - } - // InternalBehaviorAnnexParser.g:9278:2: ( rule__LogicalOrExpression__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:9278:3: rule__LogicalOrExpression__OperatorAssignment_1_1 - { - pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalOrExpression__OperatorAssignment_1_1(); + pushFollow(FollowSets000.FOLLOW_59); + rule__ValueExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrExpressionAccess().getOperatorAssignment_1_1()); - } - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__LogicalOrExpression__Group_1__1__Impl" - - - // $ANTLR start "rule__LogicalOrExpression__Group_1__2" - // InternalBehaviorAnnexParser.g:9286:1: rule__LogicalOrExpression__Group_1__2 : rule__LogicalOrExpression__Group_1__2__Impl ; - public final void rule__LogicalOrExpression__Group_1__2() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalBehaviorAnnexParser.g:9290:1: ( rule__LogicalOrExpression__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:9291:2: rule__LogicalOrExpression__Group_1__2__Impl - { pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalOrExpression__Group_1__2__Impl(); + rule__ValueExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -31199,38 +31482,32 @@ public final void rule__LogicalOrExpression__Group_1__2() throws RecognitionExce } return ; } - // $ANTLR end "rule__LogicalOrExpression__Group_1__2" + // $ANTLR end "rule__ValueExpression__Group__0" - // $ANTLR start "rule__LogicalOrExpression__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:9297:1: rule__LogicalOrExpression__Group_1__2__Impl : ( ( rule__LogicalOrExpression__RightAssignment_1_2 ) ) ; - public final void rule__LogicalOrExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ValueExpression__Group__0__Impl" + // InternalBehaviorAnnexParser.g:9366:1: rule__ValueExpression__Group__0__Impl : ( ruleRelation ) ; + public final void rule__ValueExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9301:1: ( ( ( rule__LogicalOrExpression__RightAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:9302:1: ( ( rule__LogicalOrExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9370:1: ( ( ruleRelation ) ) + // InternalBehaviorAnnexParser.g:9371:1: ( ruleRelation ) { - // InternalBehaviorAnnexParser.g:9302:1: ( ( rule__LogicalOrExpression__RightAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:9303:2: ( rule__LogicalOrExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9371:1: ( ruleRelation ) + // InternalBehaviorAnnexParser.g:9372:2: ruleRelation { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrExpressionAccess().getRightAssignment_1_2()); + before(grammarAccess.getValueExpressionAccess().getRelationParserRuleCall_0()); } - // InternalBehaviorAnnexParser.g:9304:2: ( rule__LogicalOrExpression__RightAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:9304:3: rule__LogicalOrExpression__RightAssignment_1_2 - { pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalOrExpression__RightAssignment_1_2(); + ruleRelation(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getValueExpressionAccess().getRelationParserRuleCall_0()); } } @@ -31250,26 +31527,21 @@ public final void rule__LogicalOrExpression__Group_1__2__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__LogicalOrExpression__Group_1__2__Impl" + // $ANTLR end "rule__ValueExpression__Group__0__Impl" - // $ANTLR start "rule__LogicalOrOperator__Group_0__0" - // InternalBehaviorAnnexParser.g:9313: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 { + // $ANTLR start "rule__ValueExpression__Group__1" + // InternalBehaviorAnnexParser.g:9381: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:9317:1: ( rule__LogicalOrOperator__Group_0__0__Impl rule__LogicalOrOperator__Group_0__1 ) - // InternalBehaviorAnnexParser.g:9318:2: rule__LogicalOrOperator__Group_0__0__Impl rule__LogicalOrOperator__Group_0__1 + // InternalBehaviorAnnexParser.g:9385:1: ( rule__ValueExpression__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9386:2: rule__ValueExpression__Group__1__Impl { - pushFollow(FollowSets000.FOLLOW_59); - rule__LogicalOrOperator__Group_0__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalOrOperator__Group_0__1(); + rule__ValueExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -31288,119 +31560,56 @@ public final void rule__LogicalOrOperator__Group_0__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LogicalOrOperator__Group_0__0" + // $ANTLR end "rule__ValueExpression__Group__1" - // $ANTLR start "rule__LogicalOrOperator__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:9325:1: rule__LogicalOrOperator__Group_0__0__Impl : ( Or ) ; - public final void rule__LogicalOrOperator__Group_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ValueExpression__Group__1__Impl" + // InternalBehaviorAnnexParser.g:9392: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:9329:1: ( ( Or ) ) - // InternalBehaviorAnnexParser.g:9330:1: ( Or ) + // InternalBehaviorAnnexParser.g:9396:1: ( ( ( rule__ValueExpression__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:9397:1: ( ( rule__ValueExpression__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:9330:1: ( Or ) - // InternalBehaviorAnnexParser.g:9331:2: Or + // InternalBehaviorAnnexParser.g:9397:1: ( ( rule__ValueExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:9398:2: ( rule__ValueExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrOperatorAccess().getOrKeyword_0_0()); - } - match(input,Or,FollowSets000.FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrOperatorAccess().getOrKeyword_0_0()); + before(grammarAccess.getValueExpressionAccess().getGroup_1()); } + // InternalBehaviorAnnexParser.g:9399:2: ( rule__ValueExpression__Group_1__0 )* + loop83: + do { + int alt83=2; + int LA83_0 = input.LA(1); - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__LogicalOrOperator__Group_0__0__Impl" - - - // $ANTLR start "rule__LogicalOrOperator__Group_0__1" - // InternalBehaviorAnnexParser.g:9340: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:9344:1: ( rule__LogicalOrOperator__Group_0__1__Impl ) - // InternalBehaviorAnnexParser.g:9345:2: rule__LogicalOrOperator__Group_0__1__Impl - { - pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalOrOperator__Group_0__1__Impl(); - - state._fsp--; - if (state.failed) return ; - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__LogicalOrOperator__Group_0__1" - + if ( (LA83_0==And||LA83_0==Xor||LA83_0==Or) ) { + alt83=1; + } - // $ANTLR start "rule__LogicalOrOperator__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:9351: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:9355:1: ( ( ( Else )? ) ) - // InternalBehaviorAnnexParser.g:9356:1: ( ( Else )? ) - { - // InternalBehaviorAnnexParser.g:9356:1: ( ( Else )? ) - // InternalBehaviorAnnexParser.g:9357:2: ( Else )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrOperatorAccess().getElseKeyword_0_1()); - } - // InternalBehaviorAnnexParser.g:9358:2: ( Else )? - int alt81=2; - int LA81_0 = input.LA(1); + switch (alt83) { + case 1 : + // InternalBehaviorAnnexParser.g:9399:3: rule__ValueExpression__Group_1__0 + { + pushFollow(FollowSets000.FOLLOW_60); + rule__ValueExpression__Group_1__0(); - if ( (LA81_0==Else) ) { - alt81=1; - } - switch (alt81) { - case 1 : - // InternalBehaviorAnnexParser.g:9358:3: Else - { - match(input,Else,FollowSets000.FOLLOW_2); if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } - break; + } + break; - } + default : + break loop83; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrOperatorAccess().getElseKeyword_0_1()); + after(grammarAccess.getValueExpressionAccess().getGroup_1()); } } @@ -31420,26 +31629,26 @@ public final void rule__LogicalOrOperator__Group_0__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__LogicalOrOperator__Group_0__1__Impl" + // $ANTLR end "rule__ValueExpression__Group__1__Impl" - // $ANTLR start "rule__LogicalAndExpression__Group__0" - // InternalBehaviorAnnexParser.g:9367:1: rule__LogicalAndExpression__Group__0 : rule__LogicalAndExpression__Group__0__Impl rule__LogicalAndExpression__Group__1 ; - public final void rule__LogicalAndExpression__Group__0() throws RecognitionException { + // $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 ; + public final void rule__ValueExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9371:1: ( rule__LogicalAndExpression__Group__0__Impl rule__LogicalAndExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:9372:2: rule__LogicalAndExpression__Group__0__Impl rule__LogicalAndExpression__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_33); - rule__LogicalAndExpression__Group__0__Impl(); + pushFollow(FollowSets000.FOLLOW_59); + rule__ValueExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalAndExpression__Group__1(); + rule__ValueExpression__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -31458,32 +31667,32 @@ public final void rule__LogicalAndExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__LogicalAndExpression__Group__0" + // $ANTLR end "rule__ValueExpression__Group_1__0" - // $ANTLR start "rule__LogicalAndExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9379:1: rule__LogicalAndExpression__Group__0__Impl : ( ruleRelationalExpression ) ; - public final void rule__LogicalAndExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ValueExpression__Group_1__0__Impl" + // InternalBehaviorAnnexParser.g:9420:1: rule__ValueExpression__Group_1__0__Impl : ( () ) ; + public final void rule__ValueExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9383:1: ( ( ruleRelationalExpression ) ) - // InternalBehaviorAnnexParser.g:9384:1: ( ruleRelationalExpression ) + // InternalBehaviorAnnexParser.g:9424:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:9425:1: ( () ) { - // InternalBehaviorAnnexParser.g:9384:1: ( ruleRelationalExpression ) - // InternalBehaviorAnnexParser.g:9385:2: ruleRelationalExpression + // InternalBehaviorAnnexParser.g:9425:1: ( () ) + // InternalBehaviorAnnexParser.g:9426:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndExpressionAccess().getRelationalExpressionParserRuleCall_0()); + before(grammarAccess.getValueExpressionAccess().getBinaryExpressionLeftAction_1_0()); + } + // InternalBehaviorAnnexParser.g:9427:2: () + // InternalBehaviorAnnexParser.g:9427:3: + { } - pushFollow(FollowSets000.FOLLOW_2); - ruleRelationalExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndExpressionAccess().getRelationalExpressionParserRuleCall_0()); + after(grammarAccess.getValueExpressionAccess().getBinaryExpressionLeftAction_1_0()); } } @@ -31492,10 +31701,6 @@ public final void rule__LogicalAndExpression__Group__0__Impl() throws Recognitio } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -31503,21 +31708,26 @@ public final void rule__LogicalAndExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__LogicalAndExpression__Group__0__Impl" + // $ANTLR end "rule__ValueExpression__Group_1__0__Impl" - // $ANTLR start "rule__LogicalAndExpression__Group__1" - // InternalBehaviorAnnexParser.g:9394:1: rule__LogicalAndExpression__Group__1 : rule__LogicalAndExpression__Group__1__Impl ; - public final void rule__LogicalAndExpression__Group__1() throws RecognitionException { + // $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 ; + public final void rule__ValueExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9398:1: ( rule__LogicalAndExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9399:2: rule__LogicalAndExpression__Group__1__Impl + // 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 { + pushFollow(FollowSets000.FOLLOW_47); + rule__ValueExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalAndExpression__Group__1__Impl(); + rule__ValueExpression__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -31536,56 +31746,38 @@ public final void rule__LogicalAndExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__LogicalAndExpression__Group__1" + // $ANTLR end "rule__ValueExpression__Group_1__1" - // $ANTLR start "rule__LogicalAndExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9405:1: rule__LogicalAndExpression__Group__1__Impl : ( ( rule__LogicalAndExpression__Group_1__0 )* ) ; - public final void rule__LogicalAndExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ValueExpression__Group_1__1__Impl" + // InternalBehaviorAnnexParser.g:9447: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:9409:1: ( ( ( rule__LogicalAndExpression__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:9410:1: ( ( rule__LogicalAndExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:9451:1: ( ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:9452:1: ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:9410:1: ( ( rule__LogicalAndExpression__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:9411:2: ( rule__LogicalAndExpression__Group_1__0 )* + // InternalBehaviorAnnexParser.g:9452:1: ( ( rule__ValueExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9453:2: ( rule__ValueExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndExpressionAccess().getGroup_1()); + before(grammarAccess.getValueExpressionAccess().getOperatorAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:9412:2: ( rule__LogicalAndExpression__Group_1__0 )* - loop82: - do { - int alt82=2; - int LA82_0 = input.LA(1); - - if ( (LA82_0==And) ) { - alt82=1; - } - - - switch (alt82) { - case 1 : - // InternalBehaviorAnnexParser.g:9412:3: rule__LogicalAndExpression__Group_1__0 - { - pushFollow(FollowSets000.FOLLOW_34); - rule__LogicalAndExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalBehaviorAnnexParser.g:9454:2: ( rule__ValueExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9454:3: rule__ValueExpression__OperatorAssignment_1_1 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__ValueExpression__OperatorAssignment_1_1(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop82; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndExpressionAccess().getGroup_1()); + after(grammarAccess.getValueExpressionAccess().getOperatorAssignment_1_1()); } } @@ -31605,26 +31797,21 @@ public final void rule__LogicalAndExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__LogicalAndExpression__Group__1__Impl" + // $ANTLR end "rule__ValueExpression__Group_1__1__Impl" - // $ANTLR start "rule__LogicalAndExpression__Group_1__0" - // InternalBehaviorAnnexParser.g:9421:1: rule__LogicalAndExpression__Group_1__0 : rule__LogicalAndExpression__Group_1__0__Impl rule__LogicalAndExpression__Group_1__1 ; - public final void rule__LogicalAndExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__ValueExpression__Group_1__2" + // InternalBehaviorAnnexParser.g:9462: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:9425:1: ( rule__LogicalAndExpression__Group_1__0__Impl rule__LogicalAndExpression__Group_1__1 ) - // InternalBehaviorAnnexParser.g:9426:2: rule__LogicalAndExpression__Group_1__0__Impl rule__LogicalAndExpression__Group_1__1 + // InternalBehaviorAnnexParser.g:9466:1: ( rule__ValueExpression__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:9467:2: rule__ValueExpression__Group_1__2__Impl { - pushFollow(FollowSets000.FOLLOW_33); - rule__LogicalAndExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalAndExpression__Group_1__1(); + rule__ValueExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -31643,32 +31830,38 @@ public final void rule__LogicalAndExpression__Group_1__0() throws RecognitionExc } return ; } - // $ANTLR end "rule__LogicalAndExpression__Group_1__0" + // $ANTLR end "rule__ValueExpression__Group_1__2" - // $ANTLR start "rule__LogicalAndExpression__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:9433:1: rule__LogicalAndExpression__Group_1__0__Impl : ( () ) ; - public final void rule__LogicalAndExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ValueExpression__Group_1__2__Impl" + // InternalBehaviorAnnexParser.g:9473: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:9437:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:9438:1: ( () ) + // InternalBehaviorAnnexParser.g:9477:1: ( ( ( rule__ValueExpression__RightAssignment_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:9478:1: ( ( rule__ValueExpression__RightAssignment_1_2 ) ) { - // InternalBehaviorAnnexParser.g:9438:1: ( () ) - // InternalBehaviorAnnexParser.g:9439:2: () + // InternalBehaviorAnnexParser.g:9478:1: ( ( rule__ValueExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9479:2: ( rule__ValueExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndExpressionAccess().getBinaryExpressionLeftAction_1_0()); + before(grammarAccess.getValueExpressionAccess().getRightAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:9440:2: () - // InternalBehaviorAnnexParser.g:9440:3: + // InternalBehaviorAnnexParser.g:9480:2: ( rule__ValueExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9480:3: rule__ValueExpression__RightAssignment_1_2 { + pushFollow(FollowSets000.FOLLOW_2); + rule__ValueExpression__RightAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndExpressionAccess().getBinaryExpressionLeftAction_1_0()); + after(grammarAccess.getValueExpressionAccess().getRightAssignment_1_2()); } } @@ -31677,6 +31870,10 @@ public final void rule__LogicalAndExpression__Group_1__0__Impl() throws Recognit } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -31684,26 +31881,26 @@ public final void rule__LogicalAndExpression__Group_1__0__Impl() throws Recognit } return ; } - // $ANTLR end "rule__LogicalAndExpression__Group_1__0__Impl" + // $ANTLR end "rule__ValueExpression__Group_1__2__Impl" - // $ANTLR start "rule__LogicalAndExpression__Group_1__1" - // InternalBehaviorAnnexParser.g:9448:1: rule__LogicalAndExpression__Group_1__1 : rule__LogicalAndExpression__Group_1__1__Impl rule__LogicalAndExpression__Group_1__2 ; - public final void rule__LogicalAndExpression__Group_1__1() throws RecognitionException { + // $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 ; + public final void rule__LogicalOrOperator__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9452:1: ( rule__LogicalAndExpression__Group_1__1__Impl rule__LogicalAndExpression__Group_1__2 ) - // InternalBehaviorAnnexParser.g:9453:2: rule__LogicalAndExpression__Group_1__1__Impl rule__LogicalAndExpression__Group_1__2 + // 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 { - pushFollow(FollowSets000.FOLLOW_47); - rule__LogicalAndExpression__Group_1__1__Impl(); + pushFollow(FollowSets000.FOLLOW_61); + rule__LogicalOrOperator__Group_0__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalAndExpression__Group_1__2(); + rule__LogicalOrOperator__Group_0__1(); state._fsp--; if (state.failed) return ; @@ -31722,38 +31919,28 @@ public final void rule__LogicalAndExpression__Group_1__1() throws RecognitionExc } return ; } - // $ANTLR end "rule__LogicalAndExpression__Group_1__1" + // $ANTLR end "rule__LogicalOrOperator__Group_0__0" - // $ANTLR start "rule__LogicalAndExpression__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:9460:1: rule__LogicalAndExpression__Group_1__1__Impl : ( ( rule__LogicalAndExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__LogicalAndExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__LogicalOrOperator__Group_0__0__Impl" + // InternalBehaviorAnnexParser.g:9501: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:9464:1: ( ( ( rule__LogicalAndExpression__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:9465:1: ( ( rule__LogicalAndExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9505:1: ( ( Or ) ) + // InternalBehaviorAnnexParser.g:9506:1: ( Or ) { - // InternalBehaviorAnnexParser.g:9465:1: ( ( rule__LogicalAndExpression__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:9466:2: ( rule__LogicalAndExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9506:1: ( Or ) + // InternalBehaviorAnnexParser.g:9507:2: Or { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndExpressionAccess().getOperatorAssignment_1_1()); - } - // InternalBehaviorAnnexParser.g:9467:2: ( rule__LogicalAndExpression__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:9467:3: rule__LogicalAndExpression__OperatorAssignment_1_1 - { - pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalAndExpression__OperatorAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getLogicalOrOperatorAccess().getOrKeyword_0_0()); } - + match(input,Or,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getLogicalOrOperatorAccess().getOrKeyword_0_0()); } } @@ -31773,21 +31960,21 @@ public final void rule__LogicalAndExpression__Group_1__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__LogicalAndExpression__Group_1__1__Impl" + // $ANTLR end "rule__LogicalOrOperator__Group_0__0__Impl" - // $ANTLR start "rule__LogicalAndExpression__Group_1__2" - // InternalBehaviorAnnexParser.g:9475:1: rule__LogicalAndExpression__Group_1__2 : rule__LogicalAndExpression__Group_1__2__Impl ; - public final void rule__LogicalAndExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__LogicalOrOperator__Group_0__1" + // InternalBehaviorAnnexParser.g:9516: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:9479:1: ( rule__LogicalAndExpression__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:9480:2: rule__LogicalAndExpression__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:9520:1: ( rule__LogicalOrOperator__Group_0__1__Impl ) + // InternalBehaviorAnnexParser.g:9521:2: rule__LogicalOrOperator__Group_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalAndExpression__Group_1__2__Impl(); + rule__LogicalOrOperator__Group_0__1__Impl(); state._fsp--; if (state.failed) return ; @@ -31806,38 +31993,45 @@ public final void rule__LogicalAndExpression__Group_1__2() throws RecognitionExc } return ; } - // $ANTLR end "rule__LogicalAndExpression__Group_1__2" + // $ANTLR end "rule__LogicalOrOperator__Group_0__1" - // $ANTLR start "rule__LogicalAndExpression__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:9486:1: rule__LogicalAndExpression__Group_1__2__Impl : ( ( rule__LogicalAndExpression__RightAssignment_1_2 ) ) ; - public final void rule__LogicalAndExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__LogicalOrOperator__Group_0__1__Impl" + // InternalBehaviorAnnexParser.g:9527: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:9490:1: ( ( ( rule__LogicalAndExpression__RightAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:9491:1: ( ( rule__LogicalAndExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9531:1: ( ( ( Else )? ) ) + // InternalBehaviorAnnexParser.g:9532:1: ( ( Else )? ) { - // InternalBehaviorAnnexParser.g:9491:1: ( ( rule__LogicalAndExpression__RightAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:9492:2: ( rule__LogicalAndExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9532:1: ( ( Else )? ) + // InternalBehaviorAnnexParser.g:9533:2: ( Else )? { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndExpressionAccess().getRightAssignment_1_2()); + before(grammarAccess.getLogicalOrOperatorAccess().getElseKeyword_0_1()); } - // InternalBehaviorAnnexParser.g:9493:2: ( rule__LogicalAndExpression__RightAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:9493:3: rule__LogicalAndExpression__RightAssignment_1_2 - { - pushFollow(FollowSets000.FOLLOW_2); - rule__LogicalAndExpression__RightAssignment_1_2(); + // InternalBehaviorAnnexParser.g:9534:2: ( Else )? + int alt84=2; + int LA84_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA84_0==Else) ) { + alt84=1; + } + switch (alt84) { + case 1 : + // InternalBehaviorAnnexParser.g:9534:3: Else + { + match(input,Else,FollowSets000.FOLLOW_2); if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getLogicalOrOperatorAccess().getElseKeyword_0_1()); } } @@ -31857,20 +32051,20 @@ public final void rule__LogicalAndExpression__Group_1__2__Impl() throws Recognit } return ; } - // $ANTLR end "rule__LogicalAndExpression__Group_1__2__Impl" + // $ANTLR end "rule__LogicalOrOperator__Group_0__1__Impl" // $ANTLR start "rule__LogicalAndOperator__Group__0" - // InternalBehaviorAnnexParser.g:9502:1: rule__LogicalAndOperator__Group__0 : rule__LogicalAndOperator__Group__0__Impl rule__LogicalAndOperator__Group__1 ; + // InternalBehaviorAnnexParser.g:9543: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:9506:1: ( rule__LogicalAndOperator__Group__0__Impl rule__LogicalAndOperator__Group__1 ) - // InternalBehaviorAnnexParser.g:9507:2: rule__LogicalAndOperator__Group__0__Impl rule__LogicalAndOperator__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_60); + pushFollow(FollowSets000.FOLLOW_62); rule__LogicalAndOperator__Group__0__Impl(); state._fsp--; @@ -31899,17 +32093,17 @@ public final void rule__LogicalAndOperator__Group__0() throws RecognitionExcepti // $ANTLR start "rule__LogicalAndOperator__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9514:1: rule__LogicalAndOperator__Group__0__Impl : ( And ) ; + // InternalBehaviorAnnexParser.g:9555:1: rule__LogicalAndOperator__Group__0__Impl : ( And ) ; public final void rule__LogicalAndOperator__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9518:1: ( ( And ) ) - // InternalBehaviorAnnexParser.g:9519:1: ( And ) + // InternalBehaviorAnnexParser.g:9559:1: ( ( And ) ) + // InternalBehaviorAnnexParser.g:9560:1: ( And ) { - // InternalBehaviorAnnexParser.g:9519:1: ( And ) - // InternalBehaviorAnnexParser.g:9520:2: And + // InternalBehaviorAnnexParser.g:9560:1: ( And ) + // InternalBehaviorAnnexParser.g:9561:2: And { if ( state.backtracking==0 ) { before(grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); @@ -31940,14 +32134,14 @@ public final void rule__LogicalAndOperator__Group__0__Impl() throws RecognitionE // $ANTLR start "rule__LogicalAndOperator__Group__1" - // InternalBehaviorAnnexParser.g:9529:1: rule__LogicalAndOperator__Group__1 : rule__LogicalAndOperator__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:9570: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:9533:1: ( rule__LogicalAndOperator__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9534:2: rule__LogicalAndOperator__Group__1__Impl + // InternalBehaviorAnnexParser.g:9574:1: ( rule__LogicalAndOperator__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9575:2: rule__LogicalAndOperator__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__LogicalAndOperator__Group__1__Impl(); @@ -31973,31 +32167,31 @@ public final void rule__LogicalAndOperator__Group__1() throws RecognitionExcepti // $ANTLR start "rule__LogicalAndOperator__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9540:1: rule__LogicalAndOperator__Group__1__Impl : ( ( Then )? ) ; + // InternalBehaviorAnnexParser.g:9581:1: rule__LogicalAndOperator__Group__1__Impl : ( ( Then )? ) ; public final void rule__LogicalAndOperator__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9544:1: ( ( ( Then )? ) ) - // InternalBehaviorAnnexParser.g:9545:1: ( ( Then )? ) + // InternalBehaviorAnnexParser.g:9585:1: ( ( ( Then )? ) ) + // InternalBehaviorAnnexParser.g:9586:1: ( ( Then )? ) { - // InternalBehaviorAnnexParser.g:9545:1: ( ( Then )? ) - // InternalBehaviorAnnexParser.g:9546:2: ( Then )? + // InternalBehaviorAnnexParser.g:9586:1: ( ( Then )? ) + // InternalBehaviorAnnexParser.g:9587:2: ( Then )? { if ( state.backtracking==0 ) { before(grammarAccess.getLogicalAndOperatorAccess().getThenKeyword_1()); } - // InternalBehaviorAnnexParser.g:9547:2: ( Then )? - int alt83=2; - int LA83_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:9588:2: ( Then )? + int alt85=2; + int LA85_0 = input.LA(1); - if ( (LA83_0==Then) ) { - alt83=1; + if ( (LA85_0==Then) ) { + alt85=1; } - switch (alt83) { + switch (alt85) { case 1 : - // InternalBehaviorAnnexParser.g:9547:3: Then + // InternalBehaviorAnnexParser.g:9588:3: Then { match(input,Then,FollowSets000.FOLLOW_2); if (state.failed) return ; @@ -32030,23 +32224,23 @@ public final void rule__LogicalAndOperator__Group__1__Impl() throws RecognitionE // $ANTLR end "rule__LogicalAndOperator__Group__1__Impl" - // $ANTLR start "rule__RelationalExpression__Group__0" - // InternalBehaviorAnnexParser.g:9556:1: rule__RelationalExpression__Group__0 : rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ; - public final void rule__RelationalExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__Relation__Group__0" + // InternalBehaviorAnnexParser.g:9597: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:9560:1: ( rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:9561:2: rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_61); - rule__RelationalExpression__Group__0__Impl(); + pushFollow(FollowSets000.FOLLOW_63); + rule__Relation__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__RelationalExpression__Group__1(); + rule__Relation__Group__1(); state._fsp--; if (state.failed) return ; @@ -32065,32 +32259,32 @@ public final void rule__RelationalExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__RelationalExpression__Group__0" + // $ANTLR end "rule__Relation__Group__0" - // $ANTLR start "rule__RelationalExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9568:1: rule__RelationalExpression__Group__0__Impl : ( ruleAdditiveExpression ) ; - public final void rule__RelationalExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Relation__Group__0__Impl" + // InternalBehaviorAnnexParser.g:9609:1: rule__Relation__Group__0__Impl : ( ruleSimpleExpression ) ; + public final void rule__Relation__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9572:1: ( ( ruleAdditiveExpression ) ) - // InternalBehaviorAnnexParser.g:9573:1: ( ruleAdditiveExpression ) + // InternalBehaviorAnnexParser.g:9613:1: ( ( ruleSimpleExpression ) ) + // InternalBehaviorAnnexParser.g:9614:1: ( ruleSimpleExpression ) { - // InternalBehaviorAnnexParser.g:9573:1: ( ruleAdditiveExpression ) - // InternalBehaviorAnnexParser.g:9574:2: ruleAdditiveExpression + // InternalBehaviorAnnexParser.g:9614:1: ( ruleSimpleExpression ) + // InternalBehaviorAnnexParser.g:9615:2: ruleSimpleExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); + before(grammarAccess.getRelationAccess().getSimpleExpressionParserRuleCall_0()); } pushFollow(FollowSets000.FOLLOW_2); - ruleAdditiveExpression(); + ruleSimpleExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); + after(grammarAccess.getRelationAccess().getSimpleExpressionParserRuleCall_0()); } } @@ -32110,21 +32304,21 @@ public final void rule__RelationalExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__RelationalExpression__Group__0__Impl" + // $ANTLR end "rule__Relation__Group__0__Impl" - // $ANTLR start "rule__RelationalExpression__Group__1" - // InternalBehaviorAnnexParser.g:9583:1: rule__RelationalExpression__Group__1 : rule__RelationalExpression__Group__1__Impl ; - public final void rule__RelationalExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__Relation__Group__1" + // InternalBehaviorAnnexParser.g:9624: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:9587:1: ( rule__RelationalExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9588:2: rule__RelationalExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:9628:1: ( rule__Relation__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9629:2: rule__Relation__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__RelationalExpression__Group__1__Impl(); + rule__Relation__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -32143,38 +32337,38 @@ public final void rule__RelationalExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__RelationalExpression__Group__1" + // $ANTLR end "rule__Relation__Group__1" - // $ANTLR start "rule__RelationalExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9594:1: rule__RelationalExpression__Group__1__Impl : ( ( rule__RelationalExpression__Group_1__0 )? ) ; - public final void rule__RelationalExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Relation__Group__1__Impl" + // InternalBehaviorAnnexParser.g:9635: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:9598:1: ( ( ( rule__RelationalExpression__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:9599:1: ( ( rule__RelationalExpression__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:9639:1: ( ( ( rule__Relation__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:9640:1: ( ( rule__Relation__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:9599:1: ( ( rule__RelationalExpression__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:9600:2: ( rule__RelationalExpression__Group_1__0 )? + // InternalBehaviorAnnexParser.g:9640:1: ( ( rule__Relation__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:9641:2: ( rule__Relation__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); + before(grammarAccess.getRelationAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:9601:2: ( rule__RelationalExpression__Group_1__0 )? - int alt84=2; - int LA84_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:9642:2: ( rule__Relation__Group_1__0 )? + int alt86=2; + int LA86_0 = input.LA(1); - if ( (LA84_0==ExclamationMarkEqualsSign||LA84_0==LessThanSignEqualsSign||LA84_0==GreaterThanSignEqualsSign||(LA84_0>=LessThanSign && LA84_0<=GreaterThanSign)) ) { - alt84=1; + if ( (LA86_0==ExclamationMarkEqualsSign||LA86_0==LessThanSignEqualsSign||LA86_0==GreaterThanSignEqualsSign||(LA86_0>=LessThanSign && LA86_0<=GreaterThanSign)) ) { + alt86=1; } - switch (alt84) { + switch (alt86) { case 1 : - // InternalBehaviorAnnexParser.g:9601:3: rule__RelationalExpression__Group_1__0 + // InternalBehaviorAnnexParser.g:9642:3: rule__Relation__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); - rule__RelationalExpression__Group_1__0(); + rule__Relation__Group_1__0(); state._fsp--; if (state.failed) return ; @@ -32185,7 +32379,7 @@ public final void rule__RelationalExpression__Group__1__Impl() throws Recognitio } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); + after(grammarAccess.getRelationAccess().getGroup_1()); } } @@ -32205,26 +32399,105 @@ public final void rule__RelationalExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__RelationalExpression__Group__1__Impl" + // $ANTLR end "rule__Relation__Group__1__Impl" - // $ANTLR start "rule__RelationalExpression__Group_1__0" - // InternalBehaviorAnnexParser.g:9610:1: rule__RelationalExpression__Group_1__0 : rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ; - public final void rule__RelationalExpression__Group_1__0() 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 ; + public final void rule__Relation__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9614:1: ( rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ) - // InternalBehaviorAnnexParser.g:9615:2: rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_61); - rule__RelationalExpression__Group_1__0__Impl(); + pushFollow(FollowSets000.FOLLOW_63); + rule__Relation__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FollowSets000.FOLLOW_2); + rule__Relation__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Relation__Group_1__0" + + + // $ANTLR start "rule__Relation__Group_1__0__Impl" + // InternalBehaviorAnnexParser.g:9663: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:9668:1: ( () ) + // InternalBehaviorAnnexParser.g:9669:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationAccess().getBinaryExpressionLeftAction_1_0()); + } + // InternalBehaviorAnnexParser.g:9670:2: () + // InternalBehaviorAnnexParser.g:9670:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationAccess().getBinaryExpressionLeftAction_1_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Relation__Group_1__0__Impl" + + + // $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 ; + 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 + { + pushFollow(FollowSets000.FOLLOW_47); + rule__Relation__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__RelationalExpression__Group_1__1(); + rule__Relation__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -32243,32 +32516,38 @@ public final void rule__RelationalExpression__Group_1__0() throws RecognitionExc } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__0" + // $ANTLR end "rule__Relation__Group_1__1" - // $ANTLR start "rule__RelationalExpression__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:9622:1: rule__RelationalExpression__Group_1__0__Impl : ( () ) ; - public final void rule__RelationalExpression__Group_1__0__Impl() 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 ) ) ; + public final void rule__Relation__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9626:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:9627:1: ( () ) + // InternalBehaviorAnnexParser.g:9694:1: ( ( ( rule__Relation__OperatorAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:9695:1: ( ( rule__Relation__OperatorAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:9627:1: ( () ) - // InternalBehaviorAnnexParser.g:9628:2: () + // InternalBehaviorAnnexParser.g:9695:1: ( ( rule__Relation__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9696:2: ( rule__Relation__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getBinaryExpressionLeftAction_1_0()); + before(grammarAccess.getRelationAccess().getOperatorAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:9629:2: () - // InternalBehaviorAnnexParser.g:9629:3: + // InternalBehaviorAnnexParser.g:9697:2: ( rule__Relation__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9697:3: rule__Relation__OperatorAssignment_1_1 { + pushFollow(FollowSets000.FOLLOW_2); + rule__Relation__OperatorAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getBinaryExpressionLeftAction_1_0()); + after(grammarAccess.getRelationAccess().getOperatorAssignment_1_1()); } } @@ -32277,6 +32556,10 @@ public final void rule__RelationalExpression__Group_1__0__Impl() throws Recognit } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -32284,26 +32567,21 @@ public final void rule__RelationalExpression__Group_1__0__Impl() throws Recognit } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__0__Impl" + // $ANTLR end "rule__Relation__Group_1__1__Impl" - // $ANTLR start "rule__RelationalExpression__Group_1__1" - // InternalBehaviorAnnexParser.g:9637:1: rule__RelationalExpression__Group_1__1 : rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 ; - public final void rule__RelationalExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__Relation__Group_1__2" + // InternalBehaviorAnnexParser.g:9705: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:9641:1: ( rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 ) - // InternalBehaviorAnnexParser.g:9642:2: rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 + // InternalBehaviorAnnexParser.g:9709:1: ( rule__Relation__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:9710:2: rule__Relation__Group_1__2__Impl { - pushFollow(FollowSets000.FOLLOW_47); - rule__RelationalExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__RelationalExpression__Group_1__2(); + rule__Relation__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -32322,30 +32600,30 @@ public final void rule__RelationalExpression__Group_1__1() throws RecognitionExc } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__1" + // $ANTLR end "rule__Relation__Group_1__2" - // $ANTLR start "rule__RelationalExpression__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:9649:1: rule__RelationalExpression__Group_1__1__Impl : ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__RelationalExpression__Group_1__1__Impl() 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 ) ) ; + public final void rule__Relation__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9653:1: ( ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:9654:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9720:1: ( ( ( rule__Relation__RightAssignment_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:9721:1: ( ( rule__Relation__RightAssignment_1_2 ) ) { - // InternalBehaviorAnnexParser.g:9654:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:9655:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9721:1: ( ( rule__Relation__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9722:2: ( rule__Relation__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); + before(grammarAccess.getRelationAccess().getRightAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:9656:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:9656:3: rule__RelationalExpression__OperatorAssignment_1_1 + // InternalBehaviorAnnexParser.g:9723:2: ( rule__Relation__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9723:3: rule__Relation__RightAssignment_1_2 { pushFollow(FollowSets000.FOLLOW_2); - rule__RelationalExpression__OperatorAssignment_1_1(); + rule__Relation__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; @@ -32353,7 +32631,7 @@ public final void rule__RelationalExpression__Group_1__1__Impl() throws Recognit } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getRelationAccess().getRightAssignment_1_2()); } } @@ -32373,21 +32651,26 @@ public final void rule__RelationalExpression__Group_1__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__1__Impl" + // $ANTLR end "rule__Relation__Group_1__2__Impl" - // $ANTLR start "rule__RelationalExpression__Group_1__2" - // InternalBehaviorAnnexParser.g:9664:1: rule__RelationalExpression__Group_1__2 : rule__RelationalExpression__Group_1__2__Impl ; - public final void rule__RelationalExpression__Group_1__2() 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 ; + public final void rule__SimpleExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9668:1: ( rule__RelationalExpression__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:9669:2: rule__RelationalExpression__Group_1__2__Impl + // 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 { + pushFollow(FollowSets000.FOLLOW_64); + rule__SimpleExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__RelationalExpression__Group_1__2__Impl(); + rule__SimpleExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -32406,30 +32689,30 @@ public final void rule__RelationalExpression__Group_1__2() throws RecognitionExc } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__2" + // $ANTLR end "rule__SimpleExpression__Group__0" - // $ANTLR start "rule__RelationalExpression__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:9675:1: rule__RelationalExpression__Group_1__2__Impl : ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ; - public final void rule__RelationalExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__Group__0__Impl" + // InternalBehaviorAnnexParser.g:9744: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:9679:1: ( ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:9680:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9748:1: ( ( ( rule__SimpleExpression__Alternatives_0 ) ) ) + // InternalBehaviorAnnexParser.g:9749:1: ( ( rule__SimpleExpression__Alternatives_0 ) ) { - // InternalBehaviorAnnexParser.g:9680:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:9681:2: ( rule__RelationalExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9749:1: ( ( rule__SimpleExpression__Alternatives_0 ) ) + // InternalBehaviorAnnexParser.g:9750:2: ( rule__SimpleExpression__Alternatives_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); + before(grammarAccess.getSimpleExpressionAccess().getAlternatives_0()); } - // InternalBehaviorAnnexParser.g:9682:2: ( rule__RelationalExpression__RightAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:9682:3: rule__RelationalExpression__RightAssignment_1_2 + // InternalBehaviorAnnexParser.g:9751:2: ( rule__SimpleExpression__Alternatives_0 ) + // InternalBehaviorAnnexParser.g:9751:3: rule__SimpleExpression__Alternatives_0 { pushFollow(FollowSets000.FOLLOW_2); - rule__RelationalExpression__RightAssignment_1_2(); + rule__SimpleExpression__Alternatives_0(); state._fsp--; if (state.failed) return ; @@ -32437,7 +32720,7 @@ public final void rule__RelationalExpression__Group_1__2__Impl() throws Recognit } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getSimpleExpressionAccess().getAlternatives_0()); } } @@ -32457,26 +32740,128 @@ public final void rule__RelationalExpression__Group_1__2__Impl() throws Recognit } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__2__Impl" + // $ANTLR end "rule__SimpleExpression__Group__0__Impl" - // $ANTLR start "rule__AdditiveExpression__Group__0" - // InternalBehaviorAnnexParser.g:9691:1: rule__AdditiveExpression__Group__0 : rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ; - public final void rule__AdditiveExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__Group__1" + // InternalBehaviorAnnexParser.g:9759: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:9695:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:9696:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 + // InternalBehaviorAnnexParser.g:9763:1: ( rule__SimpleExpression__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9764:2: rule__SimpleExpression__Group__1__Impl { - pushFollow(FollowSets000.FOLLOW_62); - rule__AdditiveExpression__Group__0__Impl(); + pushFollow(FollowSets000.FOLLOW_2); + rule__SimpleExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleExpression__Group__1" + + + // $ANTLR start "rule__SimpleExpression__Group__1__Impl" + // InternalBehaviorAnnexParser.g:9770: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:9775:1: ( ( rule__SimpleExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:9776: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: + do { + int alt87=2; + int LA87_0 = input.LA(1); + + if ( (LA87_0==PlusSign||LA87_0==HyphenMinus) ) { + alt87=1; + } + + + switch (alt87) { + case 1 : + // InternalBehaviorAnnexParser.g:9777:3: rule__SimpleExpression__Group_1__0 + { + pushFollow(FollowSets000.FOLLOW_65); + rule__SimpleExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop87; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleExpression__Group__1__Impl" + + + // $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 ; + 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 + { + pushFollow(FollowSets000.FOLLOW_64); + rule__SimpleExpression__Group_0_0__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__AdditiveExpression__Group__1(); + rule__SimpleExpression__Group_0_0__1(); state._fsp--; if (state.failed) return ; @@ -32495,32 +32880,117 @@ public final void rule__AdditiveExpression__Group__0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__0" + // $ANTLR end "rule__SimpleExpression__Group_0_0__0" - // $ANTLR start "rule__AdditiveExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9703:1: rule__AdditiveExpression__Group__0__Impl : ( ruleMultiplicativeExpression ) ; - public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__Group_0_0__0__Impl" + // InternalBehaviorAnnexParser.g:9798: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:9707:1: ( ( ruleMultiplicativeExpression ) ) - // InternalBehaviorAnnexParser.g:9708:1: ( ruleMultiplicativeExpression ) + // InternalBehaviorAnnexParser.g:9802:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:9803:1: ( () ) { - // InternalBehaviorAnnexParser.g:9708:1: ( ruleMultiplicativeExpression ) - // InternalBehaviorAnnexParser.g:9709:2: ruleMultiplicativeExpression + // InternalBehaviorAnnexParser.g:9803:1: ( () ) + // InternalBehaviorAnnexParser.g:9804:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); + before(grammarAccess.getSimpleExpressionAccess().getUnaryExpressionAction_0_0_0()); } + // InternalBehaviorAnnexParser.g:9805:2: () + // InternalBehaviorAnnexParser.g:9805:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleExpressionAccess().getUnaryExpressionAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleExpression__Group_0_0__0__Impl" + + + // $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 ; + 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 + { + pushFollow(FollowSets000.FOLLOW_47); + rule__SimpleExpression__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - ruleMultiplicativeExpression(); + rule__SimpleExpression__Group_0_0__2(); state._fsp--; if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleExpression__Group_0_0__1" + + + // $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 ) ) ; + 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:9830:1: ( ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) ) + // InternalBehaviorAnnexParser.g:9831:2: ( rule__SimpleExpression__OperatorAssignment_0_0_1 ) + { if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_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 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__SimpleExpression__OperatorAssignment_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_0_0_1()); } } @@ -32540,21 +33010,21 @@ public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__0__Impl" + // $ANTLR end "rule__SimpleExpression__Group_0_0__1__Impl" - // $ANTLR start "rule__AdditiveExpression__Group__1" - // InternalBehaviorAnnexParser.g:9718:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ; - public final void rule__AdditiveExpression__Group__1() throws RecognitionException { + // $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 ; + public final void rule__SimpleExpression__Group_0_0__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9722:1: ( rule__AdditiveExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9723:2: rule__AdditiveExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:9844:1: ( rule__SimpleExpression__Group_0_0__2__Impl ) + // InternalBehaviorAnnexParser.g:9845:2: rule__SimpleExpression__Group_0_0__2__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__AdditiveExpression__Group__1__Impl(); + rule__SimpleExpression__Group_0_0__2__Impl(); state._fsp--; if (state.failed) return ; @@ -32573,56 +33043,38 @@ public final void rule__AdditiveExpression__Group__1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__1" + // $ANTLR end "rule__SimpleExpression__Group_0_0__2" - // $ANTLR start "rule__AdditiveExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9729:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ; - public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException { + // $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 ) ) ; + public final void rule__SimpleExpression__Group_0_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9733:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:9734:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:9855:1: ( ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) ) + // InternalBehaviorAnnexParser.g:9856:1: ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) { - // InternalBehaviorAnnexParser.g:9734:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:9735:2: ( rule__AdditiveExpression__Group_1__0 )* + // InternalBehaviorAnnexParser.g:9856:1: ( ( rule__SimpleExpression__OperandAssignment_0_0_2 ) ) + // InternalBehaviorAnnexParser.g:9857:2: ( rule__SimpleExpression__OperandAssignment_0_0_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); + before(grammarAccess.getSimpleExpressionAccess().getOperandAssignment_0_0_2()); } - // InternalBehaviorAnnexParser.g:9736:2: ( rule__AdditiveExpression__Group_1__0 )* - loop85: - do { - int alt85=2; - int LA85_0 = input.LA(1); - - if ( (LA85_0==PlusSign||LA85_0==HyphenMinus) ) { - alt85=1; - } - - - switch (alt85) { - case 1 : - // InternalBehaviorAnnexParser.g:9736:3: rule__AdditiveExpression__Group_1__0 - { - pushFollow(FollowSets000.FOLLOW_63); - rule__AdditiveExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalBehaviorAnnexParser.g:9858:2: ( rule__SimpleExpression__OperandAssignment_0_0_2 ) + // InternalBehaviorAnnexParser.g:9858:3: rule__SimpleExpression__OperandAssignment_0_0_2 + { + pushFollow(FollowSets000.FOLLOW_2); + rule__SimpleExpression__OperandAssignment_0_0_2(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop85; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); + after(grammarAccess.getSimpleExpressionAccess().getOperandAssignment_0_0_2()); } } @@ -32642,26 +33094,26 @@ public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__1__Impl" + // $ANTLR end "rule__SimpleExpression__Group_0_0__2__Impl" - // $ANTLR start "rule__AdditiveExpression__Group_1__0" - // InternalBehaviorAnnexParser.g:9745:1: rule__AdditiveExpression__Group_1__0 : rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ; - public final void rule__AdditiveExpression__Group_1__0() throws RecognitionException { + // $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 ; + public final void rule__SimpleExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9749:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ) - // InternalBehaviorAnnexParser.g:9750:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_62); - rule__AdditiveExpression__Group_1__0__Impl(); + pushFollow(FollowSets000.FOLLOW_64); + rule__SimpleExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__AdditiveExpression__Group_1__1(); + rule__SimpleExpression__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -32680,32 +33132,32 @@ public final void rule__AdditiveExpression__Group_1__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__0" + // $ANTLR end "rule__SimpleExpression__Group_1__0" - // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:9757:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ; - public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__Group_1__0__Impl" + // InternalBehaviorAnnexParser.g:9879:1: rule__SimpleExpression__Group_1__0__Impl : ( () ) ; + public final void rule__SimpleExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9761:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:9762:1: ( () ) + // InternalBehaviorAnnexParser.g:9883:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:9884:1: ( () ) { - // InternalBehaviorAnnexParser.g:9762:1: ( () ) - // InternalBehaviorAnnexParser.g:9763:2: () + // InternalBehaviorAnnexParser.g:9884:1: ( () ) + // InternalBehaviorAnnexParser.g:9885:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); + before(grammarAccess.getSimpleExpressionAccess().getBinaryExpressionLeftAction_1_0()); } - // InternalBehaviorAnnexParser.g:9764:2: () - // InternalBehaviorAnnexParser.g:9764:3: + // InternalBehaviorAnnexParser.g:9886:2: () + // InternalBehaviorAnnexParser.g:9886:3: { } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); + after(grammarAccess.getSimpleExpressionAccess().getBinaryExpressionLeftAction_1_0()); } } @@ -32721,26 +33173,26 @@ public final void rule__AdditiveExpression__Group_1__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__0__Impl" + // $ANTLR end "rule__SimpleExpression__Group_1__0__Impl" - // $ANTLR start "rule__AdditiveExpression__Group_1__1" - // InternalBehaviorAnnexParser.g:9772:1: rule__AdditiveExpression__Group_1__1 : rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ; - public final void rule__AdditiveExpression__Group_1__1() throws RecognitionException { + // $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 ; + public final void rule__SimpleExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9776:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ) - // InternalBehaviorAnnexParser.g:9777:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 + // 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 { pushFollow(FollowSets000.FOLLOW_47); - rule__AdditiveExpression__Group_1__1__Impl(); + rule__SimpleExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__AdditiveExpression__Group_1__2(); + rule__SimpleExpression__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -32759,30 +33211,30 @@ public final void rule__AdditiveExpression__Group_1__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__1" + // $ANTLR end "rule__SimpleExpression__Group_1__1" - // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:9784:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__Group_1__1__Impl" + // InternalBehaviorAnnexParser.g:9906: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:9788:1: ( ( ( rule__AdditiveExpression__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:9789:1: ( ( rule__AdditiveExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9910:1: ( ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:9911:1: ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:9789:1: ( ( rule__AdditiveExpression__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:9790:2: ( rule__AdditiveExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9911:1: ( ( rule__SimpleExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:9912:2: ( rule__SimpleExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getOperatorAssignment_1_1()); + before(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:9791:2: ( rule__AdditiveExpression__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:9791:3: rule__AdditiveExpression__OperatorAssignment_1_1 + // InternalBehaviorAnnexParser.g:9913:2: ( rule__SimpleExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:9913:3: rule__SimpleExpression__OperatorAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); - rule__AdditiveExpression__OperatorAssignment_1_1(); + rule__SimpleExpression__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; @@ -32790,7 +33242,7 @@ public final void rule__AdditiveExpression__Group_1__1__Impl() throws Recognitio } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getSimpleExpressionAccess().getOperatorAssignment_1_1()); } } @@ -32810,21 +33262,21 @@ public final void rule__AdditiveExpression__Group_1__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__1__Impl" + // $ANTLR end "rule__SimpleExpression__Group_1__1__Impl" - // $ANTLR start "rule__AdditiveExpression__Group_1__2" - // InternalBehaviorAnnexParser.g:9799:1: rule__AdditiveExpression__Group_1__2 : rule__AdditiveExpression__Group_1__2__Impl ; - public final void rule__AdditiveExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__Group_1__2" + // InternalBehaviorAnnexParser.g:9921: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:9803:1: ( rule__AdditiveExpression__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:9804:2: rule__AdditiveExpression__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:9925:1: ( rule__SimpleExpression__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:9926:2: rule__SimpleExpression__Group_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__AdditiveExpression__Group_1__2__Impl(); + rule__SimpleExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -32843,30 +33295,30 @@ public final void rule__AdditiveExpression__Group_1__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__2" + // $ANTLR end "rule__SimpleExpression__Group_1__2" - // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:9810:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) ; - public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__Group_1__2__Impl" + // InternalBehaviorAnnexParser.g:9932: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:9814:1: ( ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:9815:1: ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9936:1: ( ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:9937:1: ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) { - // InternalBehaviorAnnexParser.g:9815:1: ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:9816:2: ( rule__AdditiveExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9937:1: ( ( rule__SimpleExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:9938:2: ( rule__SimpleExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); + before(grammarAccess.getSimpleExpressionAccess().getRightAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:9817:2: ( rule__AdditiveExpression__RightAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:9817:3: rule__AdditiveExpression__RightAssignment_1_2 + // InternalBehaviorAnnexParser.g:9939:2: ( rule__SimpleExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:9939:3: rule__SimpleExpression__RightAssignment_1_2 { pushFollow(FollowSets000.FOLLOW_2); - rule__AdditiveExpression__RightAssignment_1_2(); + rule__SimpleExpression__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; @@ -32874,7 +33326,7 @@ public final void rule__AdditiveExpression__Group_1__2__Impl() throws Recognitio } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getSimpleExpressionAccess().getRightAssignment_1_2()); } } @@ -32894,26 +33346,26 @@ public final void rule__AdditiveExpression__Group_1__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__2__Impl" + // $ANTLR end "rule__SimpleExpression__Group_1__2__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group__0" - // InternalBehaviorAnnexParser.g:9826:1: rule__MultiplicativeExpression__Group__0 : rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ; - public final void rule__MultiplicativeExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__Term__Group__0" + // InternalBehaviorAnnexParser.g:9948: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:9830:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:9831:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_64); - rule__MultiplicativeExpression__Group__0__Impl(); + pushFollow(FollowSets000.FOLLOW_66); + rule__Term__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__MultiplicativeExpression__Group__1(); + rule__Term__Group__1(); state._fsp--; if (state.failed) return ; @@ -32932,32 +33384,32 @@ public final void rule__MultiplicativeExpression__Group__0() throws RecognitionE } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__0" + // $ANTLR end "rule__Term__Group__0" - // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9838:1: rule__MultiplicativeExpression__Group__0__Impl : ( rulePowerExpression ) ; - public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Term__Group__0__Impl" + // InternalBehaviorAnnexParser.g:9960:1: rule__Term__Group__0__Impl : ( ruleFactor ) ; + public final void rule__Term__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9842:1: ( ( rulePowerExpression ) ) - // InternalBehaviorAnnexParser.g:9843:1: ( rulePowerExpression ) + // InternalBehaviorAnnexParser.g:9964:1: ( ( ruleFactor ) ) + // InternalBehaviorAnnexParser.g:9965:1: ( ruleFactor ) { - // InternalBehaviorAnnexParser.g:9843:1: ( rulePowerExpression ) - // InternalBehaviorAnnexParser.g:9844:2: rulePowerExpression + // InternalBehaviorAnnexParser.g:9965:1: ( ruleFactor ) + // InternalBehaviorAnnexParser.g:9966:2: ruleFactor { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getPowerExpressionParserRuleCall_0()); + before(grammarAccess.getTermAccess().getFactorParserRuleCall_0()); } pushFollow(FollowSets000.FOLLOW_2); - rulePowerExpression(); + ruleFactor(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getPowerExpressionParserRuleCall_0()); + after(grammarAccess.getTermAccess().getFactorParserRuleCall_0()); } } @@ -32977,21 +33429,21 @@ public final void rule__MultiplicativeExpression__Group__0__Impl() throws Recogn } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__0__Impl" + // $ANTLR end "rule__Term__Group__0__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group__1" - // InternalBehaviorAnnexParser.g:9853:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ; - public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__Term__Group__1" + // InternalBehaviorAnnexParser.g:9975: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:9857:1: ( rule__MultiplicativeExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9858:2: rule__MultiplicativeExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:9979:1: ( rule__Term__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:9980:2: rule__Term__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__MultiplicativeExpression__Group__1__Impl(); + rule__Term__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -33010,42 +33462,42 @@ public final void rule__MultiplicativeExpression__Group__1() throws RecognitionE } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__1" + // $ANTLR end "rule__Term__Group__1" - // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9864:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ; - public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Term__Group__1__Impl" + // InternalBehaviorAnnexParser.g:9986: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:9868:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:9869:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:9990:1: ( ( ( rule__Term__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:9991:1: ( ( rule__Term__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:9869:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:9870:2: ( rule__MultiplicativeExpression__Group_1__0 )* + // InternalBehaviorAnnexParser.g:9991:1: ( ( rule__Term__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:9992:2: ( rule__Term__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); + before(grammarAccess.getTermAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:9871:2: ( rule__MultiplicativeExpression__Group_1__0 )* - loop86: + // InternalBehaviorAnnexParser.g:9993:2: ( rule__Term__Group_1__0 )* + loop88: do { - int alt86=2; - int LA86_0 = input.LA(1); + int alt88=2; + int LA88_0 = input.LA(1); - if ( (LA86_0==Mod||LA86_0==Rem||LA86_0==Asterisk||LA86_0==Solidus) ) { - alt86=1; + if ( (LA88_0==Mod||LA88_0==Rem||LA88_0==Asterisk||LA88_0==Solidus) ) { + alt88=1; } - switch (alt86) { + switch (alt88) { case 1 : - // InternalBehaviorAnnexParser.g:9871:3: rule__MultiplicativeExpression__Group_1__0 + // InternalBehaviorAnnexParser.g:9993:3: rule__Term__Group_1__0 { - pushFollow(FollowSets000.FOLLOW_65); - rule__MultiplicativeExpression__Group_1__0(); + pushFollow(FollowSets000.FOLLOW_67); + rule__Term__Group_1__0(); state._fsp--; if (state.failed) return ; @@ -33054,12 +33506,12 @@ public final void rule__MultiplicativeExpression__Group__1__Impl() throws Recogn break; default : - break loop86; + break loop88; } } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); + after(grammarAccess.getTermAccess().getGroup_1()); } } @@ -33079,26 +33531,26 @@ public final void rule__MultiplicativeExpression__Group__1__Impl() throws Recogn } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__1__Impl" + // $ANTLR end "rule__Term__Group__1__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__0" - // InternalBehaviorAnnexParser.g:9880:1: rule__MultiplicativeExpression__Group_1__0 : rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ; - public final void rule__MultiplicativeExpression__Group_1__0() 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 ; + public final void rule__Term__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9884:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ) - // InternalBehaviorAnnexParser.g:9885:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_64); - rule__MultiplicativeExpression__Group_1__0__Impl(); + pushFollow(FollowSets000.FOLLOW_66); + rule__Term__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__MultiplicativeExpression__Group_1__1(); + rule__Term__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -33117,32 +33569,32 @@ public final void rule__MultiplicativeExpression__Group_1__0() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__0" + // $ANTLR end "rule__Term__Group_1__0" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:9892:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( () ) ; - public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Term__Group_1__0__Impl" + // InternalBehaviorAnnexParser.g:10014:1: rule__Term__Group_1__0__Impl : ( () ) ; + public final void rule__Term__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9896:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:9897:1: ( () ) + // InternalBehaviorAnnexParser.g:10018:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:10019:1: ( () ) { - // InternalBehaviorAnnexParser.g:9897:1: ( () ) - // InternalBehaviorAnnexParser.g:9898:2: () + // InternalBehaviorAnnexParser.g:10019:1: ( () ) + // InternalBehaviorAnnexParser.g:10020:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); + before(grammarAccess.getTermAccess().getBinaryExpressionLeftAction_1_0()); } - // InternalBehaviorAnnexParser.g:9899:2: () - // InternalBehaviorAnnexParser.g:9899:3: + // InternalBehaviorAnnexParser.g:10021:2: () + // InternalBehaviorAnnexParser.g:10021:3: { } if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); + after(grammarAccess.getTermAccess().getBinaryExpressionLeftAction_1_0()); } } @@ -33158,26 +33610,26 @@ public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws Reco } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__0__Impl" + // $ANTLR end "rule__Term__Group_1__0__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__1" - // InternalBehaviorAnnexParser.g:9907:1: rule__MultiplicativeExpression__Group_1__1 : rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ; - public final void rule__MultiplicativeExpression__Group_1__1() 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 ; + public final void rule__Term__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9911:1: ( rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ) - // InternalBehaviorAnnexParser.g:9912:2: rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 + // 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 { pushFollow(FollowSets000.FOLLOW_47); - rule__MultiplicativeExpression__Group_1__1__Impl(); + rule__Term__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__MultiplicativeExpression__Group_1__2(); + rule__Term__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -33196,30 +33648,30 @@ public final void rule__MultiplicativeExpression__Group_1__1() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__1" + // $ANTLR end "rule__Term__Group_1__1" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:9919:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__MultiplicativeExpression__Group_1__1__Impl() 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 ) ) ; + public final void rule__Term__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9923:1: ( ( ( rule__MultiplicativeExpression__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:9924:1: ( ( rule__MultiplicativeExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:10045:1: ( ( ( rule__Term__OperatorAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:10046:1: ( ( rule__Term__OperatorAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:9924:1: ( ( rule__MultiplicativeExpression__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:9925:2: ( rule__MultiplicativeExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:10046:1: ( ( rule__Term__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:10047:2: ( rule__Term__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_1()); + before(grammarAccess.getTermAccess().getOperatorAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:9926:2: ( rule__MultiplicativeExpression__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:9926:3: rule__MultiplicativeExpression__OperatorAssignment_1_1 + // InternalBehaviorAnnexParser.g:10048:2: ( rule__Term__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:10048:3: rule__Term__OperatorAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); - rule__MultiplicativeExpression__OperatorAssignment_1_1(); + rule__Term__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; @@ -33227,7 +33679,7 @@ public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws Reco } if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getTermAccess().getOperatorAssignment_1_1()); } } @@ -33247,21 +33699,21 @@ public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws Reco } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__1__Impl" + // $ANTLR end "rule__Term__Group_1__1__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__2" - // InternalBehaviorAnnexParser.g:9934:1: rule__MultiplicativeExpression__Group_1__2 : rule__MultiplicativeExpression__Group_1__2__Impl ; - public final void rule__MultiplicativeExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__Term__Group_1__2" + // InternalBehaviorAnnexParser.g:10056: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:9938:1: ( rule__MultiplicativeExpression__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:9939:2: rule__MultiplicativeExpression__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:10060:1: ( rule__Term__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:10061:2: rule__Term__Group_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__MultiplicativeExpression__Group_1__2__Impl(); + rule__Term__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -33280,30 +33732,30 @@ public final void rule__MultiplicativeExpression__Group_1__2() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__2" + // $ANTLR end "rule__Term__Group_1__2" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:9945:1: rule__MultiplicativeExpression__Group_1__2__Impl : ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) ; - public final void rule__MultiplicativeExpression__Group_1__2__Impl() 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 ) ) ; + public final void rule__Term__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9949:1: ( ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:9950:1: ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:10071:1: ( ( ( rule__Term__RightAssignment_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:10072:1: ( ( rule__Term__RightAssignment_1_2 ) ) { - // InternalBehaviorAnnexParser.g:9950:1: ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:9951:2: ( rule__MultiplicativeExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:10072:1: ( ( rule__Term__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:10073:2: ( rule__Term__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); + before(grammarAccess.getTermAccess().getRightAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:9952:2: ( rule__MultiplicativeExpression__RightAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:9952:3: rule__MultiplicativeExpression__RightAssignment_1_2 + // InternalBehaviorAnnexParser.g:10074:2: ( rule__Term__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:10074:3: rule__Term__RightAssignment_1_2 { pushFollow(FollowSets000.FOLLOW_2); - rule__MultiplicativeExpression__RightAssignment_1_2(); + rule__Term__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; @@ -33311,7 +33763,7 @@ public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws Reco } if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getTermAccess().getRightAssignment_1_2()); } } @@ -33331,26 +33783,26 @@ public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws Reco } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__2__Impl" + // $ANTLR end "rule__Term__Group_1__2__Impl" - // $ANTLR start "rule__PowerExpression__Group__0" - // InternalBehaviorAnnexParser.g:9961:1: rule__PowerExpression__Group__0 : rule__PowerExpression__Group__0__Impl rule__PowerExpression__Group__1 ; - public final void rule__PowerExpression__Group__0() 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 ; + public final void rule__Factor__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:9965:1: ( rule__PowerExpression__Group__0__Impl rule__PowerExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:9966:2: rule__PowerExpression__Group__0__Impl rule__PowerExpression__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_66); - rule__PowerExpression__Group__0__Impl(); + pushFollow(FollowSets000.FOLLOW_68); + rule__Factor__Group_0__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__PowerExpression__Group__1(); + rule__Factor__Group_0__1(); state._fsp--; if (state.failed) return ; @@ -33369,32 +33821,32 @@ public final void rule__PowerExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__PowerExpression__Group__0" + // $ANTLR end "rule__Factor__Group_0__0" - // $ANTLR start "rule__PowerExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:9973:1: rule__PowerExpression__Group__0__Impl : ( ruleUnaryExpression ) ; - public final void rule__PowerExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Factor__Group_0__0__Impl" + // InternalBehaviorAnnexParser.g:10095: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:9977:1: ( ( ruleUnaryExpression ) ) - // InternalBehaviorAnnexParser.g:9978:1: ( ruleUnaryExpression ) + // InternalBehaviorAnnexParser.g:10099:1: ( ( ruleValue ) ) + // InternalBehaviorAnnexParser.g:10100:1: ( ruleValue ) { - // InternalBehaviorAnnexParser.g:9978:1: ( ruleUnaryExpression ) - // InternalBehaviorAnnexParser.g:9979:2: ruleUnaryExpression + // InternalBehaviorAnnexParser.g:10100:1: ( ruleValue ) + // InternalBehaviorAnnexParser.g:10101:2: ruleValue { if ( state.backtracking==0 ) { - before(grammarAccess.getPowerExpressionAccess().getUnaryExpressionParserRuleCall_0()); + before(grammarAccess.getFactorAccess().getValueParserRuleCall_0_0()); } pushFollow(FollowSets000.FOLLOW_2); - ruleUnaryExpression(); + ruleValue(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getPowerExpressionAccess().getUnaryExpressionParserRuleCall_0()); + after(grammarAccess.getFactorAccess().getValueParserRuleCall_0_0()); } } @@ -33414,21 +33866,21 @@ public final void rule__PowerExpression__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__PowerExpression__Group__0__Impl" + // $ANTLR end "rule__Factor__Group_0__0__Impl" - // $ANTLR start "rule__PowerExpression__Group__1" - // InternalBehaviorAnnexParser.g:9988:1: rule__PowerExpression__Group__1 : rule__PowerExpression__Group__1__Impl ; - public final void rule__PowerExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__Factor__Group_0__1" + // InternalBehaviorAnnexParser.g:10110: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:9992:1: ( rule__PowerExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:9993:2: rule__PowerExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:10114:1: ( rule__Factor__Group_0__1__Impl ) + // InternalBehaviorAnnexParser.g:10115:2: rule__Factor__Group_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__PowerExpression__Group__1__Impl(); + rule__Factor__Group_0__1__Impl(); state._fsp--; if (state.failed) return ; @@ -33447,38 +33899,38 @@ public final void rule__PowerExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__PowerExpression__Group__1" + // $ANTLR end "rule__Factor__Group_0__1" - // $ANTLR start "rule__PowerExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:9999:1: rule__PowerExpression__Group__1__Impl : ( ( rule__PowerExpression__Group_1__0 )? ) ; - public final void rule__PowerExpression__Group__1__Impl() 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 )? ) ; + public final void rule__Factor__Group_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10003:1: ( ( ( rule__PowerExpression__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:10004:1: ( ( rule__PowerExpression__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:10125:1: ( ( ( rule__Factor__Group_0_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:10126:1: ( ( rule__Factor__Group_0_1__0 )? ) { - // InternalBehaviorAnnexParser.g:10004:1: ( ( rule__PowerExpression__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:10005:2: ( rule__PowerExpression__Group_1__0 )? + // InternalBehaviorAnnexParser.g:10126:1: ( ( rule__Factor__Group_0_1__0 )? ) + // InternalBehaviorAnnexParser.g:10127:2: ( rule__Factor__Group_0_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getPowerExpressionAccess().getGroup_1()); + before(grammarAccess.getFactorAccess().getGroup_0_1()); } - // InternalBehaviorAnnexParser.g:10006:2: ( rule__PowerExpression__Group_1__0 )? - int alt87=2; - int LA87_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:10128:2: ( rule__Factor__Group_0_1__0 )? + int alt89=2; + int LA89_0 = input.LA(1); - if ( (LA87_0==AsteriskAsterisk) ) { - alt87=1; + if ( (LA89_0==AsteriskAsterisk) ) { + alt89=1; } - switch (alt87) { + switch (alt89) { case 1 : - // InternalBehaviorAnnexParser.g:10006:3: rule__PowerExpression__Group_1__0 + // InternalBehaviorAnnexParser.g:10128:3: rule__Factor__Group_0_1__0 { pushFollow(FollowSets000.FOLLOW_2); - rule__PowerExpression__Group_1__0(); + rule__Factor__Group_0_1__0(); state._fsp--; if (state.failed) return ; @@ -33489,7 +33941,7 @@ public final void rule__PowerExpression__Group__1__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getPowerExpressionAccess().getGroup_1()); + after(grammarAccess.getFactorAccess().getGroup_0_1()); } } @@ -33509,26 +33961,26 @@ public final void rule__PowerExpression__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__PowerExpression__Group__1__Impl" + // $ANTLR end "rule__Factor__Group_0__1__Impl" - // $ANTLR start "rule__PowerExpression__Group_1__0" - // InternalBehaviorAnnexParser.g:10015:1: rule__PowerExpression__Group_1__0 : rule__PowerExpression__Group_1__0__Impl rule__PowerExpression__Group_1__1 ; - public final void rule__PowerExpression__Group_1__0() 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 ; + public final void rule__Factor__Group_0_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10019:1: ( rule__PowerExpression__Group_1__0__Impl rule__PowerExpression__Group_1__1 ) - // InternalBehaviorAnnexParser.g:10020:2: rule__PowerExpression__Group_1__0__Impl rule__PowerExpression__Group_1__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_66); - rule__PowerExpression__Group_1__0__Impl(); + pushFollow(FollowSets000.FOLLOW_68); + rule__Factor__Group_0_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__PowerExpression__Group_1__1(); + rule__Factor__Group_0_1__1(); state._fsp--; if (state.failed) return ; @@ -33547,32 +33999,32 @@ public final void rule__PowerExpression__Group_1__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__PowerExpression__Group_1__0" + // $ANTLR end "rule__Factor__Group_0_1__0" - // $ANTLR start "rule__PowerExpression__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:10027:1: rule__PowerExpression__Group_1__0__Impl : ( () ) ; - public final void rule__PowerExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Factor__Group_0_1__0__Impl" + // InternalBehaviorAnnexParser.g:10149: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:10031:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:10032:1: ( () ) + // InternalBehaviorAnnexParser.g:10153:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:10154:1: ( () ) { - // InternalBehaviorAnnexParser.g:10032:1: ( () ) - // InternalBehaviorAnnexParser.g:10033:2: () + // InternalBehaviorAnnexParser.g:10154:1: ( () ) + // InternalBehaviorAnnexParser.g:10155:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getPowerExpressionAccess().getBinaryExpressionLeftAction_1_0()); + before(grammarAccess.getFactorAccess().getBinaryExpressionLeftAction_0_1_0()); } - // InternalBehaviorAnnexParser.g:10034:2: () - // InternalBehaviorAnnexParser.g:10034:3: + // InternalBehaviorAnnexParser.g:10156:2: () + // InternalBehaviorAnnexParser.g:10156:3: { } if ( state.backtracking==0 ) { - after(grammarAccess.getPowerExpressionAccess().getBinaryExpressionLeftAction_1_0()); + after(grammarAccess.getFactorAccess().getBinaryExpressionLeftAction_0_1_0()); } } @@ -33588,26 +34040,26 @@ public final void rule__PowerExpression__Group_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__PowerExpression__Group_1__0__Impl" + // $ANTLR end "rule__Factor__Group_0_1__0__Impl" - // $ANTLR start "rule__PowerExpression__Group_1__1" - // InternalBehaviorAnnexParser.g:10042:1: rule__PowerExpression__Group_1__1 : rule__PowerExpression__Group_1__1__Impl rule__PowerExpression__Group_1__2 ; - public final void rule__PowerExpression__Group_1__1() 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 ; + public final void rule__Factor__Group_0_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10046:1: ( rule__PowerExpression__Group_1__1__Impl rule__PowerExpression__Group_1__2 ) - // InternalBehaviorAnnexParser.g:10047:2: rule__PowerExpression__Group_1__1__Impl rule__PowerExpression__Group_1__2 + // 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 { - pushFollow(FollowSets000.FOLLOW_47); - rule__PowerExpression__Group_1__1__Impl(); + pushFollow(FollowSets000.FOLLOW_29); + rule__Factor__Group_0_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__PowerExpression__Group_1__2(); + rule__Factor__Group_0_1__2(); state._fsp--; if (state.failed) return ; @@ -33626,30 +34078,30 @@ public final void rule__PowerExpression__Group_1__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__PowerExpression__Group_1__1" + // $ANTLR end "rule__Factor__Group_0_1__1" - // $ANTLR start "rule__PowerExpression__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:10054:1: rule__PowerExpression__Group_1__1__Impl : ( ( rule__PowerExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__PowerExpression__Group_1__1__Impl() 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 ) ) ; + public final void rule__Factor__Group_0_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10058:1: ( ( ( rule__PowerExpression__OperatorAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:10059:1: ( ( rule__PowerExpression__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:10180:1: ( ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:10181:1: ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) { - // InternalBehaviorAnnexParser.g:10059:1: ( ( rule__PowerExpression__OperatorAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:10060:2: ( rule__PowerExpression__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:10181:1: ( ( rule__Factor__OperatorAssignment_0_1_1 ) ) + // InternalBehaviorAnnexParser.g:10182:2: ( rule__Factor__OperatorAssignment_0_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getPowerExpressionAccess().getOperatorAssignment_1_1()); + before(grammarAccess.getFactorAccess().getOperatorAssignment_0_1_1()); } - // InternalBehaviorAnnexParser.g:10061:2: ( rule__PowerExpression__OperatorAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:10061:3: rule__PowerExpression__OperatorAssignment_1_1 + // InternalBehaviorAnnexParser.g:10183:2: ( rule__Factor__OperatorAssignment_0_1_1 ) + // InternalBehaviorAnnexParser.g:10183:3: rule__Factor__OperatorAssignment_0_1_1 { pushFollow(FollowSets000.FOLLOW_2); - rule__PowerExpression__OperatorAssignment_1_1(); + rule__Factor__OperatorAssignment_0_1_1(); state._fsp--; if (state.failed) return ; @@ -33657,7 +34109,7 @@ public final void rule__PowerExpression__Group_1__1__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getPowerExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getFactorAccess().getOperatorAssignment_0_1_1()); } } @@ -33677,21 +34129,21 @@ public final void rule__PowerExpression__Group_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__PowerExpression__Group_1__1__Impl" + // $ANTLR end "rule__Factor__Group_0_1__1__Impl" - // $ANTLR start "rule__PowerExpression__Group_1__2" - // InternalBehaviorAnnexParser.g:10069:1: rule__PowerExpression__Group_1__2 : rule__PowerExpression__Group_1__2__Impl ; - public final void rule__PowerExpression__Group_1__2() 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 ; + public final void rule__Factor__Group_0_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10073:1: ( rule__PowerExpression__Group_1__2__Impl ) - // InternalBehaviorAnnexParser.g:10074:2: rule__PowerExpression__Group_1__2__Impl + // InternalBehaviorAnnexParser.g:10195:1: ( rule__Factor__Group_0_1__2__Impl ) + // InternalBehaviorAnnexParser.g:10196:2: rule__Factor__Group_0_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__PowerExpression__Group_1__2__Impl(); + rule__Factor__Group_0_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -33710,30 +34162,30 @@ public final void rule__PowerExpression__Group_1__2() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__PowerExpression__Group_1__2" + // $ANTLR end "rule__Factor__Group_0_1__2" - // $ANTLR start "rule__PowerExpression__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:10080:1: rule__PowerExpression__Group_1__2__Impl : ( ( rule__PowerExpression__RightAssignment_1_2 ) ) ; - public final void rule__PowerExpression__Group_1__2__Impl() 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 ) ) ; + public final void rule__Factor__Group_0_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10084:1: ( ( ( rule__PowerExpression__RightAssignment_1_2 ) ) ) - // InternalBehaviorAnnexParser.g:10085:1: ( ( rule__PowerExpression__RightAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:10206:1: ( ( ( rule__Factor__RightAssignment_0_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:10207:1: ( ( rule__Factor__RightAssignment_0_1_2 ) ) { - // InternalBehaviorAnnexParser.g:10085:1: ( ( rule__PowerExpression__RightAssignment_1_2 ) ) - // InternalBehaviorAnnexParser.g:10086:2: ( rule__PowerExpression__RightAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:10207:1: ( ( rule__Factor__RightAssignment_0_1_2 ) ) + // InternalBehaviorAnnexParser.g:10208:2: ( rule__Factor__RightAssignment_0_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getPowerExpressionAccess().getRightAssignment_1_2()); + before(grammarAccess.getFactorAccess().getRightAssignment_0_1_2()); } - // InternalBehaviorAnnexParser.g:10087:2: ( rule__PowerExpression__RightAssignment_1_2 ) - // InternalBehaviorAnnexParser.g:10087:3: rule__PowerExpression__RightAssignment_1_2 + // InternalBehaviorAnnexParser.g:10209:2: ( rule__Factor__RightAssignment_0_1_2 ) + // InternalBehaviorAnnexParser.g:10209:3: rule__Factor__RightAssignment_0_1_2 { pushFollow(FollowSets000.FOLLOW_2); - rule__PowerExpression__RightAssignment_1_2(); + rule__Factor__RightAssignment_0_1_2(); state._fsp--; if (state.failed) return ; @@ -33741,7 +34193,7 @@ public final void rule__PowerExpression__Group_1__2__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getPowerExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getFactorAccess().getRightAssignment_0_1_2()); } } @@ -33761,26 +34213,26 @@ public final void rule__PowerExpression__Group_1__2__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__PowerExpression__Group_1__2__Impl" + // $ANTLR end "rule__Factor__Group_0_1__2__Impl" - // $ANTLR start "rule__UnaryExpression__Group_0__0" - // InternalBehaviorAnnexParser.g:10096:1: rule__UnaryExpression__Group_0__0 : rule__UnaryExpression__Group_0__0__Impl rule__UnaryExpression__Group_0__1 ; - public final void rule__UnaryExpression__Group_0__0() 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 ; + public final void rule__Factor__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10100:1: ( rule__UnaryExpression__Group_0__0__Impl rule__UnaryExpression__Group_0__1 ) - // InternalBehaviorAnnexParser.g:10101:2: rule__UnaryExpression__Group_0__0__Impl rule__UnaryExpression__Group_0__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_67); - rule__UnaryExpression__Group_0__0__Impl(); + pushFollow(FollowSets000.FOLLOW_47); + rule__Factor__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__UnaryExpression__Group_0__1(); + rule__Factor__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -33799,32 +34251,32 @@ public final void rule__UnaryExpression__Group_0__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__UnaryExpression__Group_0__0" + // $ANTLR end "rule__Factor__Group_1__0" - // $ANTLR start "rule__UnaryExpression__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:10108:1: rule__UnaryExpression__Group_0__0__Impl : ( () ) ; - public final void rule__UnaryExpression__Group_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Factor__Group_1__0__Impl" + // InternalBehaviorAnnexParser.g:10230:1: rule__Factor__Group_1__0__Impl : ( () ) ; + public final void rule__Factor__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10112:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:10113:1: ( () ) + // InternalBehaviorAnnexParser.g:10234:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:10235:1: ( () ) { - // InternalBehaviorAnnexParser.g:10113:1: ( () ) - // InternalBehaviorAnnexParser.g:10114:2: () + // InternalBehaviorAnnexParser.g:10235:1: ( () ) + // InternalBehaviorAnnexParser.g:10236:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_0_0()); + before(grammarAccess.getFactorAccess().getUnaryExpressionAction_1_0()); } - // InternalBehaviorAnnexParser.g:10115:2: () - // InternalBehaviorAnnexParser.g:10115:3: + // InternalBehaviorAnnexParser.g:10237:2: () + // InternalBehaviorAnnexParser.g:10237:3: { } if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_0_0()); + after(grammarAccess.getFactorAccess().getUnaryExpressionAction_1_0()); } } @@ -33840,26 +34292,26 @@ public final void rule__UnaryExpression__Group_0__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__UnaryExpression__Group_0__0__Impl" + // $ANTLR end "rule__Factor__Group_1__0__Impl" - // $ANTLR start "rule__UnaryExpression__Group_0__1" - // InternalBehaviorAnnexParser.g:10123:1: rule__UnaryExpression__Group_0__1 : rule__UnaryExpression__Group_0__1__Impl rule__UnaryExpression__Group_0__2 ; - public final void rule__UnaryExpression__Group_0__1() 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 ; + public final void rule__Factor__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10127:1: ( rule__UnaryExpression__Group_0__1__Impl rule__UnaryExpression__Group_0__2 ) - // InternalBehaviorAnnexParser.g:10128:2: rule__UnaryExpression__Group_0__1__Impl rule__UnaryExpression__Group_0__2 + // 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 { - pushFollow(FollowSets000.FOLLOW_47); - rule__UnaryExpression__Group_0__1__Impl(); + pushFollow(FollowSets000.FOLLOW_29); + rule__Factor__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__UnaryExpression__Group_0__2(); + rule__Factor__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -33878,30 +34330,30 @@ public final void rule__UnaryExpression__Group_0__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__UnaryExpression__Group_0__1" + // $ANTLR end "rule__Factor__Group_1__1" - // $ANTLR start "rule__UnaryExpression__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:10135:1: rule__UnaryExpression__Group_0__1__Impl : ( ( rule__UnaryExpression__OperatorAssignment_0_1 ) ) ; - public final void rule__UnaryExpression__Group_0__1__Impl() 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 ) ) ; + public final void rule__Factor__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10139:1: ( ( ( rule__UnaryExpression__OperatorAssignment_0_1 ) ) ) - // InternalBehaviorAnnexParser.g:10140:1: ( ( rule__UnaryExpression__OperatorAssignment_0_1 ) ) + // InternalBehaviorAnnexParser.g:10261:1: ( ( ( rule__Factor__OperatorAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:10262:1: ( ( rule__Factor__OperatorAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:10140:1: ( ( rule__UnaryExpression__OperatorAssignment_0_1 ) ) - // InternalBehaviorAnnexParser.g:10141:2: ( rule__UnaryExpression__OperatorAssignment_0_1 ) + // InternalBehaviorAnnexParser.g:10262:1: ( ( rule__Factor__OperatorAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:10263:2: ( rule__Factor__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getOperatorAssignment_0_1()); + before(grammarAccess.getFactorAccess().getOperatorAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:10142:2: ( rule__UnaryExpression__OperatorAssignment_0_1 ) - // InternalBehaviorAnnexParser.g:10142:3: rule__UnaryExpression__OperatorAssignment_0_1 + // InternalBehaviorAnnexParser.g:10264:2: ( rule__Factor__OperatorAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:10264:3: rule__Factor__OperatorAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); - rule__UnaryExpression__OperatorAssignment_0_1(); + rule__Factor__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; @@ -33909,7 +34361,7 @@ public final void rule__UnaryExpression__Group_0__1__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getOperatorAssignment_0_1()); + after(grammarAccess.getFactorAccess().getOperatorAssignment_1_1()); } } @@ -33929,21 +34381,21 @@ public final void rule__UnaryExpression__Group_0__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__UnaryExpression__Group_0__1__Impl" + // $ANTLR end "rule__Factor__Group_1__1__Impl" - // $ANTLR start "rule__UnaryExpression__Group_0__2" - // InternalBehaviorAnnexParser.g:10150:1: rule__UnaryExpression__Group_0__2 : rule__UnaryExpression__Group_0__2__Impl ; - public final void rule__UnaryExpression__Group_0__2() throws RecognitionException { + // $ANTLR start "rule__Factor__Group_1__2" + // InternalBehaviorAnnexParser.g:10272: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:10154:1: ( rule__UnaryExpression__Group_0__2__Impl ) - // InternalBehaviorAnnexParser.g:10155:2: rule__UnaryExpression__Group_0__2__Impl + // InternalBehaviorAnnexParser.g:10276:1: ( rule__Factor__Group_1__2__Impl ) + // InternalBehaviorAnnexParser.g:10277:2: rule__Factor__Group_1__2__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__UnaryExpression__Group_0__2__Impl(); + rule__Factor__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -33962,30 +34414,30 @@ public final void rule__UnaryExpression__Group_0__2() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__UnaryExpression__Group_0__2" + // $ANTLR end "rule__Factor__Group_1__2" - // $ANTLR start "rule__UnaryExpression__Group_0__2__Impl" - // InternalBehaviorAnnexParser.g:10161:1: rule__UnaryExpression__Group_0__2__Impl : ( ( rule__UnaryExpression__OperandAssignment_0_2 ) ) ; - public final void rule__UnaryExpression__Group_0__2__Impl() 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 ) ) ; + public final void rule__Factor__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10165:1: ( ( ( rule__UnaryExpression__OperandAssignment_0_2 ) ) ) - // InternalBehaviorAnnexParser.g:10166:1: ( ( rule__UnaryExpression__OperandAssignment_0_2 ) ) + // InternalBehaviorAnnexParser.g:10287:1: ( ( ( rule__Factor__OperandAssignment_1_2 ) ) ) + // InternalBehaviorAnnexParser.g:10288:1: ( ( rule__Factor__OperandAssignment_1_2 ) ) { - // InternalBehaviorAnnexParser.g:10166:1: ( ( rule__UnaryExpression__OperandAssignment_0_2 ) ) - // InternalBehaviorAnnexParser.g:10167:2: ( rule__UnaryExpression__OperandAssignment_0_2 ) + // InternalBehaviorAnnexParser.g:10288:1: ( ( rule__Factor__OperandAssignment_1_2 ) ) + // InternalBehaviorAnnexParser.g:10289:2: ( rule__Factor__OperandAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getOperandAssignment_0_2()); + before(grammarAccess.getFactorAccess().getOperandAssignment_1_2()); } - // InternalBehaviorAnnexParser.g:10168:2: ( rule__UnaryExpression__OperandAssignment_0_2 ) - // InternalBehaviorAnnexParser.g:10168:3: rule__UnaryExpression__OperandAssignment_0_2 + // InternalBehaviorAnnexParser.g:10290:2: ( rule__Factor__OperandAssignment_1_2 ) + // InternalBehaviorAnnexParser.g:10290:3: rule__Factor__OperandAssignment_1_2 { pushFollow(FollowSets000.FOLLOW_2); - rule__UnaryExpression__OperandAssignment_0_2(); + rule__Factor__OperandAssignment_1_2(); state._fsp--; if (state.failed) return ; @@ -33993,7 +34445,7 @@ public final void rule__UnaryExpression__Group_0__2__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getOperandAssignment_0_2()); + after(grammarAccess.getFactorAccess().getOperandAssignment_1_2()); } } @@ -34013,26 +34465,26 @@ public final void rule__UnaryExpression__Group_0__2__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__UnaryExpression__Group_0__2__Impl" + // $ANTLR end "rule__Factor__Group_1__2__Impl" - // $ANTLR start "rule__PrimaryExpression__Group_2__0" - // InternalBehaviorAnnexParser.g:10177:1: rule__PrimaryExpression__Group_2__0 : rule__PrimaryExpression__Group_2__0__Impl rule__PrimaryExpression__Group_2__1 ; - public final void rule__PrimaryExpression__Group_2__0() 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 ; + public final void rule__ParenthesizedExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10181:1: ( rule__PrimaryExpression__Group_2__0__Impl rule__PrimaryExpression__Group_2__1 ) - // InternalBehaviorAnnexParser.g:10182:2: rule__PrimaryExpression__Group_2__0__Impl rule__PrimaryExpression__Group_2__1 + // 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 { pushFollow(FollowSets000.FOLLOW_47); - rule__PrimaryExpression__Group_2__0__Impl(); + rule__ParenthesizedExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__PrimaryExpression__Group_2__1(); + rule__ParenthesizedExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -34051,28 +34503,28 @@ public final void rule__PrimaryExpression__Group_2__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__PrimaryExpression__Group_2__0" + // $ANTLR end "rule__ParenthesizedExpression__Group__0" - // $ANTLR start "rule__PrimaryExpression__Group_2__0__Impl" - // InternalBehaviorAnnexParser.g:10189:1: rule__PrimaryExpression__Group_2__0__Impl : ( LeftParenthesis ) ; - public final void rule__PrimaryExpression__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ParenthesizedExpression__Group__0__Impl" + // InternalBehaviorAnnexParser.g:10311:1: rule__ParenthesizedExpression__Group__0__Impl : ( LeftParenthesis ) ; + public final void rule__ParenthesizedExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10193:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:10194:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:10315:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:10316:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:10194:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:10195:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:10316:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:10317:2: LeftParenthesis { if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_2_0()); + before(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } match(input,LeftParenthesis,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_2_0()); + after(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } } @@ -34092,26 +34544,26 @@ public final void rule__PrimaryExpression__Group_2__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__PrimaryExpression__Group_2__0__Impl" + // $ANTLR end "rule__ParenthesizedExpression__Group__0__Impl" - // $ANTLR start "rule__PrimaryExpression__Group_2__1" - // InternalBehaviorAnnexParser.g:10204:1: rule__PrimaryExpression__Group_2__1 : rule__PrimaryExpression__Group_2__1__Impl rule__PrimaryExpression__Group_2__2 ; - public final void rule__PrimaryExpression__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__ParenthesizedExpression__Group__1" + // InternalBehaviorAnnexParser.g:10326: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:10208:1: ( rule__PrimaryExpression__Group_2__1__Impl rule__PrimaryExpression__Group_2__2 ) - // InternalBehaviorAnnexParser.g:10209:2: rule__PrimaryExpression__Group_2__1__Impl rule__PrimaryExpression__Group_2__2 + // 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 { pushFollow(FollowSets000.FOLLOW_37); - rule__PrimaryExpression__Group_2__1__Impl(); + rule__ParenthesizedExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FollowSets000.FOLLOW_2); - rule__PrimaryExpression__Group_2__2(); + rule__ParenthesizedExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -34130,32 +34582,38 @@ public final void rule__PrimaryExpression__Group_2__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__PrimaryExpression__Group_2__1" + // $ANTLR end "rule__ParenthesizedExpression__Group__1" - // $ANTLR start "rule__PrimaryExpression__Group_2__1__Impl" - // InternalBehaviorAnnexParser.g:10216:1: rule__PrimaryExpression__Group_2__1__Impl : ( ruleValueExpression ) ; - public final void rule__PrimaryExpression__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ParenthesizedExpression__Group__1__Impl" + // InternalBehaviorAnnexParser.g:10338: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:10220:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:10221:1: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:10342:1: ( ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10343:1: ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10221:1: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:10222:2: ruleValueExpression + // InternalBehaviorAnnexParser.g:10343:1: ( ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10344:2: ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getValueExpressionParserRuleCall_2_1()); + before(grammarAccess.getParenthesizedExpressionAccess().getExpressionAssignment_1()); } + // InternalBehaviorAnnexParser.g:10345:2: ( rule__ParenthesizedExpression__ExpressionAssignment_1 ) + // InternalBehaviorAnnexParser.g:10345:3: rule__ParenthesizedExpression__ExpressionAssignment_1 + { pushFollow(FollowSets000.FOLLOW_2); - ruleValueExpression(); + rule__ParenthesizedExpression__ExpressionAssignment_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getValueExpressionParserRuleCall_2_1()); + after(grammarAccess.getParenthesizedExpressionAccess().getExpressionAssignment_1()); } } @@ -34175,21 +34633,21 @@ public final void rule__PrimaryExpression__Group_2__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__PrimaryExpression__Group_2__1__Impl" + // $ANTLR end "rule__ParenthesizedExpression__Group__1__Impl" - // $ANTLR start "rule__PrimaryExpression__Group_2__2" - // InternalBehaviorAnnexParser.g:10231:1: rule__PrimaryExpression__Group_2__2 : rule__PrimaryExpression__Group_2__2__Impl ; - public final void rule__PrimaryExpression__Group_2__2() throws RecognitionException { + // $ANTLR start "rule__ParenthesizedExpression__Group__2" + // InternalBehaviorAnnexParser.g:10353: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:10235:1: ( rule__PrimaryExpression__Group_2__2__Impl ) - // InternalBehaviorAnnexParser.g:10236:2: rule__PrimaryExpression__Group_2__2__Impl + // InternalBehaviorAnnexParser.g:10357:1: ( rule__ParenthesizedExpression__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:10358:2: rule__ParenthesizedExpression__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); - rule__PrimaryExpression__Group_2__2__Impl(); + rule__ParenthesizedExpression__Group__2__Impl(); state._fsp--; if (state.failed) return ; @@ -34208,28 +34666,28 @@ public final void rule__PrimaryExpression__Group_2__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__PrimaryExpression__Group_2__2" + // $ANTLR end "rule__ParenthesizedExpression__Group__2" - // $ANTLR start "rule__PrimaryExpression__Group_2__2__Impl" - // InternalBehaviorAnnexParser.g:10242:1: rule__PrimaryExpression__Group_2__2__Impl : ( RightParenthesis ) ; - public final void rule__PrimaryExpression__Group_2__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ParenthesizedExpression__Group__2__Impl" + // InternalBehaviorAnnexParser.g:10364:1: rule__ParenthesizedExpression__Group__2__Impl : ( RightParenthesis ) ; + public final void rule__ParenthesizedExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10246:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:10247:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:10368:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:10369:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:10247:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:10248:2: RightParenthesis + // InternalBehaviorAnnexParser.g:10369:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:10370:2: RightParenthesis { if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_2_2()); + before(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); } match(input,RightParenthesis,FollowSets000.FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_2_2()); + after(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); } } @@ -34249,20 +34707,20 @@ public final void rule__PrimaryExpression__Group_2__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__PrimaryExpression__Group_2__2__Impl" + // $ANTLR end "rule__ParenthesizedExpression__Group__2__Impl" // $ANTLR start "rule__BehaviorBooleanLiteral__Group__0" - // InternalBehaviorAnnexParser.g:10258:1: rule__BehaviorBooleanLiteral__Group__0 : rule__BehaviorBooleanLiteral__Group__0__Impl rule__BehaviorBooleanLiteral__Group__1 ; + // InternalBehaviorAnnexParser.g:10380: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:10262:1: ( rule__BehaviorBooleanLiteral__Group__0__Impl rule__BehaviorBooleanLiteral__Group__1 ) - // InternalBehaviorAnnexParser.g:10263:2: rule__BehaviorBooleanLiteral__Group__0__Impl rule__BehaviorBooleanLiteral__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_68); + pushFollow(FollowSets000.FOLLOW_69); rule__BehaviorBooleanLiteral__Group__0__Impl(); state._fsp--; @@ -34291,23 +34749,23 @@ public final void rule__BehaviorBooleanLiteral__Group__0() throws RecognitionExc // $ANTLR start "rule__BehaviorBooleanLiteral__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10270:1: rule__BehaviorBooleanLiteral__Group__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:10392:1: rule__BehaviorBooleanLiteral__Group__0__Impl : ( () ) ; public final void rule__BehaviorBooleanLiteral__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10274:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:10275:1: ( () ) + // InternalBehaviorAnnexParser.g:10396:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:10397:1: ( () ) { - // InternalBehaviorAnnexParser.g:10275:1: ( () ) - // InternalBehaviorAnnexParser.g:10276:2: () + // InternalBehaviorAnnexParser.g:10397:1: ( () ) + // InternalBehaviorAnnexParser.g:10398:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getBehaviorBooleanLiteralAction_0()); } - // InternalBehaviorAnnexParser.g:10277:2: () - // InternalBehaviorAnnexParser.g:10277:3: + // InternalBehaviorAnnexParser.g:10399:2: () + // InternalBehaviorAnnexParser.g:10399:3: { } @@ -34332,14 +34790,14 @@ public final void rule__BehaviorBooleanLiteral__Group__0__Impl() throws Recognit // $ANTLR start "rule__BehaviorBooleanLiteral__Group__1" - // InternalBehaviorAnnexParser.g:10285:1: rule__BehaviorBooleanLiteral__Group__1 : rule__BehaviorBooleanLiteral__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:10407: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:10289:1: ( rule__BehaviorBooleanLiteral__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:10290:2: rule__BehaviorBooleanLiteral__Group__1__Impl + // InternalBehaviorAnnexParser.g:10411:1: ( rule__BehaviorBooleanLiteral__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:10412:2: rule__BehaviorBooleanLiteral__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorBooleanLiteral__Group__1__Impl(); @@ -34365,23 +34823,23 @@ public final void rule__BehaviorBooleanLiteral__Group__1() throws RecognitionExc // $ANTLR start "rule__BehaviorBooleanLiteral__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10296:1: rule__BehaviorBooleanLiteral__Group__1__Impl : ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) ; + // InternalBehaviorAnnexParser.g:10418: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:10300:1: ( ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) ) - // InternalBehaviorAnnexParser.g:10301:1: ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:10422:1: ( ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) ) + // InternalBehaviorAnnexParser.g:10423:1: ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) { - // InternalBehaviorAnnexParser.g:10301:1: ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) - // InternalBehaviorAnnexParser.g:10302:2: ( rule__BehaviorBooleanLiteral__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:10423:1: ( ( rule__BehaviorBooleanLiteral__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:10424:2: ( rule__BehaviorBooleanLiteral__Alternatives_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:10303:2: ( rule__BehaviorBooleanLiteral__Alternatives_1 ) - // InternalBehaviorAnnexParser.g:10303:3: rule__BehaviorBooleanLiteral__Alternatives_1 + // InternalBehaviorAnnexParser.g:10425:2: ( rule__BehaviorBooleanLiteral__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:10425:3: rule__BehaviorBooleanLiteral__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BehaviorBooleanLiteral__Alternatives_1(); @@ -34416,16 +34874,16 @@ public final void rule__BehaviorBooleanLiteral__Group__1__Impl() throws Recognit // $ANTLR start "rule__ReferenceExpression__Group__0" - // InternalBehaviorAnnexParser.g:10312:1: rule__ReferenceExpression__Group__0 : rule__ReferenceExpression__Group__0__Impl rule__ReferenceExpression__Group__1 ; + // InternalBehaviorAnnexParser.g:10434: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:10316:1: ( rule__ReferenceExpression__Group__0__Impl rule__ReferenceExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:10317:2: rule__ReferenceExpression__Group__0__Impl rule__ReferenceExpression__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_69); + pushFollow(FollowSets000.FOLLOW_70); rule__ReferenceExpression__Group__0__Impl(); state._fsp--; @@ -34454,23 +34912,23 @@ public final void rule__ReferenceExpression__Group__0() throws RecognitionExcept // $ANTLR start "rule__ReferenceExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10324:1: rule__ReferenceExpression__Group__0__Impl : ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:10446: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:10328:1: ( ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:10329:1: ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:10450:1: ( ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:10451:1: ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:10329:1: ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:10330:2: ( rule__ReferenceExpression__ReferenceAssignment_0 ) + // InternalBehaviorAnnexParser.g:10451:1: ( ( rule__ReferenceExpression__ReferenceAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:10452:2: ( rule__ReferenceExpression__ReferenceAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getReferenceAssignment_0()); } - // InternalBehaviorAnnexParser.g:10331:2: ( rule__ReferenceExpression__ReferenceAssignment_0 ) - // InternalBehaviorAnnexParser.g:10331:3: rule__ReferenceExpression__ReferenceAssignment_0 + // InternalBehaviorAnnexParser.g:10453:2: ( rule__ReferenceExpression__ReferenceAssignment_0 ) + // InternalBehaviorAnnexParser.g:10453:3: rule__ReferenceExpression__ReferenceAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__ReferenceAssignment_0(); @@ -34505,14 +34963,14 @@ public final void rule__ReferenceExpression__Group__0__Impl() throws Recognition // $ANTLR start "rule__ReferenceExpression__Group__1" - // InternalBehaviorAnnexParser.g:10339:1: rule__ReferenceExpression__Group__1 : rule__ReferenceExpression__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:10461: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:10343:1: ( rule__ReferenceExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:10344:2: rule__ReferenceExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:10465:1: ( rule__ReferenceExpression__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:10466:2: rule__ReferenceExpression__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__Group__1__Impl(); @@ -34538,31 +34996,31 @@ public final void rule__ReferenceExpression__Group__1() throws RecognitionExcept // $ANTLR start "rule__ReferenceExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10350:1: rule__ReferenceExpression__Group__1__Impl : ( ( rule__ReferenceExpression__Alternatives_1 )? ) ; + // InternalBehaviorAnnexParser.g:10472: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:10354:1: ( ( ( rule__ReferenceExpression__Alternatives_1 )? ) ) - // InternalBehaviorAnnexParser.g:10355:1: ( ( rule__ReferenceExpression__Alternatives_1 )? ) + // InternalBehaviorAnnexParser.g:10476:1: ( ( ( rule__ReferenceExpression__Alternatives_1 )? ) ) + // InternalBehaviorAnnexParser.g:10477:1: ( ( rule__ReferenceExpression__Alternatives_1 )? ) { - // InternalBehaviorAnnexParser.g:10355:1: ( ( rule__ReferenceExpression__Alternatives_1 )? ) - // InternalBehaviorAnnexParser.g:10356:2: ( rule__ReferenceExpression__Alternatives_1 )? + // InternalBehaviorAnnexParser.g:10477:1: ( ( rule__ReferenceExpression__Alternatives_1 )? ) + // InternalBehaviorAnnexParser.g:10478:2: ( rule__ReferenceExpression__Alternatives_1 )? { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:10357:2: ( rule__ReferenceExpression__Alternatives_1 )? - int alt88=2; - int LA88_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:10479:2: ( rule__ReferenceExpression__Alternatives_1 )? + int alt90=2; + int LA90_0 = input.LA(1); - if ( (LA88_0==NumberSign||LA88_0==Apostrophe||LA88_0==QuestionMark) ) { - alt88=1; + if ( (LA90_0==NumberSign||LA90_0==Apostrophe||LA90_0==QuestionMark) ) { + alt90=1; } - switch (alt88) { + switch (alt90) { case 1 : - // InternalBehaviorAnnexParser.g:10357:3: rule__ReferenceExpression__Alternatives_1 + // InternalBehaviorAnnexParser.g:10479:3: rule__ReferenceExpression__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__Alternatives_1(); @@ -34600,16 +35058,16 @@ public final void rule__ReferenceExpression__Group__1__Impl() throws Recognition // $ANTLR start "rule__ReferenceExpression__Group_1_2__0" - // InternalBehaviorAnnexParser.g:10366:1: rule__ReferenceExpression__Group_1_2__0 : rule__ReferenceExpression__Group_1_2__0__Impl rule__ReferenceExpression__Group_1_2__1 ; + // InternalBehaviorAnnexParser.g:10488: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:10370:1: ( rule__ReferenceExpression__Group_1_2__0__Impl rule__ReferenceExpression__Group_1_2__1 ) - // InternalBehaviorAnnexParser.g:10371:2: rule__ReferenceExpression__Group_1_2__0__Impl rule__ReferenceExpression__Group_1_2__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_70); + pushFollow(FollowSets000.FOLLOW_71); rule__ReferenceExpression__Group_1_2__0__Impl(); state._fsp--; @@ -34638,17 +35096,17 @@ public final void rule__ReferenceExpression__Group_1_2__0() throws RecognitionEx // $ANTLR start "rule__ReferenceExpression__Group_1_2__0__Impl" - // InternalBehaviorAnnexParser.g:10378:1: rule__ReferenceExpression__Group_1_2__0__Impl : ( Apostrophe ) ; + // InternalBehaviorAnnexParser.g:10500: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:10382:1: ( ( Apostrophe ) ) - // InternalBehaviorAnnexParser.g:10383:1: ( Apostrophe ) + // InternalBehaviorAnnexParser.g:10504:1: ( ( Apostrophe ) ) + // InternalBehaviorAnnexParser.g:10505:1: ( Apostrophe ) { - // InternalBehaviorAnnexParser.g:10383:1: ( Apostrophe ) - // InternalBehaviorAnnexParser.g:10384:2: Apostrophe + // InternalBehaviorAnnexParser.g:10505:1: ( Apostrophe ) + // InternalBehaviorAnnexParser.g:10506:2: Apostrophe { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getApostropheKeyword_1_2_0()); @@ -34679,14 +35137,14 @@ public final void rule__ReferenceExpression__Group_1_2__0__Impl() throws Recogni // $ANTLR start "rule__ReferenceExpression__Group_1_2__1" - // InternalBehaviorAnnexParser.g:10393:1: rule__ReferenceExpression__Group_1_2__1 : rule__ReferenceExpression__Group_1_2__1__Impl ; + // InternalBehaviorAnnexParser.g:10515: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:10397:1: ( rule__ReferenceExpression__Group_1_2__1__Impl ) - // InternalBehaviorAnnexParser.g:10398:2: rule__ReferenceExpression__Group_1_2__1__Impl + // InternalBehaviorAnnexParser.g:10519:1: ( rule__ReferenceExpression__Group_1_2__1__Impl ) + // InternalBehaviorAnnexParser.g:10520:2: rule__ReferenceExpression__Group_1_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__Group_1_2__1__Impl(); @@ -34712,23 +35170,23 @@ public final void rule__ReferenceExpression__Group_1_2__1() throws RecognitionEx // $ANTLR start "rule__ReferenceExpression__Group_1_2__1__Impl" - // InternalBehaviorAnnexParser.g:10404:1: rule__ReferenceExpression__Group_1_2__1__Impl : ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) ; + // InternalBehaviorAnnexParser.g:10526: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:10408:1: ( ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) ) - // InternalBehaviorAnnexParser.g:10409:1: ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) + // InternalBehaviorAnnexParser.g:10530:1: ( ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) ) + // InternalBehaviorAnnexParser.g:10531:1: ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) { - // InternalBehaviorAnnexParser.g:10409:1: ( ( rule__ReferenceExpression__Alternatives_1_2_1 ) ) - // InternalBehaviorAnnexParser.g:10410:2: ( 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 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getAlternatives_1_2_1()); } - // InternalBehaviorAnnexParser.g:10411:2: ( rule__ReferenceExpression__Alternatives_1_2_1 ) - // InternalBehaviorAnnexParser.g:10411:3: rule__ReferenceExpression__Alternatives_1_2_1 + // InternalBehaviorAnnexParser.g:10533:2: ( rule__ReferenceExpression__Alternatives_1_2_1 ) + // InternalBehaviorAnnexParser.g:10533:3: rule__ReferenceExpression__Alternatives_1_2_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceExpression__Alternatives_1_2_1(); @@ -34763,14 +35221,14 @@ public final void rule__ReferenceExpression__Group_1_2__1__Impl() throws Recogni // $ANTLR start "rule__HashPropertyReference__Group__0" - // InternalBehaviorAnnexParser.g:10420:1: rule__HashPropertyReference__Group__0 : rule__HashPropertyReference__Group__0__Impl rule__HashPropertyReference__Group__1 ; + // InternalBehaviorAnnexParser.g:10542: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:10424:1: ( rule__HashPropertyReference__Group__0__Impl rule__HashPropertyReference__Group__1 ) - // InternalBehaviorAnnexParser.g:10425:2: rule__HashPropertyReference__Group__0__Impl rule__HashPropertyReference__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__HashPropertyReference__Group__0__Impl(); @@ -34801,17 +35259,17 @@ public final void rule__HashPropertyReference__Group__0() throws RecognitionExce // $ANTLR start "rule__HashPropertyReference__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10432:1: rule__HashPropertyReference__Group__0__Impl : ( NumberSign ) ; + // InternalBehaviorAnnexParser.g:10554:1: rule__HashPropertyReference__Group__0__Impl : ( NumberSign ) ; public final void rule__HashPropertyReference__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10436:1: ( ( NumberSign ) ) - // InternalBehaviorAnnexParser.g:10437:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10558:1: ( ( NumberSign ) ) + // InternalBehaviorAnnexParser.g:10559:1: ( NumberSign ) { - // InternalBehaviorAnnexParser.g:10437:1: ( NumberSign ) - // InternalBehaviorAnnexParser.g:10438:2: NumberSign + // InternalBehaviorAnnexParser.g:10559:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10560:2: NumberSign { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getNumberSignKeyword_0()); @@ -34842,16 +35300,16 @@ public final void rule__HashPropertyReference__Group__0__Impl() throws Recogniti // $ANTLR start "rule__HashPropertyReference__Group__1" - // InternalBehaviorAnnexParser.g:10447:1: rule__HashPropertyReference__Group__1 : rule__HashPropertyReference__Group__1__Impl rule__HashPropertyReference__Group__2 ; + // InternalBehaviorAnnexParser.g:10569: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:10451:1: ( rule__HashPropertyReference__Group__1__Impl rule__HashPropertyReference__Group__2 ) - // InternalBehaviorAnnexParser.g:10452:2: rule__HashPropertyReference__Group__1__Impl rule__HashPropertyReference__Group__2 + // 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 { - pushFollow(FollowSets000.FOLLOW_71); + pushFollow(FollowSets000.FOLLOW_72); rule__HashPropertyReference__Group__1__Impl(); state._fsp--; @@ -34880,23 +35338,23 @@ public final void rule__HashPropertyReference__Group__1() throws RecognitionExce // $ANTLR start "rule__HashPropertyReference__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10459:1: rule__HashPropertyReference__Group__1__Impl : ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10581: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:10463:1: ( ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10464:1: ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10585:1: ( ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10586:1: ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10464:1: ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10465:2: ( rule__HashPropertyReference__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10586:1: ( ( rule__HashPropertyReference__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10587:2: ( rule__HashPropertyReference__PropertyAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getPropertyAssignment_1()); } - // InternalBehaviorAnnexParser.g:10466:2: ( rule__HashPropertyReference__PropertyAssignment_1 ) - // InternalBehaviorAnnexParser.g:10466:3: rule__HashPropertyReference__PropertyAssignment_1 + // InternalBehaviorAnnexParser.g:10588:2: ( rule__HashPropertyReference__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10588:3: rule__HashPropertyReference__PropertyAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__HashPropertyReference__PropertyAssignment_1(); @@ -34931,16 +35389,16 @@ public final void rule__HashPropertyReference__Group__1__Impl() throws Recogniti // $ANTLR start "rule__HashPropertyReference__Group__2" - // InternalBehaviorAnnexParser.g:10474:1: rule__HashPropertyReference__Group__2 : rule__HashPropertyReference__Group__2__Impl rule__HashPropertyReference__Group__3 ; + // InternalBehaviorAnnexParser.g:10596: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:10478:1: ( rule__HashPropertyReference__Group__2__Impl rule__HashPropertyReference__Group__3 ) - // InternalBehaviorAnnexParser.g:10479:2: rule__HashPropertyReference__Group__2__Impl rule__HashPropertyReference__Group__3 + // 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 { - pushFollow(FollowSets000.FOLLOW_71); + pushFollow(FollowSets000.FOLLOW_72); rule__HashPropertyReference__Group__2__Impl(); state._fsp--; @@ -34969,35 +35427,35 @@ public final void rule__HashPropertyReference__Group__2() throws RecognitionExce // $ANTLR start "rule__HashPropertyReference__Group__2__Impl" - // InternalBehaviorAnnexParser.g:10486:1: rule__HashPropertyReference__Group__2__Impl : ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) ; + // InternalBehaviorAnnexParser.g:10608: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:10490:1: ( ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) ) - // InternalBehaviorAnnexParser.g:10491:1: ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10612:1: ( ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) ) + // InternalBehaviorAnnexParser.g:10613:1: ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) { - // InternalBehaviorAnnexParser.g:10491:1: ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) - // InternalBehaviorAnnexParser.g:10492:2: ( rule__HashPropertyReference__IndexesAssignment_2 )* + // InternalBehaviorAnnexParser.g:10613:1: ( ( rule__HashPropertyReference__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10614:2: ( rule__HashPropertyReference__IndexesAssignment_2 )* { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getIndexesAssignment_2()); } - // InternalBehaviorAnnexParser.g:10493:2: ( rule__HashPropertyReference__IndexesAssignment_2 )* - loop89: + // InternalBehaviorAnnexParser.g:10615:2: ( rule__HashPropertyReference__IndexesAssignment_2 )* + loop91: do { - int alt89=2; - int LA89_0 = input.LA(1); + int alt91=2; + int LA91_0 = input.LA(1); - if ( (LA89_0==LeftSquareBracket) ) { - alt89=1; + if ( (LA91_0==LeftSquareBracket) ) { + alt91=1; } - switch (alt89) { + switch (alt91) { case 1 : - // InternalBehaviorAnnexParser.g:10493:3: rule__HashPropertyReference__IndexesAssignment_2 + // InternalBehaviorAnnexParser.g:10615:3: rule__HashPropertyReference__IndexesAssignment_2 { pushFollow(FollowSets000.FOLLOW_12); rule__HashPropertyReference__IndexesAssignment_2(); @@ -35009,7 +35467,7 @@ public final void rule__HashPropertyReference__Group__2__Impl() throws Recogniti break; default : - break loop89; + break loop91; } } while (true); @@ -35038,14 +35496,14 @@ public final void rule__HashPropertyReference__Group__2__Impl() throws Recogniti // $ANTLR start "rule__HashPropertyReference__Group__3" - // InternalBehaviorAnnexParser.g:10501:1: rule__HashPropertyReference__Group__3 : rule__HashPropertyReference__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:10623: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:10505:1: ( rule__HashPropertyReference__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:10506:2: rule__HashPropertyReference__Group__3__Impl + // InternalBehaviorAnnexParser.g:10627:1: ( rule__HashPropertyReference__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:10628:2: rule__HashPropertyReference__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__HashPropertyReference__Group__3__Impl(); @@ -35071,37 +35529,37 @@ public final void rule__HashPropertyReference__Group__3() throws RecognitionExce // $ANTLR start "rule__HashPropertyReference__Group__3__Impl" - // InternalBehaviorAnnexParser.g:10512:1: rule__HashPropertyReference__Group__3__Impl : ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) ; + // InternalBehaviorAnnexParser.g:10634: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:10516:1: ( ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) ) - // InternalBehaviorAnnexParser.g:10517:1: ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) + // InternalBehaviorAnnexParser.g:10638:1: ( ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) ) + // InternalBehaviorAnnexParser.g:10639:1: ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) { - // InternalBehaviorAnnexParser.g:10517:1: ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) - // InternalBehaviorAnnexParser.g:10518:2: ( rule__HashPropertyReference__FieldsAssignment_3 )* + // InternalBehaviorAnnexParser.g:10639:1: ( ( rule__HashPropertyReference__FieldsAssignment_3 )* ) + // InternalBehaviorAnnexParser.g:10640:2: ( rule__HashPropertyReference__FieldsAssignment_3 )* { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getFieldsAssignment_3()); } - // InternalBehaviorAnnexParser.g:10519:2: ( rule__HashPropertyReference__FieldsAssignment_3 )* - loop90: + // InternalBehaviorAnnexParser.g:10641:2: ( rule__HashPropertyReference__FieldsAssignment_3 )* + loop92: do { - int alt90=2; - int LA90_0 = input.LA(1); + int alt92=2; + int LA92_0 = input.LA(1); - if ( (LA90_0==FullStop) ) { - alt90=1; + if ( (LA92_0==FullStop) ) { + alt92=1; } - switch (alt90) { + switch (alt92) { case 1 : - // InternalBehaviorAnnexParser.g:10519:3: rule__HashPropertyReference__FieldsAssignment_3 + // InternalBehaviorAnnexParser.g:10641:3: rule__HashPropertyReference__FieldsAssignment_3 { - pushFollow(FollowSets000.FOLLOW_72); + pushFollow(FollowSets000.FOLLOW_73); rule__HashPropertyReference__FieldsAssignment_3(); state._fsp--; @@ -35111,7 +35569,7 @@ public final void rule__HashPropertyReference__Group__3__Impl() throws Recogniti break; default : - break loop90; + break loop92; } } while (true); @@ -35140,14 +35598,14 @@ public final void rule__HashPropertyReference__Group__3__Impl() throws Recogniti // $ANTLR start "rule__PropertyReferenceTail__Group__0" - // InternalBehaviorAnnexParser.g:10528:1: rule__PropertyReferenceTail__Group__0 : rule__PropertyReferenceTail__Group__0__Impl rule__PropertyReferenceTail__Group__1 ; + // InternalBehaviorAnnexParser.g:10650: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:10532:1: ( rule__PropertyReferenceTail__Group__0__Impl rule__PropertyReferenceTail__Group__1 ) - // InternalBehaviorAnnexParser.g:10533:2: rule__PropertyReferenceTail__Group__0__Impl rule__PropertyReferenceTail__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__PropertyReferenceTail__Group__0__Impl(); @@ -35178,17 +35636,17 @@ public final void rule__PropertyReferenceTail__Group__0() throws RecognitionExce // $ANTLR start "rule__PropertyReferenceTail__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10540:1: rule__PropertyReferenceTail__Group__0__Impl : ( NumberSign ) ; + // InternalBehaviorAnnexParser.g:10662:1: rule__PropertyReferenceTail__Group__0__Impl : ( NumberSign ) ; public final void rule__PropertyReferenceTail__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10544:1: ( ( NumberSign ) ) - // InternalBehaviorAnnexParser.g:10545:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10666:1: ( ( NumberSign ) ) + // InternalBehaviorAnnexParser.g:10667:1: ( NumberSign ) { - // InternalBehaviorAnnexParser.g:10545:1: ( NumberSign ) - // InternalBehaviorAnnexParser.g:10546:2: NumberSign + // InternalBehaviorAnnexParser.g:10667:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10668:2: NumberSign { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getNumberSignKeyword_0()); @@ -35219,16 +35677,16 @@ public final void rule__PropertyReferenceTail__Group__0__Impl() throws Recogniti // $ANTLR start "rule__PropertyReferenceTail__Group__1" - // InternalBehaviorAnnexParser.g:10555:1: rule__PropertyReferenceTail__Group__1 : rule__PropertyReferenceTail__Group__1__Impl rule__PropertyReferenceTail__Group__2 ; + // InternalBehaviorAnnexParser.g:10677: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:10559:1: ( rule__PropertyReferenceTail__Group__1__Impl rule__PropertyReferenceTail__Group__2 ) - // InternalBehaviorAnnexParser.g:10560:2: rule__PropertyReferenceTail__Group__1__Impl rule__PropertyReferenceTail__Group__2 + // 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 { - pushFollow(FollowSets000.FOLLOW_71); + pushFollow(FollowSets000.FOLLOW_72); rule__PropertyReferenceTail__Group__1__Impl(); state._fsp--; @@ -35257,23 +35715,23 @@ public final void rule__PropertyReferenceTail__Group__1() throws RecognitionExce // $ANTLR start "rule__PropertyReferenceTail__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10567:1: rule__PropertyReferenceTail__Group__1__Impl : ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10689: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:10571:1: ( ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10572:1: ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10693:1: ( ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10694:1: ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10572:1: ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10573:2: ( rule__PropertyReferenceTail__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10694:1: ( ( rule__PropertyReferenceTail__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10695:2: ( rule__PropertyReferenceTail__PropertyAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getPropertyAssignment_1()); } - // InternalBehaviorAnnexParser.g:10574:2: ( rule__PropertyReferenceTail__PropertyAssignment_1 ) - // InternalBehaviorAnnexParser.g:10574:3: rule__PropertyReferenceTail__PropertyAssignment_1 + // InternalBehaviorAnnexParser.g:10696:2: ( rule__PropertyReferenceTail__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10696:3: rule__PropertyReferenceTail__PropertyAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyReferenceTail__PropertyAssignment_1(); @@ -35308,16 +35766,16 @@ public final void rule__PropertyReferenceTail__Group__1__Impl() throws Recogniti // $ANTLR start "rule__PropertyReferenceTail__Group__2" - // InternalBehaviorAnnexParser.g:10582:1: rule__PropertyReferenceTail__Group__2 : rule__PropertyReferenceTail__Group__2__Impl rule__PropertyReferenceTail__Group__3 ; + // InternalBehaviorAnnexParser.g:10704: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:10586:1: ( rule__PropertyReferenceTail__Group__2__Impl rule__PropertyReferenceTail__Group__3 ) - // InternalBehaviorAnnexParser.g:10587:2: rule__PropertyReferenceTail__Group__2__Impl rule__PropertyReferenceTail__Group__3 + // 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 { - pushFollow(FollowSets000.FOLLOW_71); + pushFollow(FollowSets000.FOLLOW_72); rule__PropertyReferenceTail__Group__2__Impl(); state._fsp--; @@ -35346,35 +35804,35 @@ public final void rule__PropertyReferenceTail__Group__2() throws RecognitionExce // $ANTLR start "rule__PropertyReferenceTail__Group__2__Impl" - // InternalBehaviorAnnexParser.g:10594:1: rule__PropertyReferenceTail__Group__2__Impl : ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) ; + // InternalBehaviorAnnexParser.g:10716: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:10598:1: ( ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) ) - // InternalBehaviorAnnexParser.g:10599:1: ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10720:1: ( ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) ) + // InternalBehaviorAnnexParser.g:10721:1: ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) { - // InternalBehaviorAnnexParser.g:10599:1: ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) - // InternalBehaviorAnnexParser.g:10600:2: ( rule__PropertyReferenceTail__IndexesAssignment_2 )* + // InternalBehaviorAnnexParser.g:10721:1: ( ( rule__PropertyReferenceTail__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10722:2: ( rule__PropertyReferenceTail__IndexesAssignment_2 )* { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getIndexesAssignment_2()); } - // InternalBehaviorAnnexParser.g:10601:2: ( rule__PropertyReferenceTail__IndexesAssignment_2 )* - loop91: + // InternalBehaviorAnnexParser.g:10723:2: ( rule__PropertyReferenceTail__IndexesAssignment_2 )* + loop93: do { - int alt91=2; - int LA91_0 = input.LA(1); + int alt93=2; + int LA93_0 = input.LA(1); - if ( (LA91_0==LeftSquareBracket) ) { - alt91=1; + if ( (LA93_0==LeftSquareBracket) ) { + alt93=1; } - switch (alt91) { + switch (alt93) { case 1 : - // InternalBehaviorAnnexParser.g:10601:3: rule__PropertyReferenceTail__IndexesAssignment_2 + // InternalBehaviorAnnexParser.g:10723:3: rule__PropertyReferenceTail__IndexesAssignment_2 { pushFollow(FollowSets000.FOLLOW_12); rule__PropertyReferenceTail__IndexesAssignment_2(); @@ -35386,7 +35844,7 @@ public final void rule__PropertyReferenceTail__Group__2__Impl() throws Recogniti break; default : - break loop91; + break loop93; } } while (true); @@ -35415,14 +35873,14 @@ public final void rule__PropertyReferenceTail__Group__2__Impl() throws Recogniti // $ANTLR start "rule__PropertyReferenceTail__Group__3" - // InternalBehaviorAnnexParser.g:10609:1: rule__PropertyReferenceTail__Group__3 : rule__PropertyReferenceTail__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:10731: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:10613:1: ( rule__PropertyReferenceTail__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:10614:2: rule__PropertyReferenceTail__Group__3__Impl + // InternalBehaviorAnnexParser.g:10735:1: ( rule__PropertyReferenceTail__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:10736:2: rule__PropertyReferenceTail__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyReferenceTail__Group__3__Impl(); @@ -35448,37 +35906,37 @@ public final void rule__PropertyReferenceTail__Group__3() throws RecognitionExce // $ANTLR start "rule__PropertyReferenceTail__Group__3__Impl" - // InternalBehaviorAnnexParser.g:10620:1: rule__PropertyReferenceTail__Group__3__Impl : ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) ; + // InternalBehaviorAnnexParser.g:10742: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:10624:1: ( ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) ) - // InternalBehaviorAnnexParser.g:10625:1: ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) + // InternalBehaviorAnnexParser.g:10746:1: ( ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) ) + // InternalBehaviorAnnexParser.g:10747:1: ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) { - // InternalBehaviorAnnexParser.g:10625:1: ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) - // InternalBehaviorAnnexParser.g:10626:2: ( rule__PropertyReferenceTail__FieldsAssignment_3 )* + // InternalBehaviorAnnexParser.g:10747:1: ( ( rule__PropertyReferenceTail__FieldsAssignment_3 )* ) + // InternalBehaviorAnnexParser.g:10748:2: ( rule__PropertyReferenceTail__FieldsAssignment_3 )* { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getFieldsAssignment_3()); } - // InternalBehaviorAnnexParser.g:10627:2: ( rule__PropertyReferenceTail__FieldsAssignment_3 )* - loop92: + // InternalBehaviorAnnexParser.g:10749:2: ( rule__PropertyReferenceTail__FieldsAssignment_3 )* + loop94: do { - int alt92=2; - int LA92_0 = input.LA(1); + int alt94=2; + int LA94_0 = input.LA(1); - if ( (LA92_0==FullStop) ) { - alt92=1; + if ( (LA94_0==FullStop) ) { + alt94=1; } - switch (alt92) { + switch (alt94) { case 1 : - // InternalBehaviorAnnexParser.g:10627:3: rule__PropertyReferenceTail__FieldsAssignment_3 + // InternalBehaviorAnnexParser.g:10749:3: rule__PropertyReferenceTail__FieldsAssignment_3 { - pushFollow(FollowSets000.FOLLOW_72); + pushFollow(FollowSets000.FOLLOW_73); rule__PropertyReferenceTail__FieldsAssignment_3(); state._fsp--; @@ -35488,7 +35946,7 @@ public final void rule__PropertyReferenceTail__Group__3__Impl() throws Recogniti break; default : - break loop92; + break loop94; } } while (true); @@ -35517,14 +35975,14 @@ public final void rule__PropertyReferenceTail__Group__3__Impl() throws Recogniti // $ANTLR start "rule__NamedPropertyField__Group__0" - // InternalBehaviorAnnexParser.g:10636:1: rule__NamedPropertyField__Group__0 : rule__NamedPropertyField__Group__0__Impl rule__NamedPropertyField__Group__1 ; + // InternalBehaviorAnnexParser.g:10758: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:10640:1: ( rule__NamedPropertyField__Group__0__Impl rule__NamedPropertyField__Group__1 ) - // InternalBehaviorAnnexParser.g:10641:2: rule__NamedPropertyField__Group__0__Impl rule__NamedPropertyField__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__NamedPropertyField__Group__0__Impl(); @@ -35555,17 +36013,17 @@ public final void rule__NamedPropertyField__Group__0() throws RecognitionExcepti // $ANTLR start "rule__NamedPropertyField__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10648:1: rule__NamedPropertyField__Group__0__Impl : ( FullStop ) ; + // InternalBehaviorAnnexParser.g:10770:1: rule__NamedPropertyField__Group__0__Impl : ( FullStop ) ; public final void rule__NamedPropertyField__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10652:1: ( ( FullStop ) ) - // InternalBehaviorAnnexParser.g:10653:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:10774:1: ( ( FullStop ) ) + // InternalBehaviorAnnexParser.g:10775:1: ( FullStop ) { - // InternalBehaviorAnnexParser.g:10653:1: ( FullStop ) - // InternalBehaviorAnnexParser.g:10654:2: FullStop + // InternalBehaviorAnnexParser.g:10775:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:10776:2: FullStop { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getFullStopKeyword_0()); @@ -35596,14 +36054,14 @@ public final void rule__NamedPropertyField__Group__0__Impl() throws RecognitionE // $ANTLR start "rule__NamedPropertyField__Group__1" - // InternalBehaviorAnnexParser.g:10663:1: rule__NamedPropertyField__Group__1 : rule__NamedPropertyField__Group__1__Impl rule__NamedPropertyField__Group__2 ; + // InternalBehaviorAnnexParser.g:10785: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:10667:1: ( rule__NamedPropertyField__Group__1__Impl rule__NamedPropertyField__Group__2 ) - // InternalBehaviorAnnexParser.g:10668:2: rule__NamedPropertyField__Group__1__Impl rule__NamedPropertyField__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_11); rule__NamedPropertyField__Group__1__Impl(); @@ -35634,23 +36092,23 @@ public final void rule__NamedPropertyField__Group__1() throws RecognitionExcepti // $ANTLR start "rule__NamedPropertyField__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10675:1: rule__NamedPropertyField__Group__1__Impl : ( ( rule__NamedPropertyField__NameAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10797: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:10679:1: ( ( ( rule__NamedPropertyField__NameAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10680:1: ( ( rule__NamedPropertyField__NameAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10801:1: ( ( ( rule__NamedPropertyField__NameAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10802:1: ( ( rule__NamedPropertyField__NameAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10680:1: ( ( rule__NamedPropertyField__NameAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10681:2: ( rule__NamedPropertyField__NameAssignment_1 ) + // InternalBehaviorAnnexParser.g:10802:1: ( ( rule__NamedPropertyField__NameAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10803:2: ( rule__NamedPropertyField__NameAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getNameAssignment_1()); } - // InternalBehaviorAnnexParser.g:10682:2: ( rule__NamedPropertyField__NameAssignment_1 ) - // InternalBehaviorAnnexParser.g:10682:3: rule__NamedPropertyField__NameAssignment_1 + // InternalBehaviorAnnexParser.g:10804:2: ( rule__NamedPropertyField__NameAssignment_1 ) + // InternalBehaviorAnnexParser.g:10804:3: rule__NamedPropertyField__NameAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__NamedPropertyField__NameAssignment_1(); @@ -35685,14 +36143,14 @@ public final void rule__NamedPropertyField__Group__1__Impl() throws RecognitionE // $ANTLR start "rule__NamedPropertyField__Group__2" - // InternalBehaviorAnnexParser.g:10690:1: rule__NamedPropertyField__Group__2 : rule__NamedPropertyField__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:10812: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:10694:1: ( rule__NamedPropertyField__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:10695:2: rule__NamedPropertyField__Group__2__Impl + // InternalBehaviorAnnexParser.g:10816:1: ( rule__NamedPropertyField__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:10817:2: rule__NamedPropertyField__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__NamedPropertyField__Group__2__Impl(); @@ -35718,35 +36176,35 @@ public final void rule__NamedPropertyField__Group__2() throws RecognitionExcepti // $ANTLR start "rule__NamedPropertyField__Group__2__Impl" - // InternalBehaviorAnnexParser.g:10701:1: rule__NamedPropertyField__Group__2__Impl : ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) ; + // InternalBehaviorAnnexParser.g:10823: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:10705:1: ( ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) ) - // InternalBehaviorAnnexParser.g:10706:1: ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10827:1: ( ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) ) + // InternalBehaviorAnnexParser.g:10828:1: ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) { - // InternalBehaviorAnnexParser.g:10706:1: ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) - // InternalBehaviorAnnexParser.g:10707:2: ( rule__NamedPropertyField__IndexesAssignment_2 )* + // InternalBehaviorAnnexParser.g:10828:1: ( ( rule__NamedPropertyField__IndexesAssignment_2 )* ) + // InternalBehaviorAnnexParser.g:10829:2: ( rule__NamedPropertyField__IndexesAssignment_2 )* { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getIndexesAssignment_2()); } - // InternalBehaviorAnnexParser.g:10708:2: ( rule__NamedPropertyField__IndexesAssignment_2 )* - loop93: + // InternalBehaviorAnnexParser.g:10830:2: ( rule__NamedPropertyField__IndexesAssignment_2 )* + loop95: do { - int alt93=2; - int LA93_0 = input.LA(1); + int alt95=2; + int LA95_0 = input.LA(1); - if ( (LA93_0==LeftSquareBracket) ) { - alt93=1; + if ( (LA95_0==LeftSquareBracket) ) { + alt95=1; } - switch (alt93) { + switch (alt95) { case 1 : - // InternalBehaviorAnnexParser.g:10708:3: rule__NamedPropertyField__IndexesAssignment_2 + // InternalBehaviorAnnexParser.g:10830:3: rule__NamedPropertyField__IndexesAssignment_2 { pushFollow(FollowSets000.FOLLOW_12); rule__NamedPropertyField__IndexesAssignment_2(); @@ -35758,7 +36216,7 @@ public final void rule__NamedPropertyField__Group__2__Impl() throws RecognitionE break; default : - break loop93; + break loop95; } } while (true); @@ -35787,16 +36245,16 @@ public final void rule__NamedPropertyField__Group__2__Impl() throws RecognitionE // $ANTLR start "rule__PropertyArrayIndex__Group__0" - // InternalBehaviorAnnexParser.g:10717:1: rule__PropertyArrayIndex__Group__0 : rule__PropertyArrayIndex__Group__0__Impl rule__PropertyArrayIndex__Group__1 ; + // InternalBehaviorAnnexParser.g:10839: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:10721:1: ( rule__PropertyArrayIndex__Group__0__Impl rule__PropertyArrayIndex__Group__1 ) - // InternalBehaviorAnnexParser.g:10722:2: rule__PropertyArrayIndex__Group__0__Impl rule__PropertyArrayIndex__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_73); + pushFollow(FollowSets000.FOLLOW_74); rule__PropertyArrayIndex__Group__0__Impl(); state._fsp--; @@ -35825,17 +36283,17 @@ public final void rule__PropertyArrayIndex__Group__0() throws RecognitionExcepti // $ANTLR start "rule__PropertyArrayIndex__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10729:1: rule__PropertyArrayIndex__Group__0__Impl : ( LeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:10851:1: rule__PropertyArrayIndex__Group__0__Impl : ( LeftSquareBracket ) ; public final void rule__PropertyArrayIndex__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10733:1: ( ( LeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:10734:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:10855:1: ( ( LeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:10856:1: ( LeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:10734:1: ( LeftSquareBracket ) - // InternalBehaviorAnnexParser.g:10735:2: LeftSquareBracket + // InternalBehaviorAnnexParser.g:10856:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:10857:2: LeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyArrayIndexAccess().getLeftSquareBracketKeyword_0()); @@ -35866,14 +36324,14 @@ public final void rule__PropertyArrayIndex__Group__0__Impl() throws RecognitionE // $ANTLR start "rule__PropertyArrayIndex__Group__1" - // InternalBehaviorAnnexParser.g:10744:1: rule__PropertyArrayIndex__Group__1 : rule__PropertyArrayIndex__Group__1__Impl rule__PropertyArrayIndex__Group__2 ; + // InternalBehaviorAnnexParser.g:10866: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:10748:1: ( rule__PropertyArrayIndex__Group__1__Impl rule__PropertyArrayIndex__Group__2 ) - // InternalBehaviorAnnexParser.g:10749:2: rule__PropertyArrayIndex__Group__1__Impl rule__PropertyArrayIndex__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_14); rule__PropertyArrayIndex__Group__1__Impl(); @@ -35904,23 +36362,23 @@ public final void rule__PropertyArrayIndex__Group__1() throws RecognitionExcepti // $ANTLR start "rule__PropertyArrayIndex__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10756:1: rule__PropertyArrayIndex__Group__1__Impl : ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10878: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:10760:1: ( ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10761:1: ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10882:1: ( ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10883:1: ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10761:1: ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10762:2: ( rule__PropertyArrayIndex__ValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:10883:1: ( ( rule__PropertyArrayIndex__ValueAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10884:2: ( rule__PropertyArrayIndex__ValueAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyArrayIndexAccess().getValueAssignment_1()); } - // InternalBehaviorAnnexParser.g:10763:2: ( rule__PropertyArrayIndex__ValueAssignment_1 ) - // InternalBehaviorAnnexParser.g:10763:3: rule__PropertyArrayIndex__ValueAssignment_1 + // InternalBehaviorAnnexParser.g:10885:2: ( rule__PropertyArrayIndex__ValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:10885:3: rule__PropertyArrayIndex__ValueAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyArrayIndex__ValueAssignment_1(); @@ -35955,14 +36413,14 @@ public final void rule__PropertyArrayIndex__Group__1__Impl() throws RecognitionE // $ANTLR start "rule__PropertyArrayIndex__Group__2" - // InternalBehaviorAnnexParser.g:10771:1: rule__PropertyArrayIndex__Group__2 : rule__PropertyArrayIndex__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:10893: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:10775:1: ( rule__PropertyArrayIndex__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:10776:2: rule__PropertyArrayIndex__Group__2__Impl + // InternalBehaviorAnnexParser.g:10897:1: ( rule__PropertyArrayIndex__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:10898:2: rule__PropertyArrayIndex__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyArrayIndex__Group__2__Impl(); @@ -35988,17 +36446,17 @@ public final void rule__PropertyArrayIndex__Group__2() throws RecognitionExcepti // $ANTLR start "rule__PropertyArrayIndex__Group__2__Impl" - // InternalBehaviorAnnexParser.g:10782:1: rule__PropertyArrayIndex__Group__2__Impl : ( RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:10904:1: rule__PropertyArrayIndex__Group__2__Impl : ( RightSquareBracket ) ; public final void rule__PropertyArrayIndex__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10786:1: ( ( RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:10787:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:10908:1: ( ( RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:10909:1: ( RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:10787:1: ( RightSquareBracket ) - // InternalBehaviorAnnexParser.g:10788:2: RightSquareBracket + // InternalBehaviorAnnexParser.g:10909:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:10910:2: RightSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyArrayIndexAccess().getRightSquareBracketKeyword_2()); @@ -36029,14 +36487,14 @@ public final void rule__PropertyArrayIndex__Group__2__Impl() throws RecognitionE // $ANTLR start "rule__PropertyIndexPropertyReference__Group__0" - // InternalBehaviorAnnexParser.g:10798:1: rule__PropertyIndexPropertyReference__Group__0 : rule__PropertyIndexPropertyReference__Group__0__Impl rule__PropertyIndexPropertyReference__Group__1 ; + // InternalBehaviorAnnexParser.g:10920: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:10802:1: ( rule__PropertyIndexPropertyReference__Group__0__Impl rule__PropertyIndexPropertyReference__Group__1 ) - // InternalBehaviorAnnexParser.g:10803:2: rule__PropertyIndexPropertyReference__Group__0__Impl rule__PropertyIndexPropertyReference__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__PropertyIndexPropertyReference__Group__0__Impl(); @@ -36067,17 +36525,17 @@ public final void rule__PropertyIndexPropertyReference__Group__0() throws Recogn // $ANTLR start "rule__PropertyIndexPropertyReference__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10810:1: rule__PropertyIndexPropertyReference__Group__0__Impl : ( NumberSign ) ; + // InternalBehaviorAnnexParser.g:10932:1: rule__PropertyIndexPropertyReference__Group__0__Impl : ( NumberSign ) ; public final void rule__PropertyIndexPropertyReference__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:10814:1: ( ( NumberSign ) ) - // InternalBehaviorAnnexParser.g:10815:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10936:1: ( ( NumberSign ) ) + // InternalBehaviorAnnexParser.g:10937:1: ( NumberSign ) { - // InternalBehaviorAnnexParser.g:10815:1: ( NumberSign ) - // InternalBehaviorAnnexParser.g:10816:2: NumberSign + // InternalBehaviorAnnexParser.g:10937:1: ( NumberSign ) + // InternalBehaviorAnnexParser.g:10938:2: NumberSign { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexPropertyReferenceAccess().getNumberSignKeyword_0()); @@ -36108,14 +36566,14 @@ public final void rule__PropertyIndexPropertyReference__Group__0__Impl() throws // $ANTLR start "rule__PropertyIndexPropertyReference__Group__1" - // InternalBehaviorAnnexParser.g:10825:1: rule__PropertyIndexPropertyReference__Group__1 : rule__PropertyIndexPropertyReference__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:10947: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:10829:1: ( rule__PropertyIndexPropertyReference__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:10830:2: rule__PropertyIndexPropertyReference__Group__1__Impl + // InternalBehaviorAnnexParser.g:10951:1: ( rule__PropertyIndexPropertyReference__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:10952:2: rule__PropertyIndexPropertyReference__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyIndexPropertyReference__Group__1__Impl(); @@ -36141,23 +36599,23 @@ public final void rule__PropertyIndexPropertyReference__Group__1() throws Recogn // $ANTLR start "rule__PropertyIndexPropertyReference__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10836:1: rule__PropertyIndexPropertyReference__Group__1__Impl : ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:10958: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:10840:1: ( ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:10841:1: ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10962:1: ( ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:10963:1: ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:10841:1: ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:10842:2: ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10963:1: ( ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:10964:2: ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexPropertyReferenceAccess().getPropertyAssignment_1()); } - // InternalBehaviorAnnexParser.g:10843:2: ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) - // InternalBehaviorAnnexParser.g:10843:3: rule__PropertyIndexPropertyReference__PropertyAssignment_1 + // InternalBehaviorAnnexParser.g:10965:2: ( rule__PropertyIndexPropertyReference__PropertyAssignment_1 ) + // InternalBehaviorAnnexParser.g:10965:3: rule__PropertyIndexPropertyReference__PropertyAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__PropertyIndexPropertyReference__PropertyAssignment_1(); @@ -36192,16 +36650,16 @@ public final void rule__PropertyIndexPropertyReference__Group__1__Impl() throws // $ANTLR start "rule__UnindexedReferenceExpression__Group__0" - // InternalBehaviorAnnexParser.g:10852:1: rule__UnindexedReferenceExpression__Group__0 : rule__UnindexedReferenceExpression__Group__0__Impl rule__UnindexedReferenceExpression__Group__1 ; + // InternalBehaviorAnnexParser.g:10974: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:10856:1: ( rule__UnindexedReferenceExpression__Group__0__Impl rule__UnindexedReferenceExpression__Group__1 ) - // InternalBehaviorAnnexParser.g:10857:2: rule__UnindexedReferenceExpression__Group__0__Impl rule__UnindexedReferenceExpression__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_74); + pushFollow(FollowSets000.FOLLOW_75); rule__UnindexedReferenceExpression__Group__0__Impl(); state._fsp--; @@ -36230,23 +36688,23 @@ public final void rule__UnindexedReferenceExpression__Group__0() throws Recognit // $ANTLR start "rule__UnindexedReferenceExpression__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10864:1: rule__UnindexedReferenceExpression__Group__0__Impl : ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:10986: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:10868:1: ( ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:10869:1: ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:10990:1: ( ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:10991:1: ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:10869:1: ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:10870:2: ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) + // InternalBehaviorAnnexParser.g:10991:1: ( ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:10992:2: ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getReferenceAssignment_0()); } - // InternalBehaviorAnnexParser.g:10871:2: ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) - // InternalBehaviorAnnexParser.g:10871:3: rule__UnindexedReferenceExpression__ReferenceAssignment_0 + // InternalBehaviorAnnexParser.g:10993:2: ( rule__UnindexedReferenceExpression__ReferenceAssignment_0 ) + // InternalBehaviorAnnexParser.g:10993:3: rule__UnindexedReferenceExpression__ReferenceAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__ReferenceAssignment_0(); @@ -36281,14 +36739,14 @@ public final void rule__UnindexedReferenceExpression__Group__0__Impl() throws Re // $ANTLR start "rule__UnindexedReferenceExpression__Group__1" - // InternalBehaviorAnnexParser.g:10879:1: rule__UnindexedReferenceExpression__Group__1 : rule__UnindexedReferenceExpression__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11001: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:10883:1: ( rule__UnindexedReferenceExpression__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:10884:2: rule__UnindexedReferenceExpression__Group__1__Impl + // InternalBehaviorAnnexParser.g:11005:1: ( rule__UnindexedReferenceExpression__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11006:2: rule__UnindexedReferenceExpression__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__Group__1__Impl(); @@ -36314,31 +36772,31 @@ public final void rule__UnindexedReferenceExpression__Group__1() throws Recognit // $ANTLR start "rule__UnindexedReferenceExpression__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10890:1: rule__UnindexedReferenceExpression__Group__1__Impl : ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) ; + // InternalBehaviorAnnexParser.g:11012: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:10894:1: ( ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) ) - // InternalBehaviorAnnexParser.g:10895:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) + // InternalBehaviorAnnexParser.g:11016:1: ( ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) ) + // InternalBehaviorAnnexParser.g:11017:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) { - // InternalBehaviorAnnexParser.g:10895:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) - // InternalBehaviorAnnexParser.g:10896:2: ( rule__UnindexedReferenceExpression__Alternatives_1 )? + // InternalBehaviorAnnexParser.g:11017:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1 )? ) + // InternalBehaviorAnnexParser.g:11018:2: ( rule__UnindexedReferenceExpression__Alternatives_1 )? { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:10897:2: ( rule__UnindexedReferenceExpression__Alternatives_1 )? - int alt94=2; - int LA94_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:11019:2: ( rule__UnindexedReferenceExpression__Alternatives_1 )? + int alt96=2; + int LA96_0 = input.LA(1); - if ( (LA94_0==Apostrophe||LA94_0==QuestionMark) ) { - alt94=1; + if ( (LA96_0==Apostrophe||LA96_0==QuestionMark) ) { + alt96=1; } - switch (alt94) { + switch (alt96) { case 1 : - // InternalBehaviorAnnexParser.g:10897:3: rule__UnindexedReferenceExpression__Alternatives_1 + // InternalBehaviorAnnexParser.g:11019:3: rule__UnindexedReferenceExpression__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__Alternatives_1(); @@ -36376,16 +36834,16 @@ public final void rule__UnindexedReferenceExpression__Group__1__Impl() throws Re // $ANTLR start "rule__UnindexedReferenceExpression__Group_1_1__0" - // InternalBehaviorAnnexParser.g:10906:1: rule__UnindexedReferenceExpression__Group_1_1__0 : rule__UnindexedReferenceExpression__Group_1_1__0__Impl rule__UnindexedReferenceExpression__Group_1_1__1 ; + // InternalBehaviorAnnexParser.g:11028: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:10910:1: ( rule__UnindexedReferenceExpression__Group_1_1__0__Impl rule__UnindexedReferenceExpression__Group_1_1__1 ) - // InternalBehaviorAnnexParser.g:10911:2: rule__UnindexedReferenceExpression__Group_1_1__0__Impl rule__UnindexedReferenceExpression__Group_1_1__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_70); + pushFollow(FollowSets000.FOLLOW_71); rule__UnindexedReferenceExpression__Group_1_1__0__Impl(); state._fsp--; @@ -36414,17 +36872,17 @@ public final void rule__UnindexedReferenceExpression__Group_1_1__0() throws Reco // $ANTLR start "rule__UnindexedReferenceExpression__Group_1_1__0__Impl" - // InternalBehaviorAnnexParser.g:10918:1: rule__UnindexedReferenceExpression__Group_1_1__0__Impl : ( Apostrophe ) ; + // InternalBehaviorAnnexParser.g:11040: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:10922:1: ( ( Apostrophe ) ) - // InternalBehaviorAnnexParser.g:10923:1: ( Apostrophe ) + // InternalBehaviorAnnexParser.g:11044:1: ( ( Apostrophe ) ) + // InternalBehaviorAnnexParser.g:11045:1: ( Apostrophe ) { - // InternalBehaviorAnnexParser.g:10923:1: ( Apostrophe ) - // InternalBehaviorAnnexParser.g:10924:2: Apostrophe + // InternalBehaviorAnnexParser.g:11045:1: ( Apostrophe ) + // InternalBehaviorAnnexParser.g:11046:2: Apostrophe { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getApostropheKeyword_1_1_0()); @@ -36455,14 +36913,14 @@ public final void rule__UnindexedReferenceExpression__Group_1_1__0__Impl() throw // $ANTLR start "rule__UnindexedReferenceExpression__Group_1_1__1" - // InternalBehaviorAnnexParser.g:10933:1: rule__UnindexedReferenceExpression__Group_1_1__1 : rule__UnindexedReferenceExpression__Group_1_1__1__Impl ; + // InternalBehaviorAnnexParser.g:11055: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:10937:1: ( rule__UnindexedReferenceExpression__Group_1_1__1__Impl ) - // InternalBehaviorAnnexParser.g:10938:2: rule__UnindexedReferenceExpression__Group_1_1__1__Impl + // InternalBehaviorAnnexParser.g:11059:1: ( rule__UnindexedReferenceExpression__Group_1_1__1__Impl ) + // InternalBehaviorAnnexParser.g:11060:2: rule__UnindexedReferenceExpression__Group_1_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__Group_1_1__1__Impl(); @@ -36488,23 +36946,23 @@ public final void rule__UnindexedReferenceExpression__Group_1_1__1() throws Reco // $ANTLR start "rule__UnindexedReferenceExpression__Group_1_1__1__Impl" - // InternalBehaviorAnnexParser.g:10944:1: rule__UnindexedReferenceExpression__Group_1_1__1__Impl : ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:11066: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:10948:1: ( ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:10949:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) + // InternalBehaviorAnnexParser.g:11070:1: ( ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:11071:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) { - // InternalBehaviorAnnexParser.g:10949:1: ( ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) ) - // InternalBehaviorAnnexParser.g:10950:2: ( 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 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getAlternatives_1_1_1()); } - // InternalBehaviorAnnexParser.g:10951:2: ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) - // InternalBehaviorAnnexParser.g:10951:3: rule__UnindexedReferenceExpression__Alternatives_1_1_1 + // InternalBehaviorAnnexParser.g:11073:2: ( rule__UnindexedReferenceExpression__Alternatives_1_1_1 ) + // InternalBehaviorAnnexParser.g:11073:3: rule__UnindexedReferenceExpression__Alternatives_1_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceExpression__Alternatives_1_1_1(); @@ -36539,16 +36997,16 @@ public final void rule__UnindexedReferenceExpression__Group_1_1__1__Impl() throw // $ANTLR start "rule__UnindexedReference__Group__0" - // InternalBehaviorAnnexParser.g:10960:1: rule__UnindexedReference__Group__0 : rule__UnindexedReference__Group__0__Impl rule__UnindexedReference__Group__1 ; + // InternalBehaviorAnnexParser.g:11082: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:10964:1: ( rule__UnindexedReference__Group__0__Impl rule__UnindexedReference__Group__1 ) - // InternalBehaviorAnnexParser.g:10965:2: rule__UnindexedReference__Group__0__Impl rule__UnindexedReference__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_75); + pushFollow(FollowSets000.FOLLOW_76); rule__UnindexedReference__Group__0__Impl(); state._fsp--; @@ -36577,23 +37035,23 @@ public final void rule__UnindexedReference__Group__0() throws RecognitionExcepti // $ANTLR start "rule__UnindexedReference__Group__0__Impl" - // InternalBehaviorAnnexParser.g:10972:1: rule__UnindexedReference__Group__0__Impl : ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11094: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:10976:1: ( ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:10977:1: ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11098:1: ( ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11099:1: ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:10977:1: ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:10978:2: ( rule__UnindexedReference__SegmentsAssignment_0 ) + // InternalBehaviorAnnexParser.g:11099:1: ( ( rule__UnindexedReference__SegmentsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11100:2: ( rule__UnindexedReference__SegmentsAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceAccess().getSegmentsAssignment_0()); } - // InternalBehaviorAnnexParser.g:10979:2: ( rule__UnindexedReference__SegmentsAssignment_0 ) - // InternalBehaviorAnnexParser.g:10979:3: rule__UnindexedReference__SegmentsAssignment_0 + // InternalBehaviorAnnexParser.g:11101:2: ( rule__UnindexedReference__SegmentsAssignment_0 ) + // InternalBehaviorAnnexParser.g:11101:3: rule__UnindexedReference__SegmentsAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReference__SegmentsAssignment_0(); @@ -36628,14 +37086,14 @@ public final void rule__UnindexedReference__Group__0__Impl() throws RecognitionE // $ANTLR start "rule__UnindexedReference__Group__1" - // InternalBehaviorAnnexParser.g:10987:1: rule__UnindexedReference__Group__1 : rule__UnindexedReference__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11109: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:10991:1: ( rule__UnindexedReference__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:10992:2: rule__UnindexedReference__Group__1__Impl + // InternalBehaviorAnnexParser.g:11113:1: ( rule__UnindexedReference__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11114:2: rule__UnindexedReference__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReference__Group__1__Impl(); @@ -36661,37 +37119,37 @@ public final void rule__UnindexedReference__Group__1() throws RecognitionExcepti // $ANTLR start "rule__UnindexedReference__Group__1__Impl" - // InternalBehaviorAnnexParser.g:10998:1: rule__UnindexedReference__Group__1__Impl : ( ( rule__UnindexedReference__TailsAssignment_1 )* ) ; + // InternalBehaviorAnnexParser.g:11120: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:11002:1: ( ( ( rule__UnindexedReference__TailsAssignment_1 )* ) ) - // InternalBehaviorAnnexParser.g:11003:1: ( ( rule__UnindexedReference__TailsAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11124:1: ( ( ( rule__UnindexedReference__TailsAssignment_1 )* ) ) + // InternalBehaviorAnnexParser.g:11125:1: ( ( rule__UnindexedReference__TailsAssignment_1 )* ) { - // InternalBehaviorAnnexParser.g:11003:1: ( ( rule__UnindexedReference__TailsAssignment_1 )* ) - // InternalBehaviorAnnexParser.g:11004:2: ( rule__UnindexedReference__TailsAssignment_1 )* + // InternalBehaviorAnnexParser.g:11125:1: ( ( rule__UnindexedReference__TailsAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11126:2: ( rule__UnindexedReference__TailsAssignment_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceAccess().getTailsAssignment_1()); } - // InternalBehaviorAnnexParser.g:11005:2: ( rule__UnindexedReference__TailsAssignment_1 )* - loop95: + // InternalBehaviorAnnexParser.g:11127:2: ( rule__UnindexedReference__TailsAssignment_1 )* + loop97: do { - int alt95=2; - int LA95_0 = input.LA(1); + int alt97=2; + int LA97_0 = input.LA(1); - if ( (LA95_0==ColonColon||LA95_0==FullStop) ) { - alt95=1; + if ( (LA97_0==ColonColon||LA97_0==FullStop) ) { + alt97=1; } - switch (alt95) { + switch (alt97) { case 1 : - // InternalBehaviorAnnexParser.g:11005:3: rule__UnindexedReference__TailsAssignment_1 + // InternalBehaviorAnnexParser.g:11127:3: rule__UnindexedReference__TailsAssignment_1 { - pushFollow(FollowSets000.FOLLOW_76); + pushFollow(FollowSets000.FOLLOW_77); rule__UnindexedReference__TailsAssignment_1(); state._fsp--; @@ -36701,7 +37159,7 @@ public final void rule__UnindexedReference__Group__1__Impl() throws RecognitionE break; default : - break loop95; + break loop97; } } while (true); @@ -36730,16 +37188,16 @@ public final void rule__UnindexedReference__Group__1__Impl() throws RecognitionE // $ANTLR start "rule__UnindexedReferenceTail__Group__0" - // InternalBehaviorAnnexParser.g:11014:1: rule__UnindexedReferenceTail__Group__0 : rule__UnindexedReferenceTail__Group__0__Impl rule__UnindexedReferenceTail__Group__1 ; + // InternalBehaviorAnnexParser.g:11136: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:11018:1: ( rule__UnindexedReferenceTail__Group__0__Impl rule__UnindexedReferenceTail__Group__1 ) - // InternalBehaviorAnnexParser.g:11019:2: rule__UnindexedReferenceTail__Group__0__Impl rule__UnindexedReferenceTail__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_73); + pushFollow(FollowSets000.FOLLOW_74); rule__UnindexedReferenceTail__Group__0__Impl(); state._fsp--; @@ -36768,23 +37226,23 @@ public final void rule__UnindexedReferenceTail__Group__0() throws RecognitionExc // $ANTLR start "rule__UnindexedReferenceTail__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11026:1: rule__UnindexedReferenceTail__Group__0__Impl : ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11148: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:11030:1: ( ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11031:1: ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11152:1: ( ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11153:1: ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11031:1: ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11032:2: ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) + // InternalBehaviorAnnexParser.g:11153:1: ( ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11154:2: ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceTailAccess().getSeparatorAssignment_0()); } - // InternalBehaviorAnnexParser.g:11033:2: ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) - // InternalBehaviorAnnexParser.g:11033:3: rule__UnindexedReferenceTail__SeparatorAssignment_0 + // InternalBehaviorAnnexParser.g:11155:2: ( rule__UnindexedReferenceTail__SeparatorAssignment_0 ) + // InternalBehaviorAnnexParser.g:11155:3: rule__UnindexedReferenceTail__SeparatorAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceTail__SeparatorAssignment_0(); @@ -36819,14 +37277,14 @@ public final void rule__UnindexedReferenceTail__Group__0__Impl() throws Recognit // $ANTLR start "rule__UnindexedReferenceTail__Group__1" - // InternalBehaviorAnnexParser.g:11041:1: rule__UnindexedReferenceTail__Group__1 : rule__UnindexedReferenceTail__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11163: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:11045:1: ( rule__UnindexedReferenceTail__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11046:2: rule__UnindexedReferenceTail__Group__1__Impl + // InternalBehaviorAnnexParser.g:11167:1: ( rule__UnindexedReferenceTail__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11168:2: rule__UnindexedReferenceTail__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceTail__Group__1__Impl(); @@ -36852,23 +37310,23 @@ public final void rule__UnindexedReferenceTail__Group__1() throws RecognitionExc // $ANTLR start "rule__UnindexedReferenceTail__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11052:1: rule__UnindexedReferenceTail__Group__1__Impl : ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:11174: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:11056:1: ( ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:11057:1: ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11178:1: ( ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:11179:1: ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:11057:1: ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:11058:2: ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) + // InternalBehaviorAnnexParser.g:11179:1: ( ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11180:2: ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceTailAccess().getSegmentAssignment_1()); } - // InternalBehaviorAnnexParser.g:11059:2: ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) - // InternalBehaviorAnnexParser.g:11059:3: rule__UnindexedReferenceTail__SegmentAssignment_1 + // InternalBehaviorAnnexParser.g:11181:2: ( rule__UnindexedReferenceTail__SegmentAssignment_1 ) + // InternalBehaviorAnnexParser.g:11181:3: rule__UnindexedReferenceTail__SegmentAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__UnindexedReferenceTail__SegmentAssignment_1(); @@ -36903,16 +37361,16 @@ public final void rule__UnindexedReferenceTail__Group__1__Impl() throws Recognit // $ANTLR start "rule__QualifiedName__Group__0" - // InternalBehaviorAnnexParser.g:11068:1: rule__QualifiedName__Group__0 : rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ; + // InternalBehaviorAnnexParser.g:11190: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:11072:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ) - // InternalBehaviorAnnexParser.g:11073:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_77); + pushFollow(FollowSets000.FOLLOW_78); rule__QualifiedName__Group__0__Impl(); state._fsp--; @@ -36941,17 +37399,17 @@ public final void rule__QualifiedName__Group__0() throws RecognitionException { // $ANTLR start "rule__QualifiedName__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11080:1: rule__QualifiedName__Group__0__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:11202:1: rule__QualifiedName__Group__0__Impl : ( RULE_ID ) ; public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11084:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:11085:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:11206:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:11207:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:11085:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:11086:2: RULE_ID + // InternalBehaviorAnnexParser.g:11207:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:11208:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); @@ -36982,14 +37440,14 @@ public final void rule__QualifiedName__Group__0__Impl() throws RecognitionExcept // $ANTLR start "rule__QualifiedName__Group__1" - // InternalBehaviorAnnexParser.g:11095:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11217: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:11099:1: ( rule__QualifiedName__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11100:2: rule__QualifiedName__Group__1__Impl + // InternalBehaviorAnnexParser.g:11221:1: ( rule__QualifiedName__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11222:2: rule__QualifiedName__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QualifiedName__Group__1__Impl(); @@ -37015,37 +37473,37 @@ public final void rule__QualifiedName__Group__1() throws RecognitionException { // $ANTLR start "rule__QualifiedName__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11106:1: rule__QualifiedName__Group__1__Impl : ( ( rule__QualifiedName__Group_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:11228: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:11110:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:11111:1: ( ( rule__QualifiedName__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:11232:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:11233:1: ( ( rule__QualifiedName__Group_1__0 )* ) { - // InternalBehaviorAnnexParser.g:11111:1: ( ( rule__QualifiedName__Group_1__0 )* ) - // InternalBehaviorAnnexParser.g:11112:2: ( rule__QualifiedName__Group_1__0 )* + // InternalBehaviorAnnexParser.g:11233:1: ( ( rule__QualifiedName__Group_1__0 )* ) + // InternalBehaviorAnnexParser.g:11234:2: ( rule__QualifiedName__Group_1__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:11113:2: ( rule__QualifiedName__Group_1__0 )* - loop96: + // InternalBehaviorAnnexParser.g:11235:2: ( rule__QualifiedName__Group_1__0 )* + loop98: do { - int alt96=2; - int LA96_0 = input.LA(1); + int alt98=2; + int LA98_0 = input.LA(1); - if ( (LA96_0==ColonColon) ) { - alt96=1; + if ( (LA98_0==ColonColon) ) { + alt98=1; } - switch (alt96) { + switch (alt98) { case 1 : - // InternalBehaviorAnnexParser.g:11113:3: rule__QualifiedName__Group_1__0 + // InternalBehaviorAnnexParser.g:11235:3: rule__QualifiedName__Group_1__0 { - pushFollow(FollowSets000.FOLLOW_78); + pushFollow(FollowSets000.FOLLOW_79); rule__QualifiedName__Group_1__0(); state._fsp--; @@ -37055,7 +37513,7 @@ public final void rule__QualifiedName__Group__1__Impl() throws RecognitionExcept break; default : - break loop96; + break loop98; } } while (true); @@ -37084,14 +37542,14 @@ public final void rule__QualifiedName__Group__1__Impl() throws RecognitionExcept // $ANTLR start "rule__QualifiedName__Group_1__0" - // InternalBehaviorAnnexParser.g:11122:1: rule__QualifiedName__Group_1__0 : rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ; + // InternalBehaviorAnnexParser.g:11244: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:11126:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ) - // InternalBehaviorAnnexParser.g:11127:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__QualifiedName__Group_1__0__Impl(); @@ -37122,17 +37580,17 @@ public final void rule__QualifiedName__Group_1__0() throws RecognitionException // $ANTLR start "rule__QualifiedName__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:11134:1: rule__QualifiedName__Group_1__0__Impl : ( ColonColon ) ; + // InternalBehaviorAnnexParser.g:11256: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:11138:1: ( ( ColonColon ) ) - // InternalBehaviorAnnexParser.g:11139:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:11260:1: ( ( ColonColon ) ) + // InternalBehaviorAnnexParser.g:11261:1: ( ColonColon ) { - // InternalBehaviorAnnexParser.g:11139:1: ( ColonColon ) - // InternalBehaviorAnnexParser.g:11140:2: ColonColon + // InternalBehaviorAnnexParser.g:11261:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:11262:2: ColonColon { if ( state.backtracking==0 ) { before(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); @@ -37163,14 +37621,14 @@ public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionExce // $ANTLR start "rule__QualifiedName__Group_1__1" - // InternalBehaviorAnnexParser.g:11149:1: rule__QualifiedName__Group_1__1 : rule__QualifiedName__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:11271: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:11153:1: ( rule__QualifiedName__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:11154:2: rule__QualifiedName__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:11275:1: ( rule__QualifiedName__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:11276:2: rule__QualifiedName__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QualifiedName__Group_1__1__Impl(); @@ -37196,17 +37654,17 @@ public final void rule__QualifiedName__Group_1__1() throws RecognitionException // $ANTLR start "rule__QualifiedName__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:11160:1: rule__QualifiedName__Group_1__1__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:11282: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:11164:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:11165:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:11286:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:11287:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:11165:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:11166:2: RULE_ID + // InternalBehaviorAnnexParser.g:11287:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:11288:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); @@ -37237,16 +37695,16 @@ public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionExce // $ANTLR start "rule__Reference__Group__0" - // InternalBehaviorAnnexParser.g:11176:1: rule__Reference__Group__0 : rule__Reference__Group__0__Impl rule__Reference__Group__1 ; + // InternalBehaviorAnnexParser.g:11298: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:11180:1: ( rule__Reference__Group__0__Impl rule__Reference__Group__1 ) - // InternalBehaviorAnnexParser.g:11181:2: rule__Reference__Group__0__Impl rule__Reference__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_75); + pushFollow(FollowSets000.FOLLOW_76); rule__Reference__Group__0__Impl(); state._fsp--; @@ -37275,23 +37733,23 @@ public final void rule__Reference__Group__0() throws RecognitionException { // $ANTLR start "rule__Reference__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11188:1: rule__Reference__Group__0__Impl : ( ( rule__Reference__SegmentsAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11310: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:11192:1: ( ( ( rule__Reference__SegmentsAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11193:1: ( ( rule__Reference__SegmentsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11314:1: ( ( ( rule__Reference__SegmentsAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11315:1: ( ( rule__Reference__SegmentsAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11193:1: ( ( rule__Reference__SegmentsAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11194:2: ( rule__Reference__SegmentsAssignment_0 ) + // InternalBehaviorAnnexParser.g:11315:1: ( ( rule__Reference__SegmentsAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11316:2: ( rule__Reference__SegmentsAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceAccess().getSegmentsAssignment_0()); } - // InternalBehaviorAnnexParser.g:11195:2: ( rule__Reference__SegmentsAssignment_0 ) - // InternalBehaviorAnnexParser.g:11195:3: rule__Reference__SegmentsAssignment_0 + // InternalBehaviorAnnexParser.g:11317:2: ( rule__Reference__SegmentsAssignment_0 ) + // InternalBehaviorAnnexParser.g:11317:3: rule__Reference__SegmentsAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__Reference__SegmentsAssignment_0(); @@ -37326,14 +37784,14 @@ public final void rule__Reference__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__Reference__Group__1" - // InternalBehaviorAnnexParser.g:11203:1: rule__Reference__Group__1 : rule__Reference__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11325: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:11207:1: ( rule__Reference__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11208:2: rule__Reference__Group__1__Impl + // InternalBehaviorAnnexParser.g:11329:1: ( rule__Reference__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11330:2: rule__Reference__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__Reference__Group__1__Impl(); @@ -37359,37 +37817,37 @@ public final void rule__Reference__Group__1() throws RecognitionException { // $ANTLR start "rule__Reference__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11214:1: rule__Reference__Group__1__Impl : ( ( rule__Reference__TailsAssignment_1 )* ) ; + // InternalBehaviorAnnexParser.g:11336: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:11218:1: ( ( ( rule__Reference__TailsAssignment_1 )* ) ) - // InternalBehaviorAnnexParser.g:11219:1: ( ( rule__Reference__TailsAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11340:1: ( ( ( rule__Reference__TailsAssignment_1 )* ) ) + // InternalBehaviorAnnexParser.g:11341:1: ( ( rule__Reference__TailsAssignment_1 )* ) { - // InternalBehaviorAnnexParser.g:11219:1: ( ( rule__Reference__TailsAssignment_1 )* ) - // InternalBehaviorAnnexParser.g:11220:2: ( rule__Reference__TailsAssignment_1 )* + // InternalBehaviorAnnexParser.g:11341:1: ( ( rule__Reference__TailsAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11342:2: ( rule__Reference__TailsAssignment_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceAccess().getTailsAssignment_1()); } - // InternalBehaviorAnnexParser.g:11221:2: ( rule__Reference__TailsAssignment_1 )* - loop97: + // InternalBehaviorAnnexParser.g:11343:2: ( rule__Reference__TailsAssignment_1 )* + loop99: do { - int alt97=2; - int LA97_0 = input.LA(1); + int alt99=2; + int LA99_0 = input.LA(1); - if ( (LA97_0==ColonColon||LA97_0==FullStop) ) { - alt97=1; + if ( (LA99_0==ColonColon||LA99_0==FullStop) ) { + alt99=1; } - switch (alt97) { + switch (alt99) { case 1 : - // InternalBehaviorAnnexParser.g:11221:3: rule__Reference__TailsAssignment_1 + // InternalBehaviorAnnexParser.g:11343:3: rule__Reference__TailsAssignment_1 { - pushFollow(FollowSets000.FOLLOW_76); + pushFollow(FollowSets000.FOLLOW_77); rule__Reference__TailsAssignment_1(); state._fsp--; @@ -37399,7 +37857,7 @@ public final void rule__Reference__Group__1__Impl() throws RecognitionException break; default : - break loop97; + break loop99; } } while (true); @@ -37428,14 +37886,14 @@ public final void rule__Reference__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__ReferenceTail__Group__0" - // InternalBehaviorAnnexParser.g:11230:1: rule__ReferenceTail__Group__0 : rule__ReferenceTail__Group__0__Impl rule__ReferenceTail__Group__1 ; + // InternalBehaviorAnnexParser.g:11352: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:11234:1: ( rule__ReferenceTail__Group__0__Impl rule__ReferenceTail__Group__1 ) - // InternalBehaviorAnnexParser.g:11235:2: rule__ReferenceTail__Group__0__Impl rule__ReferenceTail__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_13); rule__ReferenceTail__Group__0__Impl(); @@ -37466,23 +37924,23 @@ public final void rule__ReferenceTail__Group__0() throws RecognitionException { // $ANTLR start "rule__ReferenceTail__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11242:1: rule__ReferenceTail__Group__0__Impl : ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11364: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:11246:1: ( ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11247:1: ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11368:1: ( ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11369:1: ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11247:1: ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11248:2: ( rule__ReferenceTail__SeparatorAssignment_0 ) + // InternalBehaviorAnnexParser.g:11369:1: ( ( rule__ReferenceTail__SeparatorAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11370:2: ( rule__ReferenceTail__SeparatorAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTailAccess().getSeparatorAssignment_0()); } - // InternalBehaviorAnnexParser.g:11249:2: ( rule__ReferenceTail__SeparatorAssignment_0 ) - // InternalBehaviorAnnexParser.g:11249:3: rule__ReferenceTail__SeparatorAssignment_0 + // InternalBehaviorAnnexParser.g:11371:2: ( rule__ReferenceTail__SeparatorAssignment_0 ) + // InternalBehaviorAnnexParser.g:11371:3: rule__ReferenceTail__SeparatorAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTail__SeparatorAssignment_0(); @@ -37517,14 +37975,14 @@ public final void rule__ReferenceTail__Group__0__Impl() throws RecognitionExcept // $ANTLR start "rule__ReferenceTail__Group__1" - // InternalBehaviorAnnexParser.g:11257:1: rule__ReferenceTail__Group__1 : rule__ReferenceTail__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11379: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:11261:1: ( rule__ReferenceTail__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11262:2: rule__ReferenceTail__Group__1__Impl + // InternalBehaviorAnnexParser.g:11383:1: ( rule__ReferenceTail__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11384:2: rule__ReferenceTail__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTail__Group__1__Impl(); @@ -37550,23 +38008,23 @@ public final void rule__ReferenceTail__Group__1() throws RecognitionException { // $ANTLR start "rule__ReferenceTail__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11268:1: rule__ReferenceTail__Group__1__Impl : ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:11390: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:11272:1: ( ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:11273:1: ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11394:1: ( ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:11395:1: ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:11273:1: ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:11274:2: ( rule__ReferenceTail__SegmentAssignment_1 ) + // InternalBehaviorAnnexParser.g:11395:1: ( ( rule__ReferenceTail__SegmentAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11396:2: ( rule__ReferenceTail__SegmentAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTailAccess().getSegmentAssignment_1()); } - // InternalBehaviorAnnexParser.g:11275:2: ( rule__ReferenceTail__SegmentAssignment_1 ) - // InternalBehaviorAnnexParser.g:11275:3: rule__ReferenceTail__SegmentAssignment_1 + // InternalBehaviorAnnexParser.g:11397:2: ( rule__ReferenceTail__SegmentAssignment_1 ) + // InternalBehaviorAnnexParser.g:11397:3: rule__ReferenceTail__SegmentAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTail__SegmentAssignment_1(); @@ -37601,14 +38059,14 @@ public final void rule__ReferenceTail__Group__1__Impl() throws RecognitionExcept // $ANTLR start "rule__ReferenceSegment__Group__0" - // InternalBehaviorAnnexParser.g:11284:1: rule__ReferenceSegment__Group__0 : rule__ReferenceSegment__Group__0__Impl rule__ReferenceSegment__Group__1 ; + // InternalBehaviorAnnexParser.g:11406: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:11288:1: ( rule__ReferenceSegment__Group__0__Impl rule__ReferenceSegment__Group__1 ) - // InternalBehaviorAnnexParser.g:11289:2: rule__ReferenceSegment__Group__0__Impl rule__ReferenceSegment__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_11); rule__ReferenceSegment__Group__0__Impl(); @@ -37639,23 +38097,23 @@ public final void rule__ReferenceSegment__Group__0() throws RecognitionException // $ANTLR start "rule__ReferenceSegment__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11296:1: rule__ReferenceSegment__Group__0__Impl : ( ( rule__ReferenceSegment__NameAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11418: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:11300:1: ( ( ( rule__ReferenceSegment__NameAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11301:1: ( ( rule__ReferenceSegment__NameAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11422:1: ( ( ( rule__ReferenceSegment__NameAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11423:1: ( ( rule__ReferenceSegment__NameAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11301:1: ( ( rule__ReferenceSegment__NameAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11302:2: ( rule__ReferenceSegment__NameAssignment_0 ) + // InternalBehaviorAnnexParser.g:11423:1: ( ( rule__ReferenceSegment__NameAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11424:2: ( rule__ReferenceSegment__NameAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSegmentAccess().getNameAssignment_0()); } - // InternalBehaviorAnnexParser.g:11303:2: ( rule__ReferenceSegment__NameAssignment_0 ) - // InternalBehaviorAnnexParser.g:11303:3: rule__ReferenceSegment__NameAssignment_0 + // InternalBehaviorAnnexParser.g:11425:2: ( rule__ReferenceSegment__NameAssignment_0 ) + // InternalBehaviorAnnexParser.g:11425:3: rule__ReferenceSegment__NameAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceSegment__NameAssignment_0(); @@ -37690,14 +38148,14 @@ public final void rule__ReferenceSegment__Group__0__Impl() throws RecognitionExc // $ANTLR start "rule__ReferenceSegment__Group__1" - // InternalBehaviorAnnexParser.g:11311:1: rule__ReferenceSegment__Group__1 : rule__ReferenceSegment__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:11433: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:11315:1: ( rule__ReferenceSegment__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:11316:2: rule__ReferenceSegment__Group__1__Impl + // InternalBehaviorAnnexParser.g:11437:1: ( rule__ReferenceSegment__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:11438:2: rule__ReferenceSegment__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceSegment__Group__1__Impl(); @@ -37723,35 +38181,35 @@ public final void rule__ReferenceSegment__Group__1() throws RecognitionException // $ANTLR start "rule__ReferenceSegment__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11322:1: rule__ReferenceSegment__Group__1__Impl : ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) ; + // InternalBehaviorAnnexParser.g:11444: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:11326:1: ( ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) ) - // InternalBehaviorAnnexParser.g:11327:1: ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11448:1: ( ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) ) + // InternalBehaviorAnnexParser.g:11449:1: ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) { - // InternalBehaviorAnnexParser.g:11327:1: ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) - // InternalBehaviorAnnexParser.g:11328:2: ( rule__ReferenceSegment__IndexesAssignment_1 )* + // InternalBehaviorAnnexParser.g:11449:1: ( ( rule__ReferenceSegment__IndexesAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:11450:2: ( rule__ReferenceSegment__IndexesAssignment_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSegmentAccess().getIndexesAssignment_1()); } - // InternalBehaviorAnnexParser.g:11329:2: ( rule__ReferenceSegment__IndexesAssignment_1 )* - loop98: + // InternalBehaviorAnnexParser.g:11451:2: ( rule__ReferenceSegment__IndexesAssignment_1 )* + loop100: do { - int alt98=2; - int LA98_0 = input.LA(1); + int alt100=2; + int LA100_0 = input.LA(1); - if ( (LA98_0==LeftSquareBracket) ) { - alt98=1; + if ( (LA100_0==LeftSquareBracket) ) { + alt100=1; } - switch (alt98) { + switch (alt100) { case 1 : - // InternalBehaviorAnnexParser.g:11329:3: rule__ReferenceSegment__IndexesAssignment_1 + // InternalBehaviorAnnexParser.g:11451:3: rule__ReferenceSegment__IndexesAssignment_1 { pushFollow(FollowSets000.FOLLOW_12); rule__ReferenceSegment__IndexesAssignment_1(); @@ -37763,7 +38221,7 @@ public final void rule__ReferenceSegment__Group__1__Impl() throws RecognitionExc break; default : - break loop98; + break loop100; } } while (true); @@ -37792,14 +38250,14 @@ public final void rule__ReferenceSegment__Group__1__Impl() throws RecognitionExc // $ANTLR start "rule__ArrayIndex__Group__0" - // InternalBehaviorAnnexParser.g:11338:1: rule__ArrayIndex__Group__0 : rule__ArrayIndex__Group__0__Impl rule__ArrayIndex__Group__1 ; + // InternalBehaviorAnnexParser.g:11460: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:11342:1: ( rule__ArrayIndex__Group__0__Impl rule__ArrayIndex__Group__1 ) - // InternalBehaviorAnnexParser.g:11343:2: rule__ArrayIndex__Group__0__Impl rule__ArrayIndex__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_13); rule__ArrayIndex__Group__0__Impl(); @@ -37830,17 +38288,17 @@ public final void rule__ArrayIndex__Group__0() throws RecognitionException { // $ANTLR start "rule__ArrayIndex__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11350:1: rule__ArrayIndex__Group__0__Impl : ( LeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:11472:1: rule__ArrayIndex__Group__0__Impl : ( LeftSquareBracket ) ; public final void rule__ArrayIndex__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11354:1: ( ( LeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:11355:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:11476:1: ( ( LeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:11477:1: ( LeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:11355:1: ( LeftSquareBracket ) - // InternalBehaviorAnnexParser.g:11356:2: LeftSquareBracket + // InternalBehaviorAnnexParser.g:11477:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:11478:2: LeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getArrayIndexAccess().getLeftSquareBracketKeyword_0()); @@ -37871,14 +38329,14 @@ public final void rule__ArrayIndex__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__ArrayIndex__Group__1" - // InternalBehaviorAnnexParser.g:11365:1: rule__ArrayIndex__Group__1 : rule__ArrayIndex__Group__1__Impl rule__ArrayIndex__Group__2 ; + // InternalBehaviorAnnexParser.g:11487: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:11369:1: ( rule__ArrayIndex__Group__1__Impl rule__ArrayIndex__Group__2 ) - // InternalBehaviorAnnexParser.g:11370:2: rule__ArrayIndex__Group__1__Impl rule__ArrayIndex__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_14); rule__ArrayIndex__Group__1__Impl(); @@ -37909,23 +38367,23 @@ public final void rule__ArrayIndex__Group__1() throws RecognitionException { // $ANTLR start "rule__ArrayIndex__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11377:1: rule__ArrayIndex__Group__1__Impl : ( ( rule__ArrayIndex__ValueAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:11499: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:11381:1: ( ( ( rule__ArrayIndex__ValueAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:11382:1: ( ( rule__ArrayIndex__ValueAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11503:1: ( ( ( rule__ArrayIndex__ValueAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:11504:1: ( ( rule__ArrayIndex__ValueAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:11382:1: ( ( rule__ArrayIndex__ValueAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:11383:2: ( rule__ArrayIndex__ValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:11504:1: ( ( rule__ArrayIndex__ValueAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:11505:2: ( rule__ArrayIndex__ValueAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getArrayIndexAccess().getValueAssignment_1()); } - // InternalBehaviorAnnexParser.g:11384:2: ( rule__ArrayIndex__ValueAssignment_1 ) - // InternalBehaviorAnnexParser.g:11384:3: rule__ArrayIndex__ValueAssignment_1 + // InternalBehaviorAnnexParser.g:11506:2: ( rule__ArrayIndex__ValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:11506:3: rule__ArrayIndex__ValueAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayIndex__ValueAssignment_1(); @@ -37960,14 +38418,14 @@ public final void rule__ArrayIndex__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__ArrayIndex__Group__2" - // InternalBehaviorAnnexParser.g:11392:1: rule__ArrayIndex__Group__2 : rule__ArrayIndex__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:11514: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:11396:1: ( rule__ArrayIndex__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:11397:2: rule__ArrayIndex__Group__2__Impl + // InternalBehaviorAnnexParser.g:11518:1: ( rule__ArrayIndex__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:11519:2: rule__ArrayIndex__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayIndex__Group__2__Impl(); @@ -37993,17 +38451,17 @@ public final void rule__ArrayIndex__Group__2() throws RecognitionException { // $ANTLR start "rule__ArrayIndex__Group__2__Impl" - // InternalBehaviorAnnexParser.g:11403:1: rule__ArrayIndex__Group__2__Impl : ( RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:11525:1: rule__ArrayIndex__Group__2__Impl : ( RightSquareBracket ) ; public final void rule__ArrayIndex__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11407:1: ( ( RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:11408:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:11529:1: ( ( RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:11530:1: ( RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:11408:1: ( RightSquareBracket ) - // InternalBehaviorAnnexParser.g:11409:2: RightSquareBracket + // InternalBehaviorAnnexParser.g:11530:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:11531:2: RightSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getArrayIndexAccess().getRightSquareBracketKeyword_2()); @@ -38034,16 +38492,16 @@ public final void rule__ArrayIndex__Group__2__Impl() throws RecognitionException // $ANTLR start "rule__ContainedPropertyAssociation__Group__0" - // InternalBehaviorAnnexParser.g:11419:1: rule__ContainedPropertyAssociation__Group__0 : rule__ContainedPropertyAssociation__Group__0__Impl rule__ContainedPropertyAssociation__Group__1 ; + // InternalBehaviorAnnexParser.g:11541: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:11423:1: ( rule__ContainedPropertyAssociation__Group__0__Impl rule__ContainedPropertyAssociation__Group__1 ) - // InternalBehaviorAnnexParser.g:11424:2: rule__ContainedPropertyAssociation__Group__0__Impl rule__ContainedPropertyAssociation__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_79); + pushFollow(FollowSets000.FOLLOW_80); rule__ContainedPropertyAssociation__Group__0__Impl(); state._fsp--; @@ -38072,23 +38530,23 @@ public final void rule__ContainedPropertyAssociation__Group__0() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__0__Impl" - // InternalBehaviorAnnexParser.g:11431:1: rule__ContainedPropertyAssociation__Group__0__Impl : ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:11553: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:11435:1: ( ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:11436:1: ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11557:1: ( ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:11558:1: ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:11436:1: ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:11437:2: ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) + // InternalBehaviorAnnexParser.g:11558:1: ( ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:11559:2: ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getPropertyAssignment_0()); } - // InternalBehaviorAnnexParser.g:11438:2: ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) - // InternalBehaviorAnnexParser.g:11438:3: rule__ContainedPropertyAssociation__PropertyAssignment_0 + // InternalBehaviorAnnexParser.g:11560:2: ( rule__ContainedPropertyAssociation__PropertyAssignment_0 ) + // InternalBehaviorAnnexParser.g:11560:3: rule__ContainedPropertyAssociation__PropertyAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__PropertyAssignment_0(); @@ -38123,16 +38581,16 @@ public final void rule__ContainedPropertyAssociation__Group__0__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__1" - // InternalBehaviorAnnexParser.g:11446:1: rule__ContainedPropertyAssociation__Group__1 : rule__ContainedPropertyAssociation__Group__1__Impl rule__ContainedPropertyAssociation__Group__2 ; + // InternalBehaviorAnnexParser.g:11568: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:11450:1: ( rule__ContainedPropertyAssociation__Group__1__Impl rule__ContainedPropertyAssociation__Group__2 ) - // InternalBehaviorAnnexParser.g:11451:2: rule__ContainedPropertyAssociation__Group__1__Impl rule__ContainedPropertyAssociation__Group__2 + // 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 { - pushFollow(FollowSets000.FOLLOW_80); + pushFollow(FollowSets000.FOLLOW_81); rule__ContainedPropertyAssociation__Group__1__Impl(); state._fsp--; @@ -38161,23 +38619,23 @@ public final void rule__ContainedPropertyAssociation__Group__1() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__1__Impl" - // InternalBehaviorAnnexParser.g:11458:1: rule__ContainedPropertyAssociation__Group__1__Impl : ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) ; + // InternalBehaviorAnnexParser.g:11580: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:11462:1: ( ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) ) - // InternalBehaviorAnnexParser.g:11463:1: ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:11584:1: ( ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) ) + // InternalBehaviorAnnexParser.g:11585:1: ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) { - // InternalBehaviorAnnexParser.g:11463:1: ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) - // InternalBehaviorAnnexParser.g:11464:2: ( rule__ContainedPropertyAssociation__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:11585:1: ( ( rule__ContainedPropertyAssociation__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:11586:2: ( rule__ContainedPropertyAssociation__Alternatives_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:11465:2: ( rule__ContainedPropertyAssociation__Alternatives_1 ) - // InternalBehaviorAnnexParser.g:11465:3: rule__ContainedPropertyAssociation__Alternatives_1 + // InternalBehaviorAnnexParser.g:11587:2: ( rule__ContainedPropertyAssociation__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:11587:3: rule__ContainedPropertyAssociation__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Alternatives_1(); @@ -38212,16 +38670,16 @@ public final void rule__ContainedPropertyAssociation__Group__1__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__2" - // InternalBehaviorAnnexParser.g:11473:1: rule__ContainedPropertyAssociation__Group__2 : rule__ContainedPropertyAssociation__Group__2__Impl rule__ContainedPropertyAssociation__Group__3 ; + // InternalBehaviorAnnexParser.g:11595: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:11477:1: ( rule__ContainedPropertyAssociation__Group__2__Impl rule__ContainedPropertyAssociation__Group__3 ) - // InternalBehaviorAnnexParser.g:11478:2: rule__ContainedPropertyAssociation__Group__2__Impl rule__ContainedPropertyAssociation__Group__3 + // 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 { - pushFollow(FollowSets000.FOLLOW_80); + pushFollow(FollowSets000.FOLLOW_81); rule__ContainedPropertyAssociation__Group__2__Impl(); state._fsp--; @@ -38250,31 +38708,31 @@ public final void rule__ContainedPropertyAssociation__Group__2() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__2__Impl" - // InternalBehaviorAnnexParser.g:11485:1: rule__ContainedPropertyAssociation__Group__2__Impl : ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) ; + // InternalBehaviorAnnexParser.g:11607: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:11489:1: ( ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) ) - // InternalBehaviorAnnexParser.g:11490:1: ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) + // InternalBehaviorAnnexParser.g:11611:1: ( ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) ) + // InternalBehaviorAnnexParser.g:11612:1: ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) { - // InternalBehaviorAnnexParser.g:11490:1: ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) - // InternalBehaviorAnnexParser.g:11491:2: ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? + // InternalBehaviorAnnexParser.g:11612:1: ( ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? ) + // InternalBehaviorAnnexParser.g:11613:2: ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getConstantAssignment_2()); } - // InternalBehaviorAnnexParser.g:11492:2: ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? - int alt99=2; - int LA99_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:11614:2: ( rule__ContainedPropertyAssociation__ConstantAssignment_2 )? + int alt101=2; + int LA101_0 = input.LA(1); - if ( (LA99_0==Constant) ) { - alt99=1; + if ( (LA101_0==Constant) ) { + alt101=1; } - switch (alt99) { + switch (alt101) { case 1 : - // InternalBehaviorAnnexParser.g:11492:3: rule__ContainedPropertyAssociation__ConstantAssignment_2 + // InternalBehaviorAnnexParser.g:11614:3: rule__ContainedPropertyAssociation__ConstantAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__ConstantAssignment_2(); @@ -38312,16 +38770,16 @@ public final void rule__ContainedPropertyAssociation__Group__2__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__3" - // InternalBehaviorAnnexParser.g:11500:1: rule__ContainedPropertyAssociation__Group__3 : rule__ContainedPropertyAssociation__Group__3__Impl rule__ContainedPropertyAssociation__Group__4 ; + // InternalBehaviorAnnexParser.g:11622: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:11504:1: ( rule__ContainedPropertyAssociation__Group__3__Impl rule__ContainedPropertyAssociation__Group__4 ) - // InternalBehaviorAnnexParser.g:11505:2: rule__ContainedPropertyAssociation__Group__3__Impl rule__ContainedPropertyAssociation__Group__4 + // 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 { - pushFollow(FollowSets000.FOLLOW_81); + pushFollow(FollowSets000.FOLLOW_82); rule__ContainedPropertyAssociation__Group__3__Impl(); state._fsp--; @@ -38350,23 +38808,23 @@ public final void rule__ContainedPropertyAssociation__Group__3() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__3__Impl" - // InternalBehaviorAnnexParser.g:11512:1: rule__ContainedPropertyAssociation__Group__3__Impl : ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) ; + // InternalBehaviorAnnexParser.g:11634: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:11516:1: ( ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) ) - // InternalBehaviorAnnexParser.g:11517:1: ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) + // InternalBehaviorAnnexParser.g:11638:1: ( ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) ) + // InternalBehaviorAnnexParser.g:11639:1: ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) { - // InternalBehaviorAnnexParser.g:11517:1: ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) - // InternalBehaviorAnnexParser.g:11518:2: ( rule__ContainedPropertyAssociation__Group_3__0 ) + // InternalBehaviorAnnexParser.g:11639:1: ( ( rule__ContainedPropertyAssociation__Group_3__0 ) ) + // InternalBehaviorAnnexParser.g:11640:2: ( rule__ContainedPropertyAssociation__Group_3__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup_3()); } - // InternalBehaviorAnnexParser.g:11519:2: ( rule__ContainedPropertyAssociation__Group_3__0 ) - // InternalBehaviorAnnexParser.g:11519:3: rule__ContainedPropertyAssociation__Group_3__0 + // InternalBehaviorAnnexParser.g:11641:2: ( rule__ContainedPropertyAssociation__Group_3__0 ) + // InternalBehaviorAnnexParser.g:11641:3: rule__ContainedPropertyAssociation__Group_3__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_3__0(); @@ -38401,16 +38859,16 @@ public final void rule__ContainedPropertyAssociation__Group__3__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__4" - // InternalBehaviorAnnexParser.g:11527:1: rule__ContainedPropertyAssociation__Group__4 : rule__ContainedPropertyAssociation__Group__4__Impl rule__ContainedPropertyAssociation__Group__5 ; + // InternalBehaviorAnnexParser.g:11649: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:11531:1: ( rule__ContainedPropertyAssociation__Group__4__Impl rule__ContainedPropertyAssociation__Group__5 ) - // InternalBehaviorAnnexParser.g:11532:2: rule__ContainedPropertyAssociation__Group__4__Impl rule__ContainedPropertyAssociation__Group__5 + // 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 { - pushFollow(FollowSets000.FOLLOW_81); + pushFollow(FollowSets000.FOLLOW_82); rule__ContainedPropertyAssociation__Group__4__Impl(); state._fsp--; @@ -38439,31 +38897,31 @@ public final void rule__ContainedPropertyAssociation__Group__4() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__4__Impl" - // InternalBehaviorAnnexParser.g:11539:1: rule__ContainedPropertyAssociation__Group__4__Impl : ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) ; + // InternalBehaviorAnnexParser.g:11661: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:11543:1: ( ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) ) - // InternalBehaviorAnnexParser.g:11544:1: ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) + // InternalBehaviorAnnexParser.g:11665:1: ( ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) ) + // InternalBehaviorAnnexParser.g:11666:1: ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) { - // InternalBehaviorAnnexParser.g:11544:1: ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) - // InternalBehaviorAnnexParser.g:11545:2: ( rule__ContainedPropertyAssociation__Group_4__0 )? + // InternalBehaviorAnnexParser.g:11666:1: ( ( rule__ContainedPropertyAssociation__Group_4__0 )? ) + // InternalBehaviorAnnexParser.g:11667:2: ( rule__ContainedPropertyAssociation__Group_4__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup_4()); } - // InternalBehaviorAnnexParser.g:11546:2: ( rule__ContainedPropertyAssociation__Group_4__0 )? - int alt100=2; - int LA100_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:11668:2: ( rule__ContainedPropertyAssociation__Group_4__0 )? + int alt102=2; + int LA102_0 = input.LA(1); - if ( (LA100_0==Applies) ) { - alt100=1; + if ( (LA102_0==Applies) ) { + alt102=1; } - switch (alt100) { + switch (alt102) { case 1 : - // InternalBehaviorAnnexParser.g:11546:3: rule__ContainedPropertyAssociation__Group_4__0 + // InternalBehaviorAnnexParser.g:11668:3: rule__ContainedPropertyAssociation__Group_4__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_4__0(); @@ -38501,16 +38959,16 @@ public final void rule__ContainedPropertyAssociation__Group__4__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__5" - // InternalBehaviorAnnexParser.g:11554:1: rule__ContainedPropertyAssociation__Group__5 : rule__ContainedPropertyAssociation__Group__5__Impl rule__ContainedPropertyAssociation__Group__6 ; + // InternalBehaviorAnnexParser.g:11676: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:11558:1: ( rule__ContainedPropertyAssociation__Group__5__Impl rule__ContainedPropertyAssociation__Group__6 ) - // InternalBehaviorAnnexParser.g:11559:2: rule__ContainedPropertyAssociation__Group__5__Impl rule__ContainedPropertyAssociation__Group__6 + // 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 { - pushFollow(FollowSets000.FOLLOW_81); + pushFollow(FollowSets000.FOLLOW_82); rule__ContainedPropertyAssociation__Group__5__Impl(); state._fsp--; @@ -38539,31 +38997,31 @@ public final void rule__ContainedPropertyAssociation__Group__5() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__5__Impl" - // InternalBehaviorAnnexParser.g:11566:1: rule__ContainedPropertyAssociation__Group__5__Impl : ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) ; + // InternalBehaviorAnnexParser.g:11688: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:11570:1: ( ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) ) - // InternalBehaviorAnnexParser.g:11571:1: ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) + // InternalBehaviorAnnexParser.g:11692:1: ( ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) ) + // InternalBehaviorAnnexParser.g:11693:1: ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) { - // InternalBehaviorAnnexParser.g:11571:1: ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) - // InternalBehaviorAnnexParser.g:11572:2: ( rule__ContainedPropertyAssociation__Group_5__0 )? + // InternalBehaviorAnnexParser.g:11693:1: ( ( rule__ContainedPropertyAssociation__Group_5__0 )? ) + // InternalBehaviorAnnexParser.g:11694:2: ( rule__ContainedPropertyAssociation__Group_5__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup_5()); } - // InternalBehaviorAnnexParser.g:11573:2: ( rule__ContainedPropertyAssociation__Group_5__0 )? - int alt101=2; - int LA101_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:11695:2: ( rule__ContainedPropertyAssociation__Group_5__0 )? + int alt103=2; + int LA103_0 = input.LA(1); - if ( (LA101_0==In) ) { - alt101=1; + if ( (LA103_0==In) ) { + alt103=1; } - switch (alt101) { + switch (alt103) { case 1 : - // InternalBehaviorAnnexParser.g:11573:3: rule__ContainedPropertyAssociation__Group_5__0 + // InternalBehaviorAnnexParser.g:11695:3: rule__ContainedPropertyAssociation__Group_5__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_5__0(); @@ -38601,14 +39059,14 @@ public final void rule__ContainedPropertyAssociation__Group__5__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group__6" - // InternalBehaviorAnnexParser.g:11581:1: rule__ContainedPropertyAssociation__Group__6 : rule__ContainedPropertyAssociation__Group__6__Impl ; + // InternalBehaviorAnnexParser.g:11703: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:11585:1: ( rule__ContainedPropertyAssociation__Group__6__Impl ) - // InternalBehaviorAnnexParser.g:11586:2: rule__ContainedPropertyAssociation__Group__6__Impl + // InternalBehaviorAnnexParser.g:11707:1: ( rule__ContainedPropertyAssociation__Group__6__Impl ) + // InternalBehaviorAnnexParser.g:11708:2: rule__ContainedPropertyAssociation__Group__6__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group__6__Impl(); @@ -38634,17 +39092,17 @@ public final void rule__ContainedPropertyAssociation__Group__6() throws Recognit // $ANTLR start "rule__ContainedPropertyAssociation__Group__6__Impl" - // InternalBehaviorAnnexParser.g:11592:1: rule__ContainedPropertyAssociation__Group__6__Impl : ( Semicolon ) ; + // InternalBehaviorAnnexParser.g:11714:1: rule__ContainedPropertyAssociation__Group__6__Impl : ( Semicolon ) ; public final void rule__ContainedPropertyAssociation__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:11596:1: ( ( Semicolon ) ) - // InternalBehaviorAnnexParser.g:11597:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:11718:1: ( ( Semicolon ) ) + // InternalBehaviorAnnexParser.g:11719:1: ( Semicolon ) { - // InternalBehaviorAnnexParser.g:11597:1: ( Semicolon ) - // InternalBehaviorAnnexParser.g:11598:2: Semicolon + // InternalBehaviorAnnexParser.g:11719:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:11720:2: Semicolon { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getSemicolonKeyword_6()); @@ -38675,16 +39133,16 @@ public final void rule__ContainedPropertyAssociation__Group__6__Impl() throws Re // $ANTLR start "rule__ContainedPropertyAssociation__Group_3__0" - // InternalBehaviorAnnexParser.g:11608:1: rule__ContainedPropertyAssociation__Group_3__0 : rule__ContainedPropertyAssociation__Group_3__0__Impl rule__ContainedPropertyAssociation__Group_3__1 ; + // InternalBehaviorAnnexParser.g:11730: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:11612:1: ( rule__ContainedPropertyAssociation__Group_3__0__Impl rule__ContainedPropertyAssociation__Group_3__1 ) - // InternalBehaviorAnnexParser.g:11613:2: rule__ContainedPropertyAssociation__Group_3__0__Impl rule__ContainedPropertyAssociation__Group_3__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_82); + pushFollow(FollowSets000.FOLLOW_83); rule__ContainedPropertyAssociation__Group_3__0__Impl(); state._fsp--; @@ -38713,23 +39171,23 @@ public final void rule__ContainedPropertyAssociation__Group_3__0() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_3__0__Impl" - // InternalBehaviorAnnexParser.g:11620:1: rule__ContainedPropertyAssociation__Group_3__0__Impl : ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) ; + // InternalBehaviorAnnexParser.g:11742: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:11624:1: ( ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) ) - // InternalBehaviorAnnexParser.g:11625:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) + // InternalBehaviorAnnexParser.g:11746:1: ( ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) ) + // InternalBehaviorAnnexParser.g:11747:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) { - // InternalBehaviorAnnexParser.g:11625:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) - // InternalBehaviorAnnexParser.g:11626:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) + // InternalBehaviorAnnexParser.g:11747:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) ) + // InternalBehaviorAnnexParser.g:11748:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueAssignment_3_0()); } - // InternalBehaviorAnnexParser.g:11627:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) - // InternalBehaviorAnnexParser.g:11627:3: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 + // InternalBehaviorAnnexParser.g:11749:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 ) + // InternalBehaviorAnnexParser.g:11749:3: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0(); @@ -38764,14 +39222,14 @@ public final void rule__ContainedPropertyAssociation__Group_3__0__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_3__1" - // InternalBehaviorAnnexParser.g:11635:1: rule__ContainedPropertyAssociation__Group_3__1 : rule__ContainedPropertyAssociation__Group_3__1__Impl ; + // InternalBehaviorAnnexParser.g:11757: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:11639:1: ( rule__ContainedPropertyAssociation__Group_3__1__Impl ) - // InternalBehaviorAnnexParser.g:11640:2: rule__ContainedPropertyAssociation__Group_3__1__Impl + // InternalBehaviorAnnexParser.g:11761:1: ( rule__ContainedPropertyAssociation__Group_3__1__Impl ) + // InternalBehaviorAnnexParser.g:11762:2: rule__ContainedPropertyAssociation__Group_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_3__1__Impl(); @@ -38797,35 +39255,35 @@ public final void rule__ContainedPropertyAssociation__Group_3__1() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_3__1__Impl" - // InternalBehaviorAnnexParser.g:11646:1: rule__ContainedPropertyAssociation__Group_3__1__Impl : ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:11768: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:11650:1: ( ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:11651:1: ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) + // InternalBehaviorAnnexParser.g:11772:1: ( ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:11773:1: ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) { - // InternalBehaviorAnnexParser.g:11651:1: ( ( rule__ContainedPropertyAssociation__Group_3_1__0 )* ) - // InternalBehaviorAnnexParser.g:11652:2: ( 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 )* { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup_3_1()); } - // InternalBehaviorAnnexParser.g:11653:2: ( rule__ContainedPropertyAssociation__Group_3_1__0 )* - loop102: + // InternalBehaviorAnnexParser.g:11775:2: ( rule__ContainedPropertyAssociation__Group_3_1__0 )* + loop104: do { - int alt102=2; - int LA102_0 = input.LA(1); + int alt104=2; + int LA104_0 = input.LA(1); - if ( (LA102_0==Comma) ) { - alt102=1; + if ( (LA104_0==Comma) ) { + alt104=1; } - switch (alt102) { + switch (alt104) { case 1 : - // InternalBehaviorAnnexParser.g:11653:3: rule__ContainedPropertyAssociation__Group_3_1__0 + // InternalBehaviorAnnexParser.g:11775:3: rule__ContainedPropertyAssociation__Group_3_1__0 { pushFollow(FollowSets000.FOLLOW_7); rule__ContainedPropertyAssociation__Group_3_1__0(); @@ -38837,7 +39295,7 @@ public final void rule__ContainedPropertyAssociation__Group_3__1__Impl() throws break; default : - break loop102; + break loop104; } } while (true); @@ -38866,16 +39324,16 @@ public final void rule__ContainedPropertyAssociation__Group_3__1__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_3_1__0" - // InternalBehaviorAnnexParser.g:11662:1: rule__ContainedPropertyAssociation__Group_3_1__0 : rule__ContainedPropertyAssociation__Group_3_1__0__Impl rule__ContainedPropertyAssociation__Group_3_1__1 ; + // InternalBehaviorAnnexParser.g:11784: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:11666:1: ( rule__ContainedPropertyAssociation__Group_3_1__0__Impl rule__ContainedPropertyAssociation__Group_3_1__1 ) - // InternalBehaviorAnnexParser.g:11667:2: rule__ContainedPropertyAssociation__Group_3_1__0__Impl rule__ContainedPropertyAssociation__Group_3_1__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_80); + pushFollow(FollowSets000.FOLLOW_81); rule__ContainedPropertyAssociation__Group_3_1__0__Impl(); state._fsp--; @@ -38904,17 +39362,17 @@ public final void rule__ContainedPropertyAssociation__Group_3_1__0() throws Reco // $ANTLR start "rule__ContainedPropertyAssociation__Group_3_1__0__Impl" - // InternalBehaviorAnnexParser.g:11674:1: rule__ContainedPropertyAssociation__Group_3_1__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:11796: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:11678:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:11679:1: ( Comma ) + // InternalBehaviorAnnexParser.g:11800:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:11801:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:11679:1: ( Comma ) - // InternalBehaviorAnnexParser.g:11680:2: Comma + // InternalBehaviorAnnexParser.g:11801:1: ( Comma ) + // InternalBehaviorAnnexParser.g:11802:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getCommaKeyword_3_1_0()); @@ -38945,14 +39403,14 @@ public final void rule__ContainedPropertyAssociation__Group_3_1__0__Impl() throw // $ANTLR start "rule__ContainedPropertyAssociation__Group_3_1__1" - // InternalBehaviorAnnexParser.g:11689:1: rule__ContainedPropertyAssociation__Group_3_1__1 : rule__ContainedPropertyAssociation__Group_3_1__1__Impl ; + // InternalBehaviorAnnexParser.g:11811: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:11693:1: ( rule__ContainedPropertyAssociation__Group_3_1__1__Impl ) - // InternalBehaviorAnnexParser.g:11694:2: rule__ContainedPropertyAssociation__Group_3_1__1__Impl + // InternalBehaviorAnnexParser.g:11815:1: ( rule__ContainedPropertyAssociation__Group_3_1__1__Impl ) + // InternalBehaviorAnnexParser.g:11816:2: rule__ContainedPropertyAssociation__Group_3_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_3_1__1__Impl(); @@ -38978,23 +39436,23 @@ public final void rule__ContainedPropertyAssociation__Group_3_1__1() throws Reco // $ANTLR start "rule__ContainedPropertyAssociation__Group_3_1__1__Impl" - // InternalBehaviorAnnexParser.g:11700:1: rule__ContainedPropertyAssociation__Group_3_1__1__Impl : ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:11822: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:11704:1: ( ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:11705:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) + // InternalBehaviorAnnexParser.g:11826:1: ( ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:11827:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) { - // InternalBehaviorAnnexParser.g:11705:1: ( ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) ) - // InternalBehaviorAnnexParser.g:11706:2: ( 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 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueAssignment_3_1_1()); } - // InternalBehaviorAnnexParser.g:11707:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) - // InternalBehaviorAnnexParser.g:11707:3: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 + // InternalBehaviorAnnexParser.g:11829:2: ( rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 ) + // InternalBehaviorAnnexParser.g:11829:3: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1(); @@ -39029,16 +39487,16 @@ public final void rule__ContainedPropertyAssociation__Group_3_1__1__Impl() throw // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__0" - // InternalBehaviorAnnexParser.g:11716:1: rule__ContainedPropertyAssociation__Group_4__0 : rule__ContainedPropertyAssociation__Group_4__0__Impl rule__ContainedPropertyAssociation__Group_4__1 ; + // InternalBehaviorAnnexParser.g:11838: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:11720:1: ( rule__ContainedPropertyAssociation__Group_4__0__Impl rule__ContainedPropertyAssociation__Group_4__1 ) - // InternalBehaviorAnnexParser.g:11721:2: rule__ContainedPropertyAssociation__Group_4__0__Impl rule__ContainedPropertyAssociation__Group_4__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_83); + pushFollow(FollowSets000.FOLLOW_84); rule__ContainedPropertyAssociation__Group_4__0__Impl(); state._fsp--; @@ -39067,17 +39525,17 @@ public final void rule__ContainedPropertyAssociation__Group_4__0() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__0__Impl" - // InternalBehaviorAnnexParser.g:11728:1: rule__ContainedPropertyAssociation__Group_4__0__Impl : ( Applies ) ; + // InternalBehaviorAnnexParser.g:11850: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:11732:1: ( ( Applies ) ) - // InternalBehaviorAnnexParser.g:11733:1: ( Applies ) + // InternalBehaviorAnnexParser.g:11854:1: ( ( Applies ) ) + // InternalBehaviorAnnexParser.g:11855:1: ( Applies ) { - // InternalBehaviorAnnexParser.g:11733:1: ( Applies ) - // InternalBehaviorAnnexParser.g:11734:2: Applies + // InternalBehaviorAnnexParser.g:11855:1: ( Applies ) + // InternalBehaviorAnnexParser.g:11856:2: Applies { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppliesKeyword_4_0()); @@ -39108,14 +39566,14 @@ public final void rule__ContainedPropertyAssociation__Group_4__0__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__1" - // InternalBehaviorAnnexParser.g:11743:1: rule__ContainedPropertyAssociation__Group_4__1 : rule__ContainedPropertyAssociation__Group_4__1__Impl rule__ContainedPropertyAssociation__Group_4__2 ; + // InternalBehaviorAnnexParser.g:11865: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:11747:1: ( rule__ContainedPropertyAssociation__Group_4__1__Impl rule__ContainedPropertyAssociation__Group_4__2 ) - // InternalBehaviorAnnexParser.g:11748:2: rule__ContainedPropertyAssociation__Group_4__1__Impl rule__ContainedPropertyAssociation__Group_4__2 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__ContainedPropertyAssociation__Group_4__1__Impl(); @@ -39146,17 +39604,17 @@ public final void rule__ContainedPropertyAssociation__Group_4__1() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__1__Impl" - // InternalBehaviorAnnexParser.g:11755:1: rule__ContainedPropertyAssociation__Group_4__1__Impl : ( To ) ; + // InternalBehaviorAnnexParser.g:11877: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:11759:1: ( ( To ) ) - // InternalBehaviorAnnexParser.g:11760:1: ( To ) + // InternalBehaviorAnnexParser.g:11881:1: ( ( To ) ) + // InternalBehaviorAnnexParser.g:11882:1: ( To ) { - // InternalBehaviorAnnexParser.g:11760:1: ( To ) - // InternalBehaviorAnnexParser.g:11761:2: To + // InternalBehaviorAnnexParser.g:11882:1: ( To ) + // InternalBehaviorAnnexParser.g:11883:2: To { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getToKeyword_4_1()); @@ -39187,16 +39645,16 @@ public final void rule__ContainedPropertyAssociation__Group_4__1__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__2" - // InternalBehaviorAnnexParser.g:11770:1: rule__ContainedPropertyAssociation__Group_4__2 : rule__ContainedPropertyAssociation__Group_4__2__Impl rule__ContainedPropertyAssociation__Group_4__3 ; + // InternalBehaviorAnnexParser.g:11892: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:11774:1: ( rule__ContainedPropertyAssociation__Group_4__2__Impl rule__ContainedPropertyAssociation__Group_4__3 ) - // InternalBehaviorAnnexParser.g:11775:2: rule__ContainedPropertyAssociation__Group_4__2__Impl rule__ContainedPropertyAssociation__Group_4__3 + // 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 { - pushFollow(FollowSets000.FOLLOW_82); + pushFollow(FollowSets000.FOLLOW_83); rule__ContainedPropertyAssociation__Group_4__2__Impl(); state._fsp--; @@ -39225,23 +39683,23 @@ public final void rule__ContainedPropertyAssociation__Group_4__2() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__2__Impl" - // InternalBehaviorAnnexParser.g:11782:1: rule__ContainedPropertyAssociation__Group_4__2__Impl : ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) ; + // InternalBehaviorAnnexParser.g:11904: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:11786:1: ( ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) ) - // InternalBehaviorAnnexParser.g:11787:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) + // InternalBehaviorAnnexParser.g:11908:1: ( ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) ) + // InternalBehaviorAnnexParser.g:11909:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) { - // InternalBehaviorAnnexParser.g:11787:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) - // InternalBehaviorAnnexParser.g:11788:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) + // InternalBehaviorAnnexParser.g:11909:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) ) + // InternalBehaviorAnnexParser.g:11910:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToAssignment_4_2()); } - // InternalBehaviorAnnexParser.g:11789:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) - // InternalBehaviorAnnexParser.g:11789:3: rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 + // InternalBehaviorAnnexParser.g:11911:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 ) + // InternalBehaviorAnnexParser.g:11911:3: rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__AppliesToAssignment_4_2(); @@ -39276,14 +39734,14 @@ public final void rule__ContainedPropertyAssociation__Group_4__2__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__3" - // InternalBehaviorAnnexParser.g:11797:1: rule__ContainedPropertyAssociation__Group_4__3 : rule__ContainedPropertyAssociation__Group_4__3__Impl ; + // InternalBehaviorAnnexParser.g:11919: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:11801:1: ( rule__ContainedPropertyAssociation__Group_4__3__Impl ) - // InternalBehaviorAnnexParser.g:11802:2: rule__ContainedPropertyAssociation__Group_4__3__Impl + // InternalBehaviorAnnexParser.g:11923:1: ( rule__ContainedPropertyAssociation__Group_4__3__Impl ) + // InternalBehaviorAnnexParser.g:11924:2: rule__ContainedPropertyAssociation__Group_4__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_4__3__Impl(); @@ -39309,35 +39767,35 @@ public final void rule__ContainedPropertyAssociation__Group_4__3() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_4__3__Impl" - // InternalBehaviorAnnexParser.g:11808:1: rule__ContainedPropertyAssociation__Group_4__3__Impl : ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) ; + // InternalBehaviorAnnexParser.g:11930: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:11812:1: ( ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) ) - // InternalBehaviorAnnexParser.g:11813:1: ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) + // InternalBehaviorAnnexParser.g:11934:1: ( ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) ) + // InternalBehaviorAnnexParser.g:11935:1: ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) { - // InternalBehaviorAnnexParser.g:11813:1: ( ( rule__ContainedPropertyAssociation__Group_4_3__0 )* ) - // InternalBehaviorAnnexParser.g:11814:2: ( 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 )* { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getGroup_4_3()); } - // InternalBehaviorAnnexParser.g:11815:2: ( rule__ContainedPropertyAssociation__Group_4_3__0 )* - loop103: + // InternalBehaviorAnnexParser.g:11937:2: ( rule__ContainedPropertyAssociation__Group_4_3__0 )* + loop105: do { - int alt103=2; - int LA103_0 = input.LA(1); + int alt105=2; + int LA105_0 = input.LA(1); - if ( (LA103_0==Comma) ) { - alt103=1; + if ( (LA105_0==Comma) ) { + alt105=1; } - switch (alt103) { + switch (alt105) { case 1 : - // InternalBehaviorAnnexParser.g:11815:3: rule__ContainedPropertyAssociation__Group_4_3__0 + // InternalBehaviorAnnexParser.g:11937:3: rule__ContainedPropertyAssociation__Group_4_3__0 { pushFollow(FollowSets000.FOLLOW_7); rule__ContainedPropertyAssociation__Group_4_3__0(); @@ -39349,7 +39807,7 @@ public final void rule__ContainedPropertyAssociation__Group_4__3__Impl() throws break; default : - break loop103; + break loop105; } } while (true); @@ -39378,14 +39836,14 @@ public final void rule__ContainedPropertyAssociation__Group_4__3__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_4_3__0" - // InternalBehaviorAnnexParser.g:11824:1: rule__ContainedPropertyAssociation__Group_4_3__0 : rule__ContainedPropertyAssociation__Group_4_3__0__Impl rule__ContainedPropertyAssociation__Group_4_3__1 ; + // InternalBehaviorAnnexParser.g:11946: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:11828:1: ( rule__ContainedPropertyAssociation__Group_4_3__0__Impl rule__ContainedPropertyAssociation__Group_4_3__1 ) - // InternalBehaviorAnnexParser.g:11829:2: rule__ContainedPropertyAssociation__Group_4_3__0__Impl rule__ContainedPropertyAssociation__Group_4_3__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__ContainedPropertyAssociation__Group_4_3__0__Impl(); @@ -39416,17 +39874,17 @@ public final void rule__ContainedPropertyAssociation__Group_4_3__0() throws Reco // $ANTLR start "rule__ContainedPropertyAssociation__Group_4_3__0__Impl" - // InternalBehaviorAnnexParser.g:11836:1: rule__ContainedPropertyAssociation__Group_4_3__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:11958: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:11840:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:11841:1: ( Comma ) + // InternalBehaviorAnnexParser.g:11962:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:11963:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:11841:1: ( Comma ) - // InternalBehaviorAnnexParser.g:11842:2: Comma + // InternalBehaviorAnnexParser.g:11963:1: ( Comma ) + // InternalBehaviorAnnexParser.g:11964:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getCommaKeyword_4_3_0()); @@ -39457,14 +39915,14 @@ public final void rule__ContainedPropertyAssociation__Group_4_3__0__Impl() throw // $ANTLR start "rule__ContainedPropertyAssociation__Group_4_3__1" - // InternalBehaviorAnnexParser.g:11851:1: rule__ContainedPropertyAssociation__Group_4_3__1 : rule__ContainedPropertyAssociation__Group_4_3__1__Impl ; + // InternalBehaviorAnnexParser.g:11973: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:11855:1: ( rule__ContainedPropertyAssociation__Group_4_3__1__Impl ) - // InternalBehaviorAnnexParser.g:11856:2: rule__ContainedPropertyAssociation__Group_4_3__1__Impl + // InternalBehaviorAnnexParser.g:11977:1: ( rule__ContainedPropertyAssociation__Group_4_3__1__Impl ) + // InternalBehaviorAnnexParser.g:11978:2: rule__ContainedPropertyAssociation__Group_4_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_4_3__1__Impl(); @@ -39490,23 +39948,23 @@ public final void rule__ContainedPropertyAssociation__Group_4_3__1() throws Reco // $ANTLR start "rule__ContainedPropertyAssociation__Group_4_3__1__Impl" - // InternalBehaviorAnnexParser.g:11862:1: rule__ContainedPropertyAssociation__Group_4_3__1__Impl : ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:11984: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:11866:1: ( ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:11867:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) + // InternalBehaviorAnnexParser.g:11988:1: ( ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:11989:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) { - // InternalBehaviorAnnexParser.g:11867:1: ( ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) ) - // InternalBehaviorAnnexParser.g:11868:2: ( 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 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToAssignment_4_3_1()); } - // InternalBehaviorAnnexParser.g:11869:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) - // InternalBehaviorAnnexParser.g:11869:3: rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 + // InternalBehaviorAnnexParser.g:11991:2: ( rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 ) + // InternalBehaviorAnnexParser.g:11991:3: rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1(); @@ -39541,14 +39999,14 @@ public final void rule__ContainedPropertyAssociation__Group_4_3__1__Impl() throw // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__0" - // InternalBehaviorAnnexParser.g:11878:1: rule__ContainedPropertyAssociation__Group_5__0 : rule__ContainedPropertyAssociation__Group_5__0__Impl rule__ContainedPropertyAssociation__Group_5__1 ; + // InternalBehaviorAnnexParser.g:12000: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:11882:1: ( rule__ContainedPropertyAssociation__Group_5__0__Impl rule__ContainedPropertyAssociation__Group_5__1 ) - // InternalBehaviorAnnexParser.g:11883:2: rule__ContainedPropertyAssociation__Group_5__0__Impl rule__ContainedPropertyAssociation__Group_5__1 + // 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 { pushFollow(FollowSets000.FOLLOW_51); rule__ContainedPropertyAssociation__Group_5__0__Impl(); @@ -39579,17 +40037,17 @@ public final void rule__ContainedPropertyAssociation__Group_5__0() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__0__Impl" - // InternalBehaviorAnnexParser.g:11890:1: rule__ContainedPropertyAssociation__Group_5__0__Impl : ( In ) ; + // InternalBehaviorAnnexParser.g:12012: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:11894:1: ( ( In ) ) - // InternalBehaviorAnnexParser.g:11895:1: ( In ) + // InternalBehaviorAnnexParser.g:12016:1: ( ( In ) ) + // InternalBehaviorAnnexParser.g:12017:1: ( In ) { - // InternalBehaviorAnnexParser.g:11895:1: ( In ) - // InternalBehaviorAnnexParser.g:11896:2: In + // InternalBehaviorAnnexParser.g:12017:1: ( In ) + // InternalBehaviorAnnexParser.g:12018:2: In { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getInKeyword_5_0()); @@ -39620,14 +40078,14 @@ public final void rule__ContainedPropertyAssociation__Group_5__0__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__1" - // InternalBehaviorAnnexParser.g:11905:1: rule__ContainedPropertyAssociation__Group_5__1 : rule__ContainedPropertyAssociation__Group_5__1__Impl rule__ContainedPropertyAssociation__Group_5__2 ; + // InternalBehaviorAnnexParser.g:12027: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:11909:1: ( rule__ContainedPropertyAssociation__Group_5__1__Impl rule__ContainedPropertyAssociation__Group_5__2 ) - // InternalBehaviorAnnexParser.g:11910:2: rule__ContainedPropertyAssociation__Group_5__1__Impl rule__ContainedPropertyAssociation__Group_5__2 + // 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 { pushFollow(FollowSets000.FOLLOW_27); rule__ContainedPropertyAssociation__Group_5__1__Impl(); @@ -39658,17 +40116,17 @@ public final void rule__ContainedPropertyAssociation__Group_5__1() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__1__Impl" - // InternalBehaviorAnnexParser.g:11917:1: rule__ContainedPropertyAssociation__Group_5__1__Impl : ( Binding ) ; + // InternalBehaviorAnnexParser.g:12039: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:11921:1: ( ( Binding ) ) - // InternalBehaviorAnnexParser.g:11922:1: ( Binding ) + // InternalBehaviorAnnexParser.g:12043:1: ( ( Binding ) ) + // InternalBehaviorAnnexParser.g:12044:1: ( Binding ) { - // InternalBehaviorAnnexParser.g:11922:1: ( Binding ) - // InternalBehaviorAnnexParser.g:11923:2: Binding + // InternalBehaviorAnnexParser.g:12044:1: ( Binding ) + // InternalBehaviorAnnexParser.g:12045:2: Binding { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getBindingKeyword_5_1()); @@ -39699,14 +40157,14 @@ public final void rule__ContainedPropertyAssociation__Group_5__1__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__2" - // InternalBehaviorAnnexParser.g:11932:1: rule__ContainedPropertyAssociation__Group_5__2 : rule__ContainedPropertyAssociation__Group_5__2__Impl rule__ContainedPropertyAssociation__Group_5__3 ; + // InternalBehaviorAnnexParser.g:12054: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:11936:1: ( rule__ContainedPropertyAssociation__Group_5__2__Impl rule__ContainedPropertyAssociation__Group_5__3 ) - // InternalBehaviorAnnexParser.g:11937:2: rule__ContainedPropertyAssociation__Group_5__2__Impl rule__ContainedPropertyAssociation__Group_5__3 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__ContainedPropertyAssociation__Group_5__2__Impl(); @@ -39737,17 +40195,17 @@ public final void rule__ContainedPropertyAssociation__Group_5__2() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__2__Impl" - // InternalBehaviorAnnexParser.g:11944:1: rule__ContainedPropertyAssociation__Group_5__2__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12066: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:11948:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:11949:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12070:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12071:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:11949:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:11950:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12071:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12072:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getLeftParenthesisKeyword_5_2()); @@ -39778,14 +40236,14 @@ public final void rule__ContainedPropertyAssociation__Group_5__2__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__3" - // InternalBehaviorAnnexParser.g:11959:1: rule__ContainedPropertyAssociation__Group_5__3 : rule__ContainedPropertyAssociation__Group_5__3__Impl rule__ContainedPropertyAssociation__Group_5__4 ; + // InternalBehaviorAnnexParser.g:12081: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:11963:1: ( rule__ContainedPropertyAssociation__Group_5__3__Impl rule__ContainedPropertyAssociation__Group_5__4 ) - // InternalBehaviorAnnexParser.g:11964:2: rule__ContainedPropertyAssociation__Group_5__3__Impl rule__ContainedPropertyAssociation__Group_5__4 + // 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 { pushFollow(FollowSets000.FOLLOW_37); rule__ContainedPropertyAssociation__Group_5__3__Impl(); @@ -39816,23 +40274,23 @@ public final void rule__ContainedPropertyAssociation__Group_5__3() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__3__Impl" - // InternalBehaviorAnnexParser.g:11971:1: rule__ContainedPropertyAssociation__Group_5__3__Impl : ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) ; + // InternalBehaviorAnnexParser.g:12093: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:11975:1: ( ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) ) - // InternalBehaviorAnnexParser.g:11976:1: ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) + // InternalBehaviorAnnexParser.g:12097:1: ( ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) ) + // InternalBehaviorAnnexParser.g:12098:1: ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) { - // InternalBehaviorAnnexParser.g:11976:1: ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) - // InternalBehaviorAnnexParser.g:11977:2: ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) + // InternalBehaviorAnnexParser.g:12098:1: ( ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) ) + // InternalBehaviorAnnexParser.g:12099:2: ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getInBindingAssignment_5_3()); } - // InternalBehaviorAnnexParser.g:11978:2: ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) - // InternalBehaviorAnnexParser.g:11978:3: rule__ContainedPropertyAssociation__InBindingAssignment_5_3 + // InternalBehaviorAnnexParser.g:12100:2: ( rule__ContainedPropertyAssociation__InBindingAssignment_5_3 ) + // InternalBehaviorAnnexParser.g:12100:3: rule__ContainedPropertyAssociation__InBindingAssignment_5_3 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__InBindingAssignment_5_3(); @@ -39867,14 +40325,14 @@ public final void rule__ContainedPropertyAssociation__Group_5__3__Impl() throws // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__4" - // InternalBehaviorAnnexParser.g:11986:1: rule__ContainedPropertyAssociation__Group_5__4 : rule__ContainedPropertyAssociation__Group_5__4__Impl ; + // InternalBehaviorAnnexParser.g:12108: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:11990:1: ( rule__ContainedPropertyAssociation__Group_5__4__Impl ) - // InternalBehaviorAnnexParser.g:11991:2: rule__ContainedPropertyAssociation__Group_5__4__Impl + // InternalBehaviorAnnexParser.g:12112:1: ( rule__ContainedPropertyAssociation__Group_5__4__Impl ) + // InternalBehaviorAnnexParser.g:12113:2: rule__ContainedPropertyAssociation__Group_5__4__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainedPropertyAssociation__Group_5__4__Impl(); @@ -39900,17 +40358,17 @@ public final void rule__ContainedPropertyAssociation__Group_5__4() throws Recogn // $ANTLR start "rule__ContainedPropertyAssociation__Group_5__4__Impl" - // InternalBehaviorAnnexParser.g:11997:1: rule__ContainedPropertyAssociation__Group_5__4__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12119: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:12001:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12002:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12123:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12124:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12002:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12003:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12124:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12125:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getRightParenthesisKeyword_5_4()); @@ -39941,14 +40399,14 @@ public final void rule__ContainedPropertyAssociation__Group_5__4__Impl() throws // $ANTLR start "rule__OptionalModalPropertyValue__Group__0" - // InternalBehaviorAnnexParser.g:12013:1: rule__OptionalModalPropertyValue__Group__0 : rule__OptionalModalPropertyValue__Group__0__Impl rule__OptionalModalPropertyValue__Group__1 ; + // InternalBehaviorAnnexParser.g:12135: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:12017:1: ( rule__OptionalModalPropertyValue__Group__0__Impl rule__OptionalModalPropertyValue__Group__1 ) - // InternalBehaviorAnnexParser.g:12018:2: rule__OptionalModalPropertyValue__Group__0__Impl rule__OptionalModalPropertyValue__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_50); rule__OptionalModalPropertyValue__Group__0__Impl(); @@ -39979,23 +40437,23 @@ public final void rule__OptionalModalPropertyValue__Group__0() throws Recognitio // $ANTLR start "rule__OptionalModalPropertyValue__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12025:1: rule__OptionalModalPropertyValue__Group__0__Impl : ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:12147: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:12029:1: ( ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:12030:1: ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:12151:1: ( ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:12152:1: ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:12030:1: ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:12031:2: ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:12152:1: ( ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:12153:2: ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getOwnedValueAssignment_0()); } - // InternalBehaviorAnnexParser.g:12032:2: ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) - // InternalBehaviorAnnexParser.g:12032:3: rule__OptionalModalPropertyValue__OwnedValueAssignment_0 + // InternalBehaviorAnnexParser.g:12154:2: ( rule__OptionalModalPropertyValue__OwnedValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:12154:3: rule__OptionalModalPropertyValue__OwnedValueAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__OwnedValueAssignment_0(); @@ -40030,14 +40488,14 @@ public final void rule__OptionalModalPropertyValue__Group__0__Impl() throws Reco // $ANTLR start "rule__OptionalModalPropertyValue__Group__1" - // InternalBehaviorAnnexParser.g:12040:1: rule__OptionalModalPropertyValue__Group__1 : rule__OptionalModalPropertyValue__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:12162: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:12044:1: ( rule__OptionalModalPropertyValue__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:12045:2: rule__OptionalModalPropertyValue__Group__1__Impl + // InternalBehaviorAnnexParser.g:12166:1: ( rule__OptionalModalPropertyValue__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:12167:2: rule__OptionalModalPropertyValue__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__Group__1__Impl(); @@ -40063,35 +40521,35 @@ public final void rule__OptionalModalPropertyValue__Group__1() throws Recognitio // $ANTLR start "rule__OptionalModalPropertyValue__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12051:1: rule__OptionalModalPropertyValue__Group__1__Impl : ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:12173: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:12055:1: ( ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:12056:1: ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:12177:1: ( ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:12178:1: ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:12056:1: ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:12057:2: ( rule__OptionalModalPropertyValue__Group_1__0 )? + // InternalBehaviorAnnexParser.g:12178:1: ( ( rule__OptionalModalPropertyValue__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:12179:2: ( rule__OptionalModalPropertyValue__Group_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:12058:2: ( rule__OptionalModalPropertyValue__Group_1__0 )? - int alt104=2; - int LA104_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:12180:2: ( rule__OptionalModalPropertyValue__Group_1__0 )? + int alt106=2; + int LA106_0 = input.LA(1); - if ( (LA104_0==In) ) { - int LA104_1 = input.LA(2); + if ( (LA106_0==In) ) { + int LA106_1 = input.LA(2); - if ( (LA104_1==Modes) ) { - alt104=1; + if ( (LA106_1==Modes) ) { + alt106=1; } } - switch (alt104) { + switch (alt106) { case 1 : - // InternalBehaviorAnnexParser.g:12058:3: rule__OptionalModalPropertyValue__Group_1__0 + // InternalBehaviorAnnexParser.g:12180:3: rule__OptionalModalPropertyValue__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__Group_1__0(); @@ -40129,16 +40587,16 @@ public final void rule__OptionalModalPropertyValue__Group__1__Impl() throws Reco // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__0" - // InternalBehaviorAnnexParser.g:12067:1: rule__OptionalModalPropertyValue__Group_1__0 : rule__OptionalModalPropertyValue__Group_1__0__Impl rule__OptionalModalPropertyValue__Group_1__1 ; + // InternalBehaviorAnnexParser.g:12189: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:12071:1: ( rule__OptionalModalPropertyValue__Group_1__0__Impl rule__OptionalModalPropertyValue__Group_1__1 ) - // InternalBehaviorAnnexParser.g:12072:2: rule__OptionalModalPropertyValue__Group_1__0__Impl rule__OptionalModalPropertyValue__Group_1__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_84); + pushFollow(FollowSets000.FOLLOW_85); rule__OptionalModalPropertyValue__Group_1__0__Impl(); state._fsp--; @@ -40167,17 +40625,17 @@ public final void rule__OptionalModalPropertyValue__Group_1__0() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:12079:1: rule__OptionalModalPropertyValue__Group_1__0__Impl : ( In ) ; + // InternalBehaviorAnnexParser.g:12201: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:12083:1: ( ( In ) ) - // InternalBehaviorAnnexParser.g:12084:1: ( In ) + // InternalBehaviorAnnexParser.g:12205:1: ( ( In ) ) + // InternalBehaviorAnnexParser.g:12206:1: ( In ) { - // InternalBehaviorAnnexParser.g:12084:1: ( In ) - // InternalBehaviorAnnexParser.g:12085:2: In + // InternalBehaviorAnnexParser.g:12206:1: ( In ) + // InternalBehaviorAnnexParser.g:12207:2: In { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInKeyword_1_0()); @@ -40208,14 +40666,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__0__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__1" - // InternalBehaviorAnnexParser.g:12094:1: rule__OptionalModalPropertyValue__Group_1__1 : rule__OptionalModalPropertyValue__Group_1__1__Impl rule__OptionalModalPropertyValue__Group_1__2 ; + // InternalBehaviorAnnexParser.g:12216: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:12098:1: ( rule__OptionalModalPropertyValue__Group_1__1__Impl rule__OptionalModalPropertyValue__Group_1__2 ) - // InternalBehaviorAnnexParser.g:12099:2: rule__OptionalModalPropertyValue__Group_1__1__Impl rule__OptionalModalPropertyValue__Group_1__2 + // 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 { pushFollow(FollowSets000.FOLLOW_27); rule__OptionalModalPropertyValue__Group_1__1__Impl(); @@ -40246,17 +40704,17 @@ public final void rule__OptionalModalPropertyValue__Group_1__1() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:12106:1: rule__OptionalModalPropertyValue__Group_1__1__Impl : ( Modes ) ; + // InternalBehaviorAnnexParser.g:12228: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:12110:1: ( ( Modes ) ) - // InternalBehaviorAnnexParser.g:12111:1: ( Modes ) + // InternalBehaviorAnnexParser.g:12232:1: ( ( Modes ) ) + // InternalBehaviorAnnexParser.g:12233:1: ( Modes ) { - // InternalBehaviorAnnexParser.g:12111:1: ( Modes ) - // InternalBehaviorAnnexParser.g:12112:2: Modes + // InternalBehaviorAnnexParser.g:12233:1: ( Modes ) + // InternalBehaviorAnnexParser.g:12234:2: Modes { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getModesKeyword_1_1()); @@ -40287,14 +40745,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__1__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__2" - // InternalBehaviorAnnexParser.g:12121:1: rule__OptionalModalPropertyValue__Group_1__2 : rule__OptionalModalPropertyValue__Group_1__2__Impl rule__OptionalModalPropertyValue__Group_1__3 ; + // InternalBehaviorAnnexParser.g:12243: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:12125:1: ( rule__OptionalModalPropertyValue__Group_1__2__Impl rule__OptionalModalPropertyValue__Group_1__3 ) - // InternalBehaviorAnnexParser.g:12126:2: rule__OptionalModalPropertyValue__Group_1__2__Impl rule__OptionalModalPropertyValue__Group_1__3 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__OptionalModalPropertyValue__Group_1__2__Impl(); @@ -40325,17 +40783,17 @@ public final void rule__OptionalModalPropertyValue__Group_1__2() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__2__Impl" - // InternalBehaviorAnnexParser.g:12133:1: rule__OptionalModalPropertyValue__Group_1__2__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12255: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:12137:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12138:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12259:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12260:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12138:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12139:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12260:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12261:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getLeftParenthesisKeyword_1_2()); @@ -40366,14 +40824,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__2__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__3" - // InternalBehaviorAnnexParser.g:12148:1: rule__OptionalModalPropertyValue__Group_1__3 : rule__OptionalModalPropertyValue__Group_1__3__Impl rule__OptionalModalPropertyValue__Group_1__4 ; + // InternalBehaviorAnnexParser.g:12270: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:12152:1: ( rule__OptionalModalPropertyValue__Group_1__3__Impl rule__OptionalModalPropertyValue__Group_1__4 ) - // InternalBehaviorAnnexParser.g:12153:2: rule__OptionalModalPropertyValue__Group_1__3__Impl rule__OptionalModalPropertyValue__Group_1__4 + // 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 { pushFollow(FollowSets000.FOLLOW_28); rule__OptionalModalPropertyValue__Group_1__3__Impl(); @@ -40404,23 +40862,23 @@ public final void rule__OptionalModalPropertyValue__Group_1__3() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__3__Impl" - // InternalBehaviorAnnexParser.g:12160:1: rule__OptionalModalPropertyValue__Group_1__3__Impl : ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) ; + // InternalBehaviorAnnexParser.g:12282: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:12164:1: ( ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) ) - // InternalBehaviorAnnexParser.g:12165:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) + // InternalBehaviorAnnexParser.g:12286:1: ( ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) ) + // InternalBehaviorAnnexParser.g:12287:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) { - // InternalBehaviorAnnexParser.g:12165:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) - // InternalBehaviorAnnexParser.g:12166:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) + // InternalBehaviorAnnexParser.g:12287:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) ) + // InternalBehaviorAnnexParser.g:12288:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeAssignment_1_3()); } - // InternalBehaviorAnnexParser.g:12167:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) - // InternalBehaviorAnnexParser.g:12167:3: rule__OptionalModalPropertyValue__InModeAssignment_1_3 + // InternalBehaviorAnnexParser.g:12289:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_3 ) + // InternalBehaviorAnnexParser.g:12289:3: rule__OptionalModalPropertyValue__InModeAssignment_1_3 { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__InModeAssignment_1_3(); @@ -40455,14 +40913,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__3__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__4" - // InternalBehaviorAnnexParser.g:12175:1: rule__OptionalModalPropertyValue__Group_1__4 : rule__OptionalModalPropertyValue__Group_1__4__Impl rule__OptionalModalPropertyValue__Group_1__5 ; + // InternalBehaviorAnnexParser.g:12297: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:12179:1: ( rule__OptionalModalPropertyValue__Group_1__4__Impl rule__OptionalModalPropertyValue__Group_1__5 ) - // InternalBehaviorAnnexParser.g:12180:2: rule__OptionalModalPropertyValue__Group_1__4__Impl rule__OptionalModalPropertyValue__Group_1__5 + // 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 { pushFollow(FollowSets000.FOLLOW_28); rule__OptionalModalPropertyValue__Group_1__4__Impl(); @@ -40493,35 +40951,35 @@ public final void rule__OptionalModalPropertyValue__Group_1__4() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__4__Impl" - // InternalBehaviorAnnexParser.g:12187:1: rule__OptionalModalPropertyValue__Group_1__4__Impl : ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) ; + // InternalBehaviorAnnexParser.g:12309: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:12191:1: ( ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) ) - // InternalBehaviorAnnexParser.g:12192:1: ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) + // InternalBehaviorAnnexParser.g:12313:1: ( ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) ) + // InternalBehaviorAnnexParser.g:12314:1: ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) { - // InternalBehaviorAnnexParser.g:12192:1: ( ( rule__OptionalModalPropertyValue__Group_1_4__0 )* ) - // InternalBehaviorAnnexParser.g:12193:2: ( 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 )* { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getGroup_1_4()); } - // InternalBehaviorAnnexParser.g:12194:2: ( rule__OptionalModalPropertyValue__Group_1_4__0 )* - loop105: + // InternalBehaviorAnnexParser.g:12316:2: ( rule__OptionalModalPropertyValue__Group_1_4__0 )* + loop107: do { - int alt105=2; - int LA105_0 = input.LA(1); + int alt107=2; + int LA107_0 = input.LA(1); - if ( (LA105_0==Comma) ) { - alt105=1; + if ( (LA107_0==Comma) ) { + alt107=1; } - switch (alt105) { + switch (alt107) { case 1 : - // InternalBehaviorAnnexParser.g:12194:3: rule__OptionalModalPropertyValue__Group_1_4__0 + // InternalBehaviorAnnexParser.g:12316:3: rule__OptionalModalPropertyValue__Group_1_4__0 { pushFollow(FollowSets000.FOLLOW_7); rule__OptionalModalPropertyValue__Group_1_4__0(); @@ -40533,7 +40991,7 @@ public final void rule__OptionalModalPropertyValue__Group_1__4__Impl() throws Re break; default : - break loop105; + break loop107; } } while (true); @@ -40562,14 +41020,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__4__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__5" - // InternalBehaviorAnnexParser.g:12202:1: rule__OptionalModalPropertyValue__Group_1__5 : rule__OptionalModalPropertyValue__Group_1__5__Impl ; + // InternalBehaviorAnnexParser.g:12324: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:12206:1: ( rule__OptionalModalPropertyValue__Group_1__5__Impl ) - // InternalBehaviorAnnexParser.g:12207:2: rule__OptionalModalPropertyValue__Group_1__5__Impl + // InternalBehaviorAnnexParser.g:12328:1: ( rule__OptionalModalPropertyValue__Group_1__5__Impl ) + // InternalBehaviorAnnexParser.g:12329:2: rule__OptionalModalPropertyValue__Group_1__5__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__Group_1__5__Impl(); @@ -40595,17 +41053,17 @@ public final void rule__OptionalModalPropertyValue__Group_1__5() throws Recognit // $ANTLR start "rule__OptionalModalPropertyValue__Group_1__5__Impl" - // InternalBehaviorAnnexParser.g:12213:1: rule__OptionalModalPropertyValue__Group_1__5__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12335: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:12217:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12218:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12339:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12340:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12218:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12219:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12340:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12341:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getRightParenthesisKeyword_1_5()); @@ -40636,14 +41094,14 @@ public final void rule__OptionalModalPropertyValue__Group_1__5__Impl() throws Re // $ANTLR start "rule__OptionalModalPropertyValue__Group_1_4__0" - // InternalBehaviorAnnexParser.g:12229:1: rule__OptionalModalPropertyValue__Group_1_4__0 : rule__OptionalModalPropertyValue__Group_1_4__0__Impl rule__OptionalModalPropertyValue__Group_1_4__1 ; + // InternalBehaviorAnnexParser.g:12351: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:12233:1: ( rule__OptionalModalPropertyValue__Group_1_4__0__Impl rule__OptionalModalPropertyValue__Group_1_4__1 ) - // InternalBehaviorAnnexParser.g:12234:2: rule__OptionalModalPropertyValue__Group_1_4__0__Impl rule__OptionalModalPropertyValue__Group_1_4__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__OptionalModalPropertyValue__Group_1_4__0__Impl(); @@ -40674,17 +41132,17 @@ public final void rule__OptionalModalPropertyValue__Group_1_4__0() throws Recogn // $ANTLR start "rule__OptionalModalPropertyValue__Group_1_4__0__Impl" - // InternalBehaviorAnnexParser.g:12241:1: rule__OptionalModalPropertyValue__Group_1_4__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:12363: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:12245:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:12246:1: ( Comma ) + // InternalBehaviorAnnexParser.g:12367:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:12368:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:12246:1: ( Comma ) - // InternalBehaviorAnnexParser.g:12247:2: Comma + // InternalBehaviorAnnexParser.g:12368:1: ( Comma ) + // InternalBehaviorAnnexParser.g:12369:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getCommaKeyword_1_4_0()); @@ -40715,14 +41173,14 @@ public final void rule__OptionalModalPropertyValue__Group_1_4__0__Impl() throws // $ANTLR start "rule__OptionalModalPropertyValue__Group_1_4__1" - // InternalBehaviorAnnexParser.g:12256:1: rule__OptionalModalPropertyValue__Group_1_4__1 : rule__OptionalModalPropertyValue__Group_1_4__1__Impl ; + // InternalBehaviorAnnexParser.g:12378: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:12260:1: ( rule__OptionalModalPropertyValue__Group_1_4__1__Impl ) - // InternalBehaviorAnnexParser.g:12261:2: rule__OptionalModalPropertyValue__Group_1_4__1__Impl + // InternalBehaviorAnnexParser.g:12382:1: ( rule__OptionalModalPropertyValue__Group_1_4__1__Impl ) + // InternalBehaviorAnnexParser.g:12383:2: rule__OptionalModalPropertyValue__Group_1_4__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__Group_1_4__1__Impl(); @@ -40748,23 +41206,23 @@ public final void rule__OptionalModalPropertyValue__Group_1_4__1() throws Recogn // $ANTLR start "rule__OptionalModalPropertyValue__Group_1_4__1__Impl" - // InternalBehaviorAnnexParser.g:12267:1: rule__OptionalModalPropertyValue__Group_1_4__1__Impl : ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) ; + // InternalBehaviorAnnexParser.g:12389: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:12271:1: ( ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) ) - // InternalBehaviorAnnexParser.g:12272:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) + // InternalBehaviorAnnexParser.g:12393:1: ( ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) ) + // InternalBehaviorAnnexParser.g:12394:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) { - // InternalBehaviorAnnexParser.g:12272:1: ( ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) ) - // InternalBehaviorAnnexParser.g:12273:2: ( 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 ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeAssignment_1_4_1()); } - // InternalBehaviorAnnexParser.g:12274:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) - // InternalBehaviorAnnexParser.g:12274:3: rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 + // InternalBehaviorAnnexParser.g:12396:2: ( rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 ) + // InternalBehaviorAnnexParser.g:12396:3: rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 { pushFollow(FollowSets000.FOLLOW_2); rule__OptionalModalPropertyValue__InModeAssignment_1_4_1(); @@ -40799,16 +41257,16 @@ public final void rule__OptionalModalPropertyValue__Group_1_4__1__Impl() throws // $ANTLR start "rule__BooleanLiteral__Group__0" - // InternalBehaviorAnnexParser.g:12283:1: rule__BooleanLiteral__Group__0 : rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ; + // InternalBehaviorAnnexParser.g:12405: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:12287:1: ( rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ) - // InternalBehaviorAnnexParser.g:12288:2: rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_68); + pushFollow(FollowSets000.FOLLOW_69); rule__BooleanLiteral__Group__0__Impl(); state._fsp--; @@ -40837,23 +41295,23 @@ public final void rule__BooleanLiteral__Group__0() throws RecognitionException { // $ANTLR start "rule__BooleanLiteral__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12295:1: rule__BooleanLiteral__Group__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:12417:1: rule__BooleanLiteral__Group__0__Impl : ( () ) ; public final void rule__BooleanLiteral__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12299:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:12300:1: ( () ) + // InternalBehaviorAnnexParser.g:12421:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:12422:1: ( () ) { - // InternalBehaviorAnnexParser.g:12300:1: ( () ) - // InternalBehaviorAnnexParser.g:12301:2: () + // InternalBehaviorAnnexParser.g:12422:1: ( () ) + // InternalBehaviorAnnexParser.g:12423:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); } - // InternalBehaviorAnnexParser.g:12302:2: () - // InternalBehaviorAnnexParser.g:12302:3: + // InternalBehaviorAnnexParser.g:12424:2: () + // InternalBehaviorAnnexParser.g:12424:3: { } @@ -40878,14 +41336,14 @@ public final void rule__BooleanLiteral__Group__0__Impl() throws RecognitionExcep // $ANTLR start "rule__BooleanLiteral__Group__1" - // InternalBehaviorAnnexParser.g:12310:1: rule__BooleanLiteral__Group__1 : rule__BooleanLiteral__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:12432: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:12314:1: ( rule__BooleanLiteral__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:12315:2: rule__BooleanLiteral__Group__1__Impl + // InternalBehaviorAnnexParser.g:12436:1: ( rule__BooleanLiteral__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:12437:2: rule__BooleanLiteral__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__BooleanLiteral__Group__1__Impl(); @@ -40911,23 +41369,23 @@ public final void rule__BooleanLiteral__Group__1() throws RecognitionException { // $ANTLR start "rule__BooleanLiteral__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12321:1: rule__BooleanLiteral__Group__1__Impl : ( ( rule__BooleanLiteral__Alternatives_1 ) ) ; + // InternalBehaviorAnnexParser.g:12443: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:12325:1: ( ( ( rule__BooleanLiteral__Alternatives_1 ) ) ) - // InternalBehaviorAnnexParser.g:12326:1: ( ( rule__BooleanLiteral__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:12447:1: ( ( ( rule__BooleanLiteral__Alternatives_1 ) ) ) + // InternalBehaviorAnnexParser.g:12448:1: ( ( rule__BooleanLiteral__Alternatives_1 ) ) { - // InternalBehaviorAnnexParser.g:12326:1: ( ( rule__BooleanLiteral__Alternatives_1 ) ) - // InternalBehaviorAnnexParser.g:12327:2: ( rule__BooleanLiteral__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:12448:1: ( ( rule__BooleanLiteral__Alternatives_1 ) ) + // InternalBehaviorAnnexParser.g:12449:2: ( rule__BooleanLiteral__Alternatives_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getAlternatives_1()); } - // InternalBehaviorAnnexParser.g:12328:2: ( rule__BooleanLiteral__Alternatives_1 ) - // InternalBehaviorAnnexParser.g:12328:3: rule__BooleanLiteral__Alternatives_1 + // InternalBehaviorAnnexParser.g:12450:2: ( rule__BooleanLiteral__Alternatives_1 ) + // InternalBehaviorAnnexParser.g:12450:3: rule__BooleanLiteral__Alternatives_1 { pushFollow(FollowSets000.FOLLOW_2); rule__BooleanLiteral__Alternatives_1(); @@ -40962,14 +41420,14 @@ public final void rule__BooleanLiteral__Group__1__Impl() throws RecognitionExcep // $ANTLR start "rule__ReferenceTerm__Group__0" - // InternalBehaviorAnnexParser.g:12337:1: rule__ReferenceTerm__Group__0 : rule__ReferenceTerm__Group__0__Impl rule__ReferenceTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:12459: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:12341:1: ( rule__ReferenceTerm__Group__0__Impl rule__ReferenceTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:12342:2: rule__ReferenceTerm__Group__0__Impl rule__ReferenceTerm__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_27); rule__ReferenceTerm__Group__0__Impl(); @@ -41000,17 +41458,17 @@ public final void rule__ReferenceTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__ReferenceTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12349:1: rule__ReferenceTerm__Group__0__Impl : ( Reference ) ; + // InternalBehaviorAnnexParser.g:12471:1: rule__ReferenceTerm__Group__0__Impl : ( Reference ) ; public final void rule__ReferenceTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12353:1: ( ( Reference ) ) - // InternalBehaviorAnnexParser.g:12354:1: ( Reference ) + // InternalBehaviorAnnexParser.g:12475:1: ( ( Reference ) ) + // InternalBehaviorAnnexParser.g:12476:1: ( Reference ) { - // InternalBehaviorAnnexParser.g:12354:1: ( Reference ) - // InternalBehaviorAnnexParser.g:12355:2: Reference + // InternalBehaviorAnnexParser.g:12476:1: ( Reference ) + // InternalBehaviorAnnexParser.g:12477:2: Reference { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getReferenceKeyword_0()); @@ -41041,14 +41499,14 @@ public final void rule__ReferenceTerm__Group__0__Impl() throws RecognitionExcept // $ANTLR start "rule__ReferenceTerm__Group__1" - // InternalBehaviorAnnexParser.g:12364:1: rule__ReferenceTerm__Group__1 : rule__ReferenceTerm__Group__1__Impl rule__ReferenceTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:12486: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:12368:1: ( rule__ReferenceTerm__Group__1__Impl rule__ReferenceTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:12369:2: rule__ReferenceTerm__Group__1__Impl rule__ReferenceTerm__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__ReferenceTerm__Group__1__Impl(); @@ -41079,17 +41537,17 @@ public final void rule__ReferenceTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__ReferenceTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12376:1: rule__ReferenceTerm__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12498:1: rule__ReferenceTerm__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__ReferenceTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12380:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12381:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12502:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12503:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12381:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12382:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12503:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12504:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getLeftParenthesisKeyword_1()); @@ -41120,14 +41578,14 @@ public final void rule__ReferenceTerm__Group__1__Impl() throws RecognitionExcept // $ANTLR start "rule__ReferenceTerm__Group__2" - // InternalBehaviorAnnexParser.g:12391:1: rule__ReferenceTerm__Group__2 : rule__ReferenceTerm__Group__2__Impl rule__ReferenceTerm__Group__3 ; + // InternalBehaviorAnnexParser.g:12513: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:12395:1: ( rule__ReferenceTerm__Group__2__Impl rule__ReferenceTerm__Group__3 ) - // InternalBehaviorAnnexParser.g:12396:2: rule__ReferenceTerm__Group__2__Impl rule__ReferenceTerm__Group__3 + // 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 { pushFollow(FollowSets000.FOLLOW_37); rule__ReferenceTerm__Group__2__Impl(); @@ -41158,23 +41616,23 @@ public final void rule__ReferenceTerm__Group__2() throws RecognitionException { // $ANTLR start "rule__ReferenceTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:12403:1: rule__ReferenceTerm__Group__2__Impl : ( ( rule__ReferenceTerm__PathAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:12525: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:12407:1: ( ( ( rule__ReferenceTerm__PathAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:12408:1: ( ( rule__ReferenceTerm__PathAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12529:1: ( ( ( rule__ReferenceTerm__PathAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:12530:1: ( ( rule__ReferenceTerm__PathAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:12408:1: ( ( rule__ReferenceTerm__PathAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:12409:2: ( rule__ReferenceTerm__PathAssignment_2 ) + // InternalBehaviorAnnexParser.g:12530:1: ( ( rule__ReferenceTerm__PathAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12531:2: ( rule__ReferenceTerm__PathAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getPathAssignment_2()); } - // InternalBehaviorAnnexParser.g:12410:2: ( rule__ReferenceTerm__PathAssignment_2 ) - // InternalBehaviorAnnexParser.g:12410:3: rule__ReferenceTerm__PathAssignment_2 + // InternalBehaviorAnnexParser.g:12532:2: ( rule__ReferenceTerm__PathAssignment_2 ) + // InternalBehaviorAnnexParser.g:12532:3: rule__ReferenceTerm__PathAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTerm__PathAssignment_2(); @@ -41209,14 +41667,14 @@ public final void rule__ReferenceTerm__Group__2__Impl() throws RecognitionExcept // $ANTLR start "rule__ReferenceTerm__Group__3" - // InternalBehaviorAnnexParser.g:12418:1: rule__ReferenceTerm__Group__3 : rule__ReferenceTerm__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:12540: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:12422:1: ( rule__ReferenceTerm__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:12423:2: rule__ReferenceTerm__Group__3__Impl + // InternalBehaviorAnnexParser.g:12544:1: ( rule__ReferenceTerm__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:12545:2: rule__ReferenceTerm__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ReferenceTerm__Group__3__Impl(); @@ -41242,17 +41700,17 @@ public final void rule__ReferenceTerm__Group__3() throws RecognitionException { // $ANTLR start "rule__ReferenceTerm__Group__3__Impl" - // InternalBehaviorAnnexParser.g:12429:1: rule__ReferenceTerm__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12551:1: rule__ReferenceTerm__Group__3__Impl : ( RightParenthesis ) ; public final void rule__ReferenceTerm__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12433:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12434:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12555:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12556:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12434:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12435:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12556:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12557:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getRightParenthesisKeyword_3()); @@ -41283,14 +41741,14 @@ public final void rule__ReferenceTerm__Group__3__Impl() throws RecognitionExcept // $ANTLR start "rule__RecordTerm__Group__0" - // InternalBehaviorAnnexParser.g:12445:1: rule__RecordTerm__Group__0 : rule__RecordTerm__Group__0__Impl rule__RecordTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:12567: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:12449:1: ( rule__RecordTerm__Group__0__Impl rule__RecordTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:12450:2: rule__RecordTerm__Group__0__Impl rule__RecordTerm__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__RecordTerm__Group__0__Impl(); @@ -41321,17 +41779,17 @@ public final void rule__RecordTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__RecordTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12457:1: rule__RecordTerm__Group__0__Impl : ( LeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:12579:1: rule__RecordTerm__Group__0__Impl : ( LeftSquareBracket ) ; public final void rule__RecordTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12461:1: ( ( LeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:12462:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:12583:1: ( ( LeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:12584:1: ( LeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:12462:1: ( LeftSquareBracket ) - // InternalBehaviorAnnexParser.g:12463:2: LeftSquareBracket + // InternalBehaviorAnnexParser.g:12584:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:12585:2: LeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getLeftSquareBracketKeyword_0()); @@ -41362,14 +41820,14 @@ public final void rule__RecordTerm__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__RecordTerm__Group__1" - // InternalBehaviorAnnexParser.g:12472:1: rule__RecordTerm__Group__1 : rule__RecordTerm__Group__1__Impl rule__RecordTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:12594: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:12476:1: ( rule__RecordTerm__Group__1__Impl rule__RecordTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:12477:2: rule__RecordTerm__Group__1__Impl rule__RecordTerm__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_14); rule__RecordTerm__Group__1__Impl(); @@ -41400,26 +41858,26 @@ public final void rule__RecordTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__RecordTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12484:1: rule__RecordTerm__Group__1__Impl : ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) ; + // InternalBehaviorAnnexParser.g:12606: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:12488:1: ( ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) ) - // InternalBehaviorAnnexParser.g:12489:1: ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) + // 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:12489:1: ( ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) ) - // InternalBehaviorAnnexParser.g:12490:2: ( ( 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:12490:2: ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:12491:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:12612:2: ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:12613:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getOwnedFieldValueAssignment_1()); } - // InternalBehaviorAnnexParser.g:12492:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) - // InternalBehaviorAnnexParser.g:12492:4: rule__RecordTerm__OwnedFieldValueAssignment_1 + // InternalBehaviorAnnexParser.g:12614:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 ) + // InternalBehaviorAnnexParser.g:12614:4: rule__RecordTerm__OwnedFieldValueAssignment_1 { pushFollow(FollowSets000.FOLLOW_5); rule__RecordTerm__OwnedFieldValueAssignment_1(); @@ -41435,26 +41893,26 @@ public final void rule__RecordTerm__Group__1__Impl() throws RecognitionException } - // InternalBehaviorAnnexParser.g:12495:2: ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) - // InternalBehaviorAnnexParser.g:12496:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* + // InternalBehaviorAnnexParser.g:12617:2: ( ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* ) + // InternalBehaviorAnnexParser.g:12618:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getOwnedFieldValueAssignment_1()); } - // InternalBehaviorAnnexParser.g:12497:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* - loop106: + // InternalBehaviorAnnexParser.g:12619:3: ( rule__RecordTerm__OwnedFieldValueAssignment_1 )* + loop108: do { - int alt106=2; - int LA106_0 = input.LA(1); + int alt108=2; + int LA108_0 = input.LA(1); - if ( (LA106_0==RULE_ID) ) { - alt106=1; + if ( (LA108_0==RULE_ID) ) { + alt108=1; } - switch (alt106) { + switch (alt108) { case 1 : - // InternalBehaviorAnnexParser.g:12497:4: rule__RecordTerm__OwnedFieldValueAssignment_1 + // InternalBehaviorAnnexParser.g:12619:4: rule__RecordTerm__OwnedFieldValueAssignment_1 { pushFollow(FollowSets000.FOLLOW_5); rule__RecordTerm__OwnedFieldValueAssignment_1(); @@ -41466,7 +41924,7 @@ public final void rule__RecordTerm__Group__1__Impl() throws RecognitionException break; default : - break loop106; + break loop108; } } while (true); @@ -41498,14 +41956,14 @@ public final void rule__RecordTerm__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__RecordTerm__Group__2" - // InternalBehaviorAnnexParser.g:12506:1: rule__RecordTerm__Group__2 : rule__RecordTerm__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:12628: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:12510:1: ( rule__RecordTerm__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:12511:2: rule__RecordTerm__Group__2__Impl + // InternalBehaviorAnnexParser.g:12632:1: ( rule__RecordTerm__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:12633:2: rule__RecordTerm__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__RecordTerm__Group__2__Impl(); @@ -41531,17 +41989,17 @@ public final void rule__RecordTerm__Group__2() throws RecognitionException { // $ANTLR start "rule__RecordTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:12517:1: rule__RecordTerm__Group__2__Impl : ( RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:12639:1: rule__RecordTerm__Group__2__Impl : ( RightSquareBracket ) ; public final void rule__RecordTerm__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12521:1: ( ( RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:12522:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:12643:1: ( ( RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:12644:1: ( RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:12522:1: ( RightSquareBracket ) - // InternalBehaviorAnnexParser.g:12523:2: RightSquareBracket + // InternalBehaviorAnnexParser.g:12644:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:12645:2: RightSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getRightSquareBracketKeyword_2()); @@ -41572,14 +42030,14 @@ public final void rule__RecordTerm__Group__2__Impl() throws RecognitionException // $ANTLR start "rule__ComputedTerm__Group__0" - // InternalBehaviorAnnexParser.g:12533:1: rule__ComputedTerm__Group__0 : rule__ComputedTerm__Group__0__Impl rule__ComputedTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:12655: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:12537:1: ( rule__ComputedTerm__Group__0__Impl rule__ComputedTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:12538:2: rule__ComputedTerm__Group__0__Impl rule__ComputedTerm__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_27); rule__ComputedTerm__Group__0__Impl(); @@ -41610,17 +42068,17 @@ public final void rule__ComputedTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__ComputedTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12545:1: rule__ComputedTerm__Group__0__Impl : ( Compute ) ; + // InternalBehaviorAnnexParser.g:12667:1: rule__ComputedTerm__Group__0__Impl : ( Compute ) ; public final void rule__ComputedTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12549:1: ( ( Compute ) ) - // InternalBehaviorAnnexParser.g:12550:1: ( Compute ) + // InternalBehaviorAnnexParser.g:12671:1: ( ( Compute ) ) + // InternalBehaviorAnnexParser.g:12672:1: ( Compute ) { - // InternalBehaviorAnnexParser.g:12550:1: ( Compute ) - // InternalBehaviorAnnexParser.g:12551:2: Compute + // InternalBehaviorAnnexParser.g:12672:1: ( Compute ) + // InternalBehaviorAnnexParser.g:12673:2: Compute { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getComputeKeyword_0()); @@ -41651,14 +42109,14 @@ public final void rule__ComputedTerm__Group__0__Impl() throws RecognitionExcepti // $ANTLR start "rule__ComputedTerm__Group__1" - // InternalBehaviorAnnexParser.g:12560:1: rule__ComputedTerm__Group__1 : rule__ComputedTerm__Group__1__Impl rule__ComputedTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:12682: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:12564:1: ( rule__ComputedTerm__Group__1__Impl rule__ComputedTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:12565:2: rule__ComputedTerm__Group__1__Impl rule__ComputedTerm__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__ComputedTerm__Group__1__Impl(); @@ -41689,17 +42147,17 @@ public final void rule__ComputedTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__ComputedTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12572:1: rule__ComputedTerm__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12694:1: rule__ComputedTerm__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__ComputedTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12576:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12577:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12698:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12699:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12577:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12578:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12699:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12700:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getLeftParenthesisKeyword_1()); @@ -41730,14 +42188,14 @@ public final void rule__ComputedTerm__Group__1__Impl() throws RecognitionExcepti // $ANTLR start "rule__ComputedTerm__Group__2" - // InternalBehaviorAnnexParser.g:12587:1: rule__ComputedTerm__Group__2 : rule__ComputedTerm__Group__2__Impl rule__ComputedTerm__Group__3 ; + // InternalBehaviorAnnexParser.g:12709: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:12591:1: ( rule__ComputedTerm__Group__2__Impl rule__ComputedTerm__Group__3 ) - // InternalBehaviorAnnexParser.g:12592:2: rule__ComputedTerm__Group__2__Impl rule__ComputedTerm__Group__3 + // 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 { pushFollow(FollowSets000.FOLLOW_37); rule__ComputedTerm__Group__2__Impl(); @@ -41768,23 +42226,23 @@ public final void rule__ComputedTerm__Group__2() throws RecognitionException { // $ANTLR start "rule__ComputedTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:12599:1: rule__ComputedTerm__Group__2__Impl : ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:12721: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:12603:1: ( ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:12604:1: ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12725:1: ( ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:12726:1: ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:12604:1: ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:12605:2: ( rule__ComputedTerm__FunctionAssignment_2 ) + // InternalBehaviorAnnexParser.g:12726:1: ( ( rule__ComputedTerm__FunctionAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12727:2: ( rule__ComputedTerm__FunctionAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getFunctionAssignment_2()); } - // InternalBehaviorAnnexParser.g:12606:2: ( rule__ComputedTerm__FunctionAssignment_2 ) - // InternalBehaviorAnnexParser.g:12606:3: rule__ComputedTerm__FunctionAssignment_2 + // InternalBehaviorAnnexParser.g:12728:2: ( rule__ComputedTerm__FunctionAssignment_2 ) + // InternalBehaviorAnnexParser.g:12728:3: rule__ComputedTerm__FunctionAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ComputedTerm__FunctionAssignment_2(); @@ -41819,14 +42277,14 @@ public final void rule__ComputedTerm__Group__2__Impl() throws RecognitionExcepti // $ANTLR start "rule__ComputedTerm__Group__3" - // InternalBehaviorAnnexParser.g:12614:1: rule__ComputedTerm__Group__3 : rule__ComputedTerm__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:12736: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:12618:1: ( rule__ComputedTerm__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:12619:2: rule__ComputedTerm__Group__3__Impl + // InternalBehaviorAnnexParser.g:12740:1: ( rule__ComputedTerm__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:12741:2: rule__ComputedTerm__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ComputedTerm__Group__3__Impl(); @@ -41852,17 +42310,17 @@ public final void rule__ComputedTerm__Group__3() throws RecognitionException { // $ANTLR start "rule__ComputedTerm__Group__3__Impl" - // InternalBehaviorAnnexParser.g:12625:1: rule__ComputedTerm__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12747:1: rule__ComputedTerm__Group__3__Impl : ( RightParenthesis ) ; public final void rule__ComputedTerm__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12629:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12630:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12751:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12752:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12630:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12631:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12752:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12753:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getRightParenthesisKeyword_3()); @@ -41893,14 +42351,14 @@ public final void rule__ComputedTerm__Group__3__Impl() throws RecognitionExcepti // $ANTLR start "rule__ComponentClassifierTerm__Group__0" - // InternalBehaviorAnnexParser.g:12641:1: rule__ComponentClassifierTerm__Group__0 : rule__ComponentClassifierTerm__Group__0__Impl rule__ComponentClassifierTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:12763: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:12645:1: ( rule__ComponentClassifierTerm__Group__0__Impl rule__ComponentClassifierTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:12646:2: rule__ComponentClassifierTerm__Group__0__Impl rule__ComponentClassifierTerm__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_27); rule__ComponentClassifierTerm__Group__0__Impl(); @@ -41931,17 +42389,17 @@ public final void rule__ComponentClassifierTerm__Group__0() throws RecognitionEx // $ANTLR start "rule__ComponentClassifierTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12653:1: rule__ComponentClassifierTerm__Group__0__Impl : ( Classifier ) ; + // InternalBehaviorAnnexParser.g:12775:1: rule__ComponentClassifierTerm__Group__0__Impl : ( Classifier ) ; public final void rule__ComponentClassifierTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12657:1: ( ( Classifier ) ) - // InternalBehaviorAnnexParser.g:12658:1: ( Classifier ) + // InternalBehaviorAnnexParser.g:12779:1: ( ( Classifier ) ) + // InternalBehaviorAnnexParser.g:12780:1: ( Classifier ) { - // InternalBehaviorAnnexParser.g:12658:1: ( Classifier ) - // InternalBehaviorAnnexParser.g:12659:2: Classifier + // InternalBehaviorAnnexParser.g:12780:1: ( Classifier ) + // InternalBehaviorAnnexParser.g:12781:2: Classifier { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getClassifierKeyword_0()); @@ -41972,14 +42430,14 @@ public final void rule__ComponentClassifierTerm__Group__0__Impl() throws Recogni // $ANTLR start "rule__ComponentClassifierTerm__Group__1" - // InternalBehaviorAnnexParser.g:12668:1: rule__ComponentClassifierTerm__Group__1 : rule__ComponentClassifierTerm__Group__1__Impl rule__ComponentClassifierTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:12790: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:12672:1: ( rule__ComponentClassifierTerm__Group__1__Impl rule__ComponentClassifierTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:12673:2: rule__ComponentClassifierTerm__Group__1__Impl rule__ComponentClassifierTerm__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__ComponentClassifierTerm__Group__1__Impl(); @@ -42010,17 +42468,17 @@ public final void rule__ComponentClassifierTerm__Group__1() throws RecognitionEx // $ANTLR start "rule__ComponentClassifierTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12680:1: rule__ComponentClassifierTerm__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12802:1: rule__ComponentClassifierTerm__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__ComponentClassifierTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12684:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12685:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12806:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12807:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12685:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12686:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12807:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12808:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getLeftParenthesisKeyword_1()); @@ -42051,14 +42509,14 @@ public final void rule__ComponentClassifierTerm__Group__1__Impl() throws Recogni // $ANTLR start "rule__ComponentClassifierTerm__Group__2" - // InternalBehaviorAnnexParser.g:12695:1: rule__ComponentClassifierTerm__Group__2 : rule__ComponentClassifierTerm__Group__2__Impl rule__ComponentClassifierTerm__Group__3 ; + // InternalBehaviorAnnexParser.g:12817: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:12699:1: ( rule__ComponentClassifierTerm__Group__2__Impl rule__ComponentClassifierTerm__Group__3 ) - // InternalBehaviorAnnexParser.g:12700:2: rule__ComponentClassifierTerm__Group__2__Impl rule__ComponentClassifierTerm__Group__3 + // 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 { pushFollow(FollowSets000.FOLLOW_37); rule__ComponentClassifierTerm__Group__2__Impl(); @@ -42089,23 +42547,23 @@ public final void rule__ComponentClassifierTerm__Group__2() throws RecognitionEx // $ANTLR start "rule__ComponentClassifierTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:12707:1: rule__ComponentClassifierTerm__Group__2__Impl : ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:12829: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:12711:1: ( ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:12712:1: ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12833:1: ( ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:12834:1: ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:12712:1: ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:12713:2: ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) + // InternalBehaviorAnnexParser.g:12834:1: ( ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:12835:2: ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getClassifierAssignment_2()); } - // InternalBehaviorAnnexParser.g:12714:2: ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) - // InternalBehaviorAnnexParser.g:12714:3: rule__ComponentClassifierTerm__ClassifierAssignment_2 + // InternalBehaviorAnnexParser.g:12836:2: ( rule__ComponentClassifierTerm__ClassifierAssignment_2 ) + // InternalBehaviorAnnexParser.g:12836:3: rule__ComponentClassifierTerm__ClassifierAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ComponentClassifierTerm__ClassifierAssignment_2(); @@ -42140,14 +42598,14 @@ public final void rule__ComponentClassifierTerm__Group__2__Impl() throws Recogni // $ANTLR start "rule__ComponentClassifierTerm__Group__3" - // InternalBehaviorAnnexParser.g:12722:1: rule__ComponentClassifierTerm__Group__3 : rule__ComponentClassifierTerm__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:12844: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:12726:1: ( rule__ComponentClassifierTerm__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:12727:2: rule__ComponentClassifierTerm__Group__3__Impl + // InternalBehaviorAnnexParser.g:12848:1: ( rule__ComponentClassifierTerm__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:12849:2: rule__ComponentClassifierTerm__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ComponentClassifierTerm__Group__3__Impl(); @@ -42173,17 +42631,17 @@ public final void rule__ComponentClassifierTerm__Group__3() throws RecognitionEx // $ANTLR start "rule__ComponentClassifierTerm__Group__3__Impl" - // InternalBehaviorAnnexParser.g:12733:1: rule__ComponentClassifierTerm__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12855:1: rule__ComponentClassifierTerm__Group__3__Impl : ( RightParenthesis ) ; public final void rule__ComponentClassifierTerm__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12737:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12738:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12859:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12860:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12738:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12739:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12860:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12861:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getRightParenthesisKeyword_3()); @@ -42214,14 +42672,14 @@ public final void rule__ComponentClassifierTerm__Group__3__Impl() throws Recogni // $ANTLR start "rule__ListTerm__Group__0" - // InternalBehaviorAnnexParser.g:12749:1: rule__ListTerm__Group__0 : rule__ListTerm__Group__0__Impl rule__ListTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:12871: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:12753:1: ( rule__ListTerm__Group__0__Impl rule__ListTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:12754:2: rule__ListTerm__Group__0__Impl rule__ListTerm__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_27); rule__ListTerm__Group__0__Impl(); @@ -42252,23 +42710,23 @@ public final void rule__ListTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12761:1: rule__ListTerm__Group__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:12883:1: rule__ListTerm__Group__0__Impl : ( () ) ; public final void rule__ListTerm__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12765:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:12766:1: ( () ) + // InternalBehaviorAnnexParser.g:12887:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:12888:1: ( () ) { - // InternalBehaviorAnnexParser.g:12766:1: ( () ) - // InternalBehaviorAnnexParser.g:12767:2: () + // InternalBehaviorAnnexParser.g:12888:1: ( () ) + // InternalBehaviorAnnexParser.g:12889:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getListValueAction_0()); } - // InternalBehaviorAnnexParser.g:12768:2: () - // InternalBehaviorAnnexParser.g:12768:3: + // InternalBehaviorAnnexParser.g:12890:2: () + // InternalBehaviorAnnexParser.g:12890:3: { } @@ -42293,16 +42751,16 @@ public final void rule__ListTerm__Group__0__Impl() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__1" - // InternalBehaviorAnnexParser.g:12776:1: rule__ListTerm__Group__1 : rule__ListTerm__Group__1__Impl rule__ListTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:12898: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:12780:1: ( rule__ListTerm__Group__1__Impl rule__ListTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:12781:2: rule__ListTerm__Group__1__Impl rule__ListTerm__Group__2 + // 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 { - pushFollow(FollowSets000.FOLLOW_85); + pushFollow(FollowSets000.FOLLOW_86); rule__ListTerm__Group__1__Impl(); state._fsp--; @@ -42331,17 +42789,17 @@ public final void rule__ListTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:12788:1: rule__ListTerm__Group__1__Impl : ( LeftParenthesis ) ; + // InternalBehaviorAnnexParser.g:12910:1: rule__ListTerm__Group__1__Impl : ( LeftParenthesis ) ; public final void rule__ListTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12792:1: ( ( LeftParenthesis ) ) - // InternalBehaviorAnnexParser.g:12793:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12914:1: ( ( LeftParenthesis ) ) + // InternalBehaviorAnnexParser.g:12915:1: ( LeftParenthesis ) { - // InternalBehaviorAnnexParser.g:12793:1: ( LeftParenthesis ) - // InternalBehaviorAnnexParser.g:12794:2: LeftParenthesis + // InternalBehaviorAnnexParser.g:12915:1: ( LeftParenthesis ) + // InternalBehaviorAnnexParser.g:12916:2: LeftParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getLeftParenthesisKeyword_1()); @@ -42372,16 +42830,16 @@ public final void rule__ListTerm__Group__1__Impl() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__2" - // InternalBehaviorAnnexParser.g:12803:1: rule__ListTerm__Group__2 : rule__ListTerm__Group__2__Impl rule__ListTerm__Group__3 ; + // InternalBehaviorAnnexParser.g:12925: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:12807:1: ( rule__ListTerm__Group__2__Impl rule__ListTerm__Group__3 ) - // InternalBehaviorAnnexParser.g:12808:2: rule__ListTerm__Group__2__Impl rule__ListTerm__Group__3 + // 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 { - pushFollow(FollowSets000.FOLLOW_85); + pushFollow(FollowSets000.FOLLOW_86); rule__ListTerm__Group__2__Impl(); state._fsp--; @@ -42410,31 +42868,31 @@ public final void rule__ListTerm__Group__2() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:12815:1: rule__ListTerm__Group__2__Impl : ( ( rule__ListTerm__Group_2__0 )? ) ; + // InternalBehaviorAnnexParser.g:12937: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:12819:1: ( ( ( rule__ListTerm__Group_2__0 )? ) ) - // InternalBehaviorAnnexParser.g:12820:1: ( ( rule__ListTerm__Group_2__0 )? ) + // InternalBehaviorAnnexParser.g:12941:1: ( ( ( rule__ListTerm__Group_2__0 )? ) ) + // InternalBehaviorAnnexParser.g:12942:1: ( ( rule__ListTerm__Group_2__0 )? ) { - // InternalBehaviorAnnexParser.g:12820:1: ( ( rule__ListTerm__Group_2__0 )? ) - // InternalBehaviorAnnexParser.g:12821:2: ( rule__ListTerm__Group_2__0 )? + // InternalBehaviorAnnexParser.g:12942:1: ( ( rule__ListTerm__Group_2__0 )? ) + // InternalBehaviorAnnexParser.g:12943:2: ( rule__ListTerm__Group_2__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getGroup_2()); } - // InternalBehaviorAnnexParser.g:12822:2: ( rule__ListTerm__Group_2__0 )? - int alt107=2; - int LA107_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:12944:2: ( rule__ListTerm__Group_2__0 )? + int alt109=2; + int LA109_0 = input.LA(1); - if ( (LA107_0==Classifier||LA107_0==Reference||LA107_0==Compute||LA107_0==False||LA107_0==True||LA107_0==LeftParenthesis||LA107_0==PlusSign||LA107_0==HyphenMinus||LA107_0==LeftSquareBracket||LA107_0==RULE_REAL_LIT||LA107_0==RULE_INTEGER_LIT||(LA107_0>=RULE_STRING && LA107_0<=RULE_ID)) ) { - alt107=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; } - switch (alt107) { + switch (alt109) { case 1 : - // InternalBehaviorAnnexParser.g:12822:3: rule__ListTerm__Group_2__0 + // InternalBehaviorAnnexParser.g:12944:3: rule__ListTerm__Group_2__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__Group_2__0(); @@ -42472,14 +42930,14 @@ public final void rule__ListTerm__Group__2__Impl() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__3" - // InternalBehaviorAnnexParser.g:12830:1: rule__ListTerm__Group__3 : rule__ListTerm__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:12952: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:12834:1: ( rule__ListTerm__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:12835:2: rule__ListTerm__Group__3__Impl + // InternalBehaviorAnnexParser.g:12956:1: ( rule__ListTerm__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:12957:2: rule__ListTerm__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__Group__3__Impl(); @@ -42505,17 +42963,17 @@ public final void rule__ListTerm__Group__3() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group__3__Impl" - // InternalBehaviorAnnexParser.g:12841:1: rule__ListTerm__Group__3__Impl : ( RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:12963:1: rule__ListTerm__Group__3__Impl : ( RightParenthesis ) ; public final void rule__ListTerm__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:12845:1: ( ( RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:12846:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12967:1: ( ( RightParenthesis ) ) + // InternalBehaviorAnnexParser.g:12968:1: ( RightParenthesis ) { - // InternalBehaviorAnnexParser.g:12846:1: ( RightParenthesis ) - // InternalBehaviorAnnexParser.g:12847:2: RightParenthesis + // InternalBehaviorAnnexParser.g:12968:1: ( RightParenthesis ) + // InternalBehaviorAnnexParser.g:12969:2: RightParenthesis { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getRightParenthesisKeyword_3()); @@ -42546,16 +43004,16 @@ public final void rule__ListTerm__Group__3__Impl() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group_2__0" - // InternalBehaviorAnnexParser.g:12857:1: rule__ListTerm__Group_2__0 : rule__ListTerm__Group_2__0__Impl rule__ListTerm__Group_2__1 ; + // InternalBehaviorAnnexParser.g:12979: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:12861:1: ( rule__ListTerm__Group_2__0__Impl rule__ListTerm__Group_2__1 ) - // InternalBehaviorAnnexParser.g:12862:2: rule__ListTerm__Group_2__0__Impl rule__ListTerm__Group_2__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_82); + pushFollow(FollowSets000.FOLLOW_83); rule__ListTerm__Group_2__0__Impl(); state._fsp--; @@ -42584,23 +43042,23 @@ public final void rule__ListTerm__Group_2__0() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group_2__0__Impl" - // InternalBehaviorAnnexParser.g:12869:1: rule__ListTerm__Group_2__0__Impl : ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) ; + // InternalBehaviorAnnexParser.g:12991: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:12873:1: ( ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) ) - // InternalBehaviorAnnexParser.g:12874:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) + // InternalBehaviorAnnexParser.g:12995:1: ( ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) ) + // InternalBehaviorAnnexParser.g:12996:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) { - // InternalBehaviorAnnexParser.g:12874:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) - // InternalBehaviorAnnexParser.g:12875:2: ( rule__ListTerm__OwnedListElementAssignment_2_0 ) + // InternalBehaviorAnnexParser.g:12996:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_0 ) ) + // InternalBehaviorAnnexParser.g:12997:2: ( rule__ListTerm__OwnedListElementAssignment_2_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getOwnedListElementAssignment_2_0()); } - // InternalBehaviorAnnexParser.g:12876:2: ( rule__ListTerm__OwnedListElementAssignment_2_0 ) - // InternalBehaviorAnnexParser.g:12876:3: rule__ListTerm__OwnedListElementAssignment_2_0 + // InternalBehaviorAnnexParser.g:12998:2: ( rule__ListTerm__OwnedListElementAssignment_2_0 ) + // InternalBehaviorAnnexParser.g:12998:3: rule__ListTerm__OwnedListElementAssignment_2_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__OwnedListElementAssignment_2_0(); @@ -42635,14 +43093,14 @@ public final void rule__ListTerm__Group_2__0__Impl() throws RecognitionException // $ANTLR start "rule__ListTerm__Group_2__1" - // InternalBehaviorAnnexParser.g:12884:1: rule__ListTerm__Group_2__1 : rule__ListTerm__Group_2__1__Impl ; + // InternalBehaviorAnnexParser.g:13006: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:12888:1: ( rule__ListTerm__Group_2__1__Impl ) - // InternalBehaviorAnnexParser.g:12889:2: rule__ListTerm__Group_2__1__Impl + // InternalBehaviorAnnexParser.g:13010:1: ( rule__ListTerm__Group_2__1__Impl ) + // InternalBehaviorAnnexParser.g:13011:2: rule__ListTerm__Group_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__Group_2__1__Impl(); @@ -42668,35 +43126,35 @@ public final void rule__ListTerm__Group_2__1() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group_2__1__Impl" - // InternalBehaviorAnnexParser.g:12895:1: rule__ListTerm__Group_2__1__Impl : ( ( rule__ListTerm__Group_2_1__0 )* ) ; + // InternalBehaviorAnnexParser.g:13017: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:12899:1: ( ( ( rule__ListTerm__Group_2_1__0 )* ) ) - // InternalBehaviorAnnexParser.g:12900:1: ( ( rule__ListTerm__Group_2_1__0 )* ) + // InternalBehaviorAnnexParser.g:13021:1: ( ( ( rule__ListTerm__Group_2_1__0 )* ) ) + // InternalBehaviorAnnexParser.g:13022:1: ( ( rule__ListTerm__Group_2_1__0 )* ) { - // InternalBehaviorAnnexParser.g:12900:1: ( ( rule__ListTerm__Group_2_1__0 )* ) - // InternalBehaviorAnnexParser.g:12901:2: ( 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 )* { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getGroup_2_1()); } - // InternalBehaviorAnnexParser.g:12902:2: ( rule__ListTerm__Group_2_1__0 )* - loop108: + // InternalBehaviorAnnexParser.g:13024:2: ( rule__ListTerm__Group_2_1__0 )* + loop110: do { - int alt108=2; - int LA108_0 = input.LA(1); + int alt110=2; + int LA110_0 = input.LA(1); - if ( (LA108_0==Comma) ) { - alt108=1; + if ( (LA110_0==Comma) ) { + alt110=1; } - switch (alt108) { + switch (alt110) { case 1 : - // InternalBehaviorAnnexParser.g:12902:3: rule__ListTerm__Group_2_1__0 + // InternalBehaviorAnnexParser.g:13024:3: rule__ListTerm__Group_2_1__0 { pushFollow(FollowSets000.FOLLOW_7); rule__ListTerm__Group_2_1__0(); @@ -42708,7 +43166,7 @@ public final void rule__ListTerm__Group_2__1__Impl() throws RecognitionException break; default : - break loop108; + break loop110; } } while (true); @@ -42737,14 +43195,14 @@ public final void rule__ListTerm__Group_2__1__Impl() throws RecognitionException // $ANTLR start "rule__ListTerm__Group_2_1__0" - // InternalBehaviorAnnexParser.g:12911:1: rule__ListTerm__Group_2_1__0 : rule__ListTerm__Group_2_1__0__Impl rule__ListTerm__Group_2_1__1 ; + // InternalBehaviorAnnexParser.g:13033: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:12915:1: ( rule__ListTerm__Group_2_1__0__Impl rule__ListTerm__Group_2_1__1 ) - // InternalBehaviorAnnexParser.g:12916:2: rule__ListTerm__Group_2_1__0__Impl rule__ListTerm__Group_2_1__1 + // 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 { pushFollow(FollowSets000.FOLLOW_16); rule__ListTerm__Group_2_1__0__Impl(); @@ -42775,17 +43233,17 @@ public final void rule__ListTerm__Group_2_1__0() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group_2_1__0__Impl" - // InternalBehaviorAnnexParser.g:12923:1: rule__ListTerm__Group_2_1__0__Impl : ( Comma ) ; + // InternalBehaviorAnnexParser.g:13045: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:12927:1: ( ( Comma ) ) - // InternalBehaviorAnnexParser.g:12928:1: ( Comma ) + // InternalBehaviorAnnexParser.g:13049:1: ( ( Comma ) ) + // InternalBehaviorAnnexParser.g:13050:1: ( Comma ) { - // InternalBehaviorAnnexParser.g:12928:1: ( Comma ) - // InternalBehaviorAnnexParser.g:12929:2: Comma + // InternalBehaviorAnnexParser.g:13050:1: ( Comma ) + // InternalBehaviorAnnexParser.g:13051:2: Comma { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getCommaKeyword_2_1_0()); @@ -42816,14 +43274,14 @@ public final void rule__ListTerm__Group_2_1__0__Impl() throws RecognitionExcepti // $ANTLR start "rule__ListTerm__Group_2_1__1" - // InternalBehaviorAnnexParser.g:12938:1: rule__ListTerm__Group_2_1__1 : rule__ListTerm__Group_2_1__1__Impl ; + // InternalBehaviorAnnexParser.g:13060: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:12942:1: ( rule__ListTerm__Group_2_1__1__Impl ) - // InternalBehaviorAnnexParser.g:12943:2: rule__ListTerm__Group_2_1__1__Impl + // InternalBehaviorAnnexParser.g:13064:1: ( rule__ListTerm__Group_2_1__1__Impl ) + // InternalBehaviorAnnexParser.g:13065:2: rule__ListTerm__Group_2_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__Group_2_1__1__Impl(); @@ -42849,23 +43307,23 @@ public final void rule__ListTerm__Group_2_1__1() throws RecognitionException { // $ANTLR start "rule__ListTerm__Group_2_1__1__Impl" - // InternalBehaviorAnnexParser.g:12949:1: rule__ListTerm__Group_2_1__1__Impl : ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:13071: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:12953:1: ( ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:12954:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) + // InternalBehaviorAnnexParser.g:13075:1: ( ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:13076:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) { - // InternalBehaviorAnnexParser.g:12954:1: ( ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) ) - // InternalBehaviorAnnexParser.g:12955:2: ( 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 ) { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getOwnedListElementAssignment_2_1_1()); } - // InternalBehaviorAnnexParser.g:12956:2: ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) - // InternalBehaviorAnnexParser.g:12956:3: rule__ListTerm__OwnedListElementAssignment_2_1_1 + // InternalBehaviorAnnexParser.g:13078:2: ( rule__ListTerm__OwnedListElementAssignment_2_1_1 ) + // InternalBehaviorAnnexParser.g:13078:3: rule__ListTerm__OwnedListElementAssignment_2_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ListTerm__OwnedListElementAssignment_2_1_1(); @@ -42900,14 +43358,14 @@ public final void rule__ListTerm__Group_2_1__1__Impl() throws RecognitionExcepti // $ANTLR start "rule__FieldPropertyAssociation__Group__0" - // InternalBehaviorAnnexParser.g:12965:1: rule__FieldPropertyAssociation__Group__0 : rule__FieldPropertyAssociation__Group__0__Impl rule__FieldPropertyAssociation__Group__1 ; + // InternalBehaviorAnnexParser.g:13087: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:12969:1: ( rule__FieldPropertyAssociation__Group__0__Impl rule__FieldPropertyAssociation__Group__1 ) - // InternalBehaviorAnnexParser.g:12970:2: rule__FieldPropertyAssociation__Group__0__Impl rule__FieldPropertyAssociation__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_15); rule__FieldPropertyAssociation__Group__0__Impl(); @@ -42938,23 +43396,23 @@ public final void rule__FieldPropertyAssociation__Group__0() throws RecognitionE // $ANTLR start "rule__FieldPropertyAssociation__Group__0__Impl" - // InternalBehaviorAnnexParser.g:12977:1: rule__FieldPropertyAssociation__Group__0__Impl : ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:13099: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:12981:1: ( ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:12982:1: ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13103:1: ( ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:13104:1: ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:12982:1: ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:12983:2: ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) + // InternalBehaviorAnnexParser.g:13104:1: ( ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13105:2: ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getPropertyAssignment_0()); } - // InternalBehaviorAnnexParser.g:12984:2: ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) - // InternalBehaviorAnnexParser.g:12984:3: rule__FieldPropertyAssociation__PropertyAssignment_0 + // InternalBehaviorAnnexParser.g:13106:2: ( rule__FieldPropertyAssociation__PropertyAssignment_0 ) + // InternalBehaviorAnnexParser.g:13106:3: rule__FieldPropertyAssociation__PropertyAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__FieldPropertyAssociation__PropertyAssignment_0(); @@ -42989,14 +43447,14 @@ public final void rule__FieldPropertyAssociation__Group__0__Impl() throws Recogn // $ANTLR start "rule__FieldPropertyAssociation__Group__1" - // InternalBehaviorAnnexParser.g:12992:1: rule__FieldPropertyAssociation__Group__1 : rule__FieldPropertyAssociation__Group__1__Impl rule__FieldPropertyAssociation__Group__2 ; + // InternalBehaviorAnnexParser.g:13114: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:12996:1: ( rule__FieldPropertyAssociation__Group__1__Impl rule__FieldPropertyAssociation__Group__2 ) - // InternalBehaviorAnnexParser.g:12997:2: rule__FieldPropertyAssociation__Group__1__Impl rule__FieldPropertyAssociation__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_16); rule__FieldPropertyAssociation__Group__1__Impl(); @@ -43027,17 +43485,17 @@ public final void rule__FieldPropertyAssociation__Group__1() throws RecognitionE // $ANTLR start "rule__FieldPropertyAssociation__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13004:1: rule__FieldPropertyAssociation__Group__1__Impl : ( EqualsSignGreaterThanSign ) ; + // InternalBehaviorAnnexParser.g:13126:1: rule__FieldPropertyAssociation__Group__1__Impl : ( EqualsSignGreaterThanSign ) ; public final void rule__FieldPropertyAssociation__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13008:1: ( ( EqualsSignGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:13009:1: ( EqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:13130:1: ( ( EqualsSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:13131:1: ( EqualsSignGreaterThanSign ) { - // InternalBehaviorAnnexParser.g:13009:1: ( EqualsSignGreaterThanSign ) - // InternalBehaviorAnnexParser.g:13010:2: EqualsSignGreaterThanSign + // InternalBehaviorAnnexParser.g:13131:1: ( EqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:13132:2: EqualsSignGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getEqualsSignGreaterThanSignKeyword_1()); @@ -43068,14 +43526,14 @@ public final void rule__FieldPropertyAssociation__Group__1__Impl() throws Recogn // $ANTLR start "rule__FieldPropertyAssociation__Group__2" - // InternalBehaviorAnnexParser.g:13019:1: rule__FieldPropertyAssociation__Group__2 : rule__FieldPropertyAssociation__Group__2__Impl rule__FieldPropertyAssociation__Group__3 ; + // InternalBehaviorAnnexParser.g:13141: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:13023:1: ( rule__FieldPropertyAssociation__Group__2__Impl rule__FieldPropertyAssociation__Group__3 ) - // InternalBehaviorAnnexParser.g:13024:2: rule__FieldPropertyAssociation__Group__2__Impl rule__FieldPropertyAssociation__Group__3 + // 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 { pushFollow(FollowSets000.FOLLOW_17); rule__FieldPropertyAssociation__Group__2__Impl(); @@ -43106,23 +43564,23 @@ public final void rule__FieldPropertyAssociation__Group__2() throws RecognitionE // $ANTLR start "rule__FieldPropertyAssociation__Group__2__Impl" - // InternalBehaviorAnnexParser.g:13031:1: rule__FieldPropertyAssociation__Group__2__Impl : ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:13153: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:13035:1: ( ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:13036:1: ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13157:1: ( ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:13158:1: ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:13036:1: ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:13037:2: ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) + // InternalBehaviorAnnexParser.g:13158:1: ( ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13159:2: ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getOwnedValueAssignment_2()); } - // InternalBehaviorAnnexParser.g:13038:2: ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) - // InternalBehaviorAnnexParser.g:13038:3: rule__FieldPropertyAssociation__OwnedValueAssignment_2 + // InternalBehaviorAnnexParser.g:13160:2: ( rule__FieldPropertyAssociation__OwnedValueAssignment_2 ) + // InternalBehaviorAnnexParser.g:13160:3: rule__FieldPropertyAssociation__OwnedValueAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__FieldPropertyAssociation__OwnedValueAssignment_2(); @@ -43157,14 +43615,14 @@ public final void rule__FieldPropertyAssociation__Group__2__Impl() throws Recogn // $ANTLR start "rule__FieldPropertyAssociation__Group__3" - // InternalBehaviorAnnexParser.g:13046:1: rule__FieldPropertyAssociation__Group__3 : rule__FieldPropertyAssociation__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:13168: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:13050:1: ( rule__FieldPropertyAssociation__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:13051:2: rule__FieldPropertyAssociation__Group__3__Impl + // InternalBehaviorAnnexParser.g:13172:1: ( rule__FieldPropertyAssociation__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:13173:2: rule__FieldPropertyAssociation__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__FieldPropertyAssociation__Group__3__Impl(); @@ -43190,17 +43648,17 @@ public final void rule__FieldPropertyAssociation__Group__3() throws RecognitionE // $ANTLR start "rule__FieldPropertyAssociation__Group__3__Impl" - // InternalBehaviorAnnexParser.g:13057:1: rule__FieldPropertyAssociation__Group__3__Impl : ( Semicolon ) ; + // InternalBehaviorAnnexParser.g:13179:1: rule__FieldPropertyAssociation__Group__3__Impl : ( Semicolon ) ; public final void rule__FieldPropertyAssociation__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13061:1: ( ( Semicolon ) ) - // InternalBehaviorAnnexParser.g:13062:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:13183:1: ( ( Semicolon ) ) + // InternalBehaviorAnnexParser.g:13184:1: ( Semicolon ) { - // InternalBehaviorAnnexParser.g:13062:1: ( Semicolon ) - // InternalBehaviorAnnexParser.g:13063:2: Semicolon + // InternalBehaviorAnnexParser.g:13184:1: ( Semicolon ) + // InternalBehaviorAnnexParser.g:13185:2: Semicolon { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getSemicolonKeyword_3()); @@ -43231,16 +43689,16 @@ public final void rule__FieldPropertyAssociation__Group__3__Impl() throws Recogn // $ANTLR start "rule__ContainmentPathElement__Group__0" - // InternalBehaviorAnnexParser.g:13073:1: rule__ContainmentPathElement__Group__0 : rule__ContainmentPathElement__Group__0__Impl rule__ContainmentPathElement__Group__1 ; + // InternalBehaviorAnnexParser.g:13195: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:13077:1: ( rule__ContainmentPathElement__Group__0__Impl rule__ContainmentPathElement__Group__1 ) - // InternalBehaviorAnnexParser.g:13078:2: rule__ContainmentPathElement__Group__0__Impl rule__ContainmentPathElement__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_86); + pushFollow(FollowSets000.FOLLOW_87); rule__ContainmentPathElement__Group__0__Impl(); state._fsp--; @@ -43269,23 +43727,23 @@ public final void rule__ContainmentPathElement__Group__0() throws RecognitionExc // $ANTLR start "rule__ContainmentPathElement__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13085:1: rule__ContainmentPathElement__Group__0__Impl : ( ( rule__ContainmentPathElement__Group_0__0 ) ) ; + // InternalBehaviorAnnexParser.g:13207: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:13089:1: ( ( ( rule__ContainmentPathElement__Group_0__0 ) ) ) - // InternalBehaviorAnnexParser.g:13090:1: ( ( rule__ContainmentPathElement__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:13211:1: ( ( ( rule__ContainmentPathElement__Group_0__0 ) ) ) + // InternalBehaviorAnnexParser.g:13212:1: ( ( rule__ContainmentPathElement__Group_0__0 ) ) { - // InternalBehaviorAnnexParser.g:13090:1: ( ( rule__ContainmentPathElement__Group_0__0 ) ) - // InternalBehaviorAnnexParser.g:13091:2: ( rule__ContainmentPathElement__Group_0__0 ) + // InternalBehaviorAnnexParser.g:13212:1: ( ( rule__ContainmentPathElement__Group_0__0 ) ) + // InternalBehaviorAnnexParser.g:13213:2: ( rule__ContainmentPathElement__Group_0__0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getGroup_0()); } - // InternalBehaviorAnnexParser.g:13092:2: ( rule__ContainmentPathElement__Group_0__0 ) - // InternalBehaviorAnnexParser.g:13092:3: rule__ContainmentPathElement__Group_0__0 + // InternalBehaviorAnnexParser.g:13214:2: ( rule__ContainmentPathElement__Group_0__0 ) + // InternalBehaviorAnnexParser.g:13214:3: rule__ContainmentPathElement__Group_0__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group_0__0(); @@ -43320,14 +43778,14 @@ public final void rule__ContainmentPathElement__Group__0__Impl() throws Recognit // $ANTLR start "rule__ContainmentPathElement__Group__1" - // InternalBehaviorAnnexParser.g:13100:1: rule__ContainmentPathElement__Group__1 : rule__ContainmentPathElement__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13222: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:13104:1: ( rule__ContainmentPathElement__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13105:2: rule__ContainmentPathElement__Group__1__Impl + // InternalBehaviorAnnexParser.g:13226:1: ( rule__ContainmentPathElement__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13227:2: rule__ContainmentPathElement__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group__1__Impl(); @@ -43353,31 +43811,31 @@ public final void rule__ContainmentPathElement__Group__1() throws RecognitionExc // $ANTLR start "rule__ContainmentPathElement__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13111:1: rule__ContainmentPathElement__Group__1__Impl : ( ( rule__ContainmentPathElement__Group_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:13233: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:13115:1: ( ( ( rule__ContainmentPathElement__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:13116:1: ( ( rule__ContainmentPathElement__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:13237:1: ( ( ( rule__ContainmentPathElement__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:13238:1: ( ( rule__ContainmentPathElement__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:13116:1: ( ( rule__ContainmentPathElement__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:13117:2: ( rule__ContainmentPathElement__Group_1__0 )? + // InternalBehaviorAnnexParser.g:13238:1: ( ( rule__ContainmentPathElement__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:13239:2: ( rule__ContainmentPathElement__Group_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:13118:2: ( rule__ContainmentPathElement__Group_1__0 )? - int alt109=2; - int LA109_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13240:2: ( rule__ContainmentPathElement__Group_1__0 )? + int alt111=2; + int LA111_0 = input.LA(1); - if ( (LA109_0==FullStop) ) { - alt109=1; + if ( (LA111_0==FullStop) ) { + alt111=1; } - switch (alt109) { + switch (alt111) { case 1 : - // InternalBehaviorAnnexParser.g:13118:3: rule__ContainmentPathElement__Group_1__0 + // InternalBehaviorAnnexParser.g:13240:3: rule__ContainmentPathElement__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group_1__0(); @@ -43415,14 +43873,14 @@ public final void rule__ContainmentPathElement__Group__1__Impl() throws Recognit // $ANTLR start "rule__ContainmentPathElement__Group_0__0" - // InternalBehaviorAnnexParser.g:13127:1: rule__ContainmentPathElement__Group_0__0 : rule__ContainmentPathElement__Group_0__0__Impl rule__ContainmentPathElement__Group_0__1 ; + // InternalBehaviorAnnexParser.g:13249: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:13131:1: ( rule__ContainmentPathElement__Group_0__0__Impl rule__ContainmentPathElement__Group_0__1 ) - // InternalBehaviorAnnexParser.g:13132:2: rule__ContainmentPathElement__Group_0__0__Impl rule__ContainmentPathElement__Group_0__1 + // 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 { pushFollow(FollowSets000.FOLLOW_11); rule__ContainmentPathElement__Group_0__0__Impl(); @@ -43453,23 +43911,23 @@ public final void rule__ContainmentPathElement__Group_0__0() throws RecognitionE // $ANTLR start "rule__ContainmentPathElement__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:13139:1: rule__ContainmentPathElement__Group_0__0__Impl : ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) ; + // InternalBehaviorAnnexParser.g:13261: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:13143:1: ( ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) ) - // InternalBehaviorAnnexParser.g:13144:1: ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) + // InternalBehaviorAnnexParser.g:13265:1: ( ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) ) + // InternalBehaviorAnnexParser.g:13266:1: ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) { - // InternalBehaviorAnnexParser.g:13144:1: ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) - // InternalBehaviorAnnexParser.g:13145:2: ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) + // InternalBehaviorAnnexParser.g:13266:1: ( ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) ) + // InternalBehaviorAnnexParser.g:13267:2: ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getNamedElementAssignment_0_0()); } - // InternalBehaviorAnnexParser.g:13146:2: ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) - // InternalBehaviorAnnexParser.g:13146:3: rule__ContainmentPathElement__NamedElementAssignment_0_0 + // InternalBehaviorAnnexParser.g:13268:2: ( rule__ContainmentPathElement__NamedElementAssignment_0_0 ) + // InternalBehaviorAnnexParser.g:13268:3: rule__ContainmentPathElement__NamedElementAssignment_0_0 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__NamedElementAssignment_0_0(); @@ -43504,14 +43962,14 @@ public final void rule__ContainmentPathElement__Group_0__0__Impl() throws Recogn // $ANTLR start "rule__ContainmentPathElement__Group_0__1" - // InternalBehaviorAnnexParser.g:13154:1: rule__ContainmentPathElement__Group_0__1 : rule__ContainmentPathElement__Group_0__1__Impl ; + // InternalBehaviorAnnexParser.g:13276: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:13158:1: ( rule__ContainmentPathElement__Group_0__1__Impl ) - // InternalBehaviorAnnexParser.g:13159:2: rule__ContainmentPathElement__Group_0__1__Impl + // InternalBehaviorAnnexParser.g:13280:1: ( rule__ContainmentPathElement__Group_0__1__Impl ) + // InternalBehaviorAnnexParser.g:13281:2: rule__ContainmentPathElement__Group_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group_0__1__Impl(); @@ -43537,35 +43995,35 @@ public final void rule__ContainmentPathElement__Group_0__1() throws RecognitionE // $ANTLR start "rule__ContainmentPathElement__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:13165:1: rule__ContainmentPathElement__Group_0__1__Impl : ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) ; + // InternalBehaviorAnnexParser.g:13287: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:13169:1: ( ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) ) - // InternalBehaviorAnnexParser.g:13170:1: ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) + // InternalBehaviorAnnexParser.g:13291:1: ( ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) ) + // InternalBehaviorAnnexParser.g:13292:1: ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) { - // InternalBehaviorAnnexParser.g:13170:1: ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) - // InternalBehaviorAnnexParser.g:13171:2: ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* + // InternalBehaviorAnnexParser.g:13292:1: ( ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* ) + // InternalBehaviorAnnexParser.g:13293:2: ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getArrayRangeAssignment_0_1()); } - // InternalBehaviorAnnexParser.g:13172:2: ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* - loop110: + // InternalBehaviorAnnexParser.g:13294:2: ( rule__ContainmentPathElement__ArrayRangeAssignment_0_1 )* + loop112: do { - int alt110=2; - int LA110_0 = input.LA(1); + int alt112=2; + int LA112_0 = input.LA(1); - if ( (LA110_0==LeftSquareBracket) ) { - alt110=1; + if ( (LA112_0==LeftSquareBracket) ) { + alt112=1; } - switch (alt110) { + switch (alt112) { case 1 : - // InternalBehaviorAnnexParser.g:13172:3: rule__ContainmentPathElement__ArrayRangeAssignment_0_1 + // InternalBehaviorAnnexParser.g:13294:3: rule__ContainmentPathElement__ArrayRangeAssignment_0_1 { pushFollow(FollowSets000.FOLLOW_12); rule__ContainmentPathElement__ArrayRangeAssignment_0_1(); @@ -43577,7 +44035,7 @@ public final void rule__ContainmentPathElement__Group_0__1__Impl() throws Recogn break; default : - break loop110; + break loop112; } } while (true); @@ -43606,14 +44064,14 @@ public final void rule__ContainmentPathElement__Group_0__1__Impl() throws Recogn // $ANTLR start "rule__ContainmentPathElement__Group_1__0" - // InternalBehaviorAnnexParser.g:13181:1: rule__ContainmentPathElement__Group_1__0 : rule__ContainmentPathElement__Group_1__0__Impl rule__ContainmentPathElement__Group_1__1 ; + // InternalBehaviorAnnexParser.g:13303: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:13185:1: ( rule__ContainmentPathElement__Group_1__0__Impl rule__ContainmentPathElement__Group_1__1 ) - // InternalBehaviorAnnexParser.g:13186:2: rule__ContainmentPathElement__Group_1__0__Impl rule__ContainmentPathElement__Group_1__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__ContainmentPathElement__Group_1__0__Impl(); @@ -43644,17 +44102,17 @@ public final void rule__ContainmentPathElement__Group_1__0() throws RecognitionE // $ANTLR start "rule__ContainmentPathElement__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:13193:1: rule__ContainmentPathElement__Group_1__0__Impl : ( FullStop ) ; + // InternalBehaviorAnnexParser.g:13315: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:13197:1: ( ( FullStop ) ) - // InternalBehaviorAnnexParser.g:13198:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:13319:1: ( ( FullStop ) ) + // InternalBehaviorAnnexParser.g:13320:1: ( FullStop ) { - // InternalBehaviorAnnexParser.g:13198:1: ( FullStop ) - // InternalBehaviorAnnexParser.g:13199:2: FullStop + // InternalBehaviorAnnexParser.g:13320:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:13321:2: FullStop { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getFullStopKeyword_1_0()); @@ -43685,14 +44143,14 @@ public final void rule__ContainmentPathElement__Group_1__0__Impl() throws Recogn // $ANTLR start "rule__ContainmentPathElement__Group_1__1" - // InternalBehaviorAnnexParser.g:13208:1: rule__ContainmentPathElement__Group_1__1 : rule__ContainmentPathElement__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:13330: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:13212:1: ( rule__ContainmentPathElement__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:13213:2: rule__ContainmentPathElement__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:13334:1: ( rule__ContainmentPathElement__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:13335:2: rule__ContainmentPathElement__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__Group_1__1__Impl(); @@ -43718,23 +44176,23 @@ public final void rule__ContainmentPathElement__Group_1__1() throws RecognitionE // $ANTLR start "rule__ContainmentPathElement__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:13219:1: rule__ContainmentPathElement__Group_1__1__Impl : ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) ; + // InternalBehaviorAnnexParser.g:13341: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:13223:1: ( ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) ) - // InternalBehaviorAnnexParser.g:13224:1: ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:13345:1: ( ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) ) + // InternalBehaviorAnnexParser.g:13346:1: ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) { - // InternalBehaviorAnnexParser.g:13224:1: ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) - // InternalBehaviorAnnexParser.g:13225:2: ( rule__ContainmentPathElement__PathAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:13346:1: ( ( rule__ContainmentPathElement__PathAssignment_1_1 ) ) + // InternalBehaviorAnnexParser.g:13347:2: ( rule__ContainmentPathElement__PathAssignment_1_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getPathAssignment_1_1()); } - // InternalBehaviorAnnexParser.g:13226:2: ( rule__ContainmentPathElement__PathAssignment_1_1 ) - // InternalBehaviorAnnexParser.g:13226:3: rule__ContainmentPathElement__PathAssignment_1_1 + // InternalBehaviorAnnexParser.g:13348:2: ( rule__ContainmentPathElement__PathAssignment_1_1 ) + // InternalBehaviorAnnexParser.g:13348:3: rule__ContainmentPathElement__PathAssignment_1_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ContainmentPathElement__PathAssignment_1_1(); @@ -43769,14 +44227,14 @@ public final void rule__ContainmentPathElement__Group_1__1__Impl() throws Recogn // $ANTLR start "rule__ArrayRange__Group__0" - // InternalBehaviorAnnexParser.g:13235:1: rule__ArrayRange__Group__0 : rule__ArrayRange__Group__0__Impl rule__ArrayRange__Group__1 ; + // InternalBehaviorAnnexParser.g:13357: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:13239:1: ( rule__ArrayRange__Group__0__Impl rule__ArrayRange__Group__1 ) - // InternalBehaviorAnnexParser.g:13240:2: rule__ArrayRange__Group__0__Impl rule__ArrayRange__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_11); rule__ArrayRange__Group__0__Impl(); @@ -43807,23 +44265,23 @@ public final void rule__ArrayRange__Group__0() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13247:1: rule__ArrayRange__Group__0__Impl : ( () ) ; + // InternalBehaviorAnnexParser.g:13369:1: rule__ArrayRange__Group__0__Impl : ( () ) ; public final void rule__ArrayRange__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13251:1: ( ( () ) ) - // InternalBehaviorAnnexParser.g:13252:1: ( () ) + // InternalBehaviorAnnexParser.g:13373:1: ( ( () ) ) + // InternalBehaviorAnnexParser.g:13374:1: ( () ) { - // InternalBehaviorAnnexParser.g:13252:1: ( () ) - // InternalBehaviorAnnexParser.g:13253:2: () + // InternalBehaviorAnnexParser.g:13374:1: ( () ) + // InternalBehaviorAnnexParser.g:13375:2: () { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getArrayRangeAction_0()); } - // InternalBehaviorAnnexParser.g:13254:2: () - // InternalBehaviorAnnexParser.g:13254:3: + // InternalBehaviorAnnexParser.g:13376:2: () + // InternalBehaviorAnnexParser.g:13376:3: { } @@ -43848,14 +44306,14 @@ public final void rule__ArrayRange__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__ArrayRange__Group__1" - // InternalBehaviorAnnexParser.g:13262:1: rule__ArrayRange__Group__1 : rule__ArrayRange__Group__1__Impl rule__ArrayRange__Group__2 ; + // InternalBehaviorAnnexParser.g:13384: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:13266:1: ( rule__ArrayRange__Group__1__Impl rule__ArrayRange__Group__2 ) - // InternalBehaviorAnnexParser.g:13267:2: rule__ArrayRange__Group__1__Impl rule__ArrayRange__Group__2 + // 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 { pushFollow(FollowSets000.FOLLOW_23); rule__ArrayRange__Group__1__Impl(); @@ -43886,17 +44344,17 @@ public final void rule__ArrayRange__Group__1() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13274:1: rule__ArrayRange__Group__1__Impl : ( LeftSquareBracket ) ; + // InternalBehaviorAnnexParser.g:13396:1: rule__ArrayRange__Group__1__Impl : ( LeftSquareBracket ) ; public final void rule__ArrayRange__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13278:1: ( ( LeftSquareBracket ) ) - // InternalBehaviorAnnexParser.g:13279:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:13400:1: ( ( LeftSquareBracket ) ) + // InternalBehaviorAnnexParser.g:13401:1: ( LeftSquareBracket ) { - // InternalBehaviorAnnexParser.g:13279:1: ( LeftSquareBracket ) - // InternalBehaviorAnnexParser.g:13280:2: LeftSquareBracket + // InternalBehaviorAnnexParser.g:13401:1: ( LeftSquareBracket ) + // InternalBehaviorAnnexParser.g:13402:2: LeftSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getLeftSquareBracketKeyword_1()); @@ -43927,16 +44385,16 @@ public final void rule__ArrayRange__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__ArrayRange__Group__2" - // InternalBehaviorAnnexParser.g:13289:1: rule__ArrayRange__Group__2 : rule__ArrayRange__Group__2__Impl rule__ArrayRange__Group__3 ; + // InternalBehaviorAnnexParser.g:13411: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:13293:1: ( rule__ArrayRange__Group__2__Impl rule__ArrayRange__Group__3 ) - // InternalBehaviorAnnexParser.g:13294:2: rule__ArrayRange__Group__2__Impl rule__ArrayRange__Group__3 + // 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 { - pushFollow(FollowSets000.FOLLOW_87); + pushFollow(FollowSets000.FOLLOW_88); rule__ArrayRange__Group__2__Impl(); state._fsp--; @@ -43965,23 +44423,23 @@ public final void rule__ArrayRange__Group__2() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group__2__Impl" - // InternalBehaviorAnnexParser.g:13301:1: rule__ArrayRange__Group__2__Impl : ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:13423: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:13305:1: ( ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:13306:1: ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13427:1: ( ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:13428:1: ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:13306:1: ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:13307:2: ( rule__ArrayRange__LowerBoundAssignment_2 ) + // InternalBehaviorAnnexParser.g:13428:1: ( ( rule__ArrayRange__LowerBoundAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13429:2: ( rule__ArrayRange__LowerBoundAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getLowerBoundAssignment_2()); } - // InternalBehaviorAnnexParser.g:13308:2: ( rule__ArrayRange__LowerBoundAssignment_2 ) - // InternalBehaviorAnnexParser.g:13308:3: rule__ArrayRange__LowerBoundAssignment_2 + // InternalBehaviorAnnexParser.g:13430:2: ( rule__ArrayRange__LowerBoundAssignment_2 ) + // InternalBehaviorAnnexParser.g:13430:3: rule__ArrayRange__LowerBoundAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__LowerBoundAssignment_2(); @@ -44016,16 +44474,16 @@ public final void rule__ArrayRange__Group__2__Impl() throws RecognitionException // $ANTLR start "rule__ArrayRange__Group__3" - // InternalBehaviorAnnexParser.g:13316:1: rule__ArrayRange__Group__3 : rule__ArrayRange__Group__3__Impl rule__ArrayRange__Group__4 ; + // InternalBehaviorAnnexParser.g:13438: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:13320:1: ( rule__ArrayRange__Group__3__Impl rule__ArrayRange__Group__4 ) - // InternalBehaviorAnnexParser.g:13321:2: rule__ArrayRange__Group__3__Impl rule__ArrayRange__Group__4 + // 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 { - pushFollow(FollowSets000.FOLLOW_87); + pushFollow(FollowSets000.FOLLOW_88); rule__ArrayRange__Group__3__Impl(); state._fsp--; @@ -44054,31 +44512,31 @@ public final void rule__ArrayRange__Group__3() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group__3__Impl" - // InternalBehaviorAnnexParser.g:13328:1: rule__ArrayRange__Group__3__Impl : ( ( rule__ArrayRange__Group_3__0 )? ) ; + // InternalBehaviorAnnexParser.g:13450: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:13332:1: ( ( ( rule__ArrayRange__Group_3__0 )? ) ) - // InternalBehaviorAnnexParser.g:13333:1: ( ( rule__ArrayRange__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:13454:1: ( ( ( rule__ArrayRange__Group_3__0 )? ) ) + // InternalBehaviorAnnexParser.g:13455:1: ( ( rule__ArrayRange__Group_3__0 )? ) { - // InternalBehaviorAnnexParser.g:13333:1: ( ( rule__ArrayRange__Group_3__0 )? ) - // InternalBehaviorAnnexParser.g:13334:2: ( rule__ArrayRange__Group_3__0 )? + // InternalBehaviorAnnexParser.g:13455:1: ( ( rule__ArrayRange__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:13456:2: ( rule__ArrayRange__Group_3__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getGroup_3()); } - // InternalBehaviorAnnexParser.g:13335:2: ( rule__ArrayRange__Group_3__0 )? - int alt111=2; - int LA111_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13457:2: ( rule__ArrayRange__Group_3__0 )? + int alt113=2; + int LA113_0 = input.LA(1); - if ( (LA111_0==FullStopFullStop) ) { - alt111=1; + if ( (LA113_0==FullStopFullStop) ) { + alt113=1; } - switch (alt111) { + switch (alt113) { case 1 : - // InternalBehaviorAnnexParser.g:13335:3: rule__ArrayRange__Group_3__0 + // InternalBehaviorAnnexParser.g:13457:3: rule__ArrayRange__Group_3__0 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__Group_3__0(); @@ -44116,14 +44574,14 @@ public final void rule__ArrayRange__Group__3__Impl() throws RecognitionException // $ANTLR start "rule__ArrayRange__Group__4" - // InternalBehaviorAnnexParser.g:13343:1: rule__ArrayRange__Group__4 : rule__ArrayRange__Group__4__Impl ; + // InternalBehaviorAnnexParser.g:13465: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:13347:1: ( rule__ArrayRange__Group__4__Impl ) - // InternalBehaviorAnnexParser.g:13348:2: rule__ArrayRange__Group__4__Impl + // InternalBehaviorAnnexParser.g:13469:1: ( rule__ArrayRange__Group__4__Impl ) + // InternalBehaviorAnnexParser.g:13470:2: rule__ArrayRange__Group__4__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__Group__4__Impl(); @@ -44149,17 +44607,17 @@ public final void rule__ArrayRange__Group__4() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group__4__Impl" - // InternalBehaviorAnnexParser.g:13354:1: rule__ArrayRange__Group__4__Impl : ( RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:13476:1: rule__ArrayRange__Group__4__Impl : ( RightSquareBracket ) ; public final void rule__ArrayRange__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13358:1: ( ( RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:13359:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:13480:1: ( ( RightSquareBracket ) ) + // InternalBehaviorAnnexParser.g:13481:1: ( RightSquareBracket ) { - // InternalBehaviorAnnexParser.g:13359:1: ( RightSquareBracket ) - // InternalBehaviorAnnexParser.g:13360:2: RightSquareBracket + // InternalBehaviorAnnexParser.g:13481:1: ( RightSquareBracket ) + // InternalBehaviorAnnexParser.g:13482:2: RightSquareBracket { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getRightSquareBracketKeyword_4()); @@ -44190,14 +44648,14 @@ public final void rule__ArrayRange__Group__4__Impl() throws RecognitionException // $ANTLR start "rule__ArrayRange__Group_3__0" - // InternalBehaviorAnnexParser.g:13370:1: rule__ArrayRange__Group_3__0 : rule__ArrayRange__Group_3__0__Impl rule__ArrayRange__Group_3__1 ; + // InternalBehaviorAnnexParser.g:13492: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:13374:1: ( rule__ArrayRange__Group_3__0__Impl rule__ArrayRange__Group_3__1 ) - // InternalBehaviorAnnexParser.g:13375:2: rule__ArrayRange__Group_3__0__Impl rule__ArrayRange__Group_3__1 + // 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 { pushFollow(FollowSets000.FOLLOW_23); rule__ArrayRange__Group_3__0__Impl(); @@ -44228,17 +44686,17 @@ public final void rule__ArrayRange__Group_3__0() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group_3__0__Impl" - // InternalBehaviorAnnexParser.g:13382:1: rule__ArrayRange__Group_3__0__Impl : ( FullStopFullStop ) ; + // InternalBehaviorAnnexParser.g:13504: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:13386:1: ( ( FullStopFullStop ) ) - // InternalBehaviorAnnexParser.g:13387:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:13508:1: ( ( FullStopFullStop ) ) + // InternalBehaviorAnnexParser.g:13509:1: ( FullStopFullStop ) { - // InternalBehaviorAnnexParser.g:13387:1: ( FullStopFullStop ) - // InternalBehaviorAnnexParser.g:13388:2: FullStopFullStop + // InternalBehaviorAnnexParser.g:13509:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:13510:2: FullStopFullStop { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getFullStopFullStopKeyword_3_0()); @@ -44269,14 +44727,14 @@ public final void rule__ArrayRange__Group_3__0__Impl() throws RecognitionExcepti // $ANTLR start "rule__ArrayRange__Group_3__1" - // InternalBehaviorAnnexParser.g:13397:1: rule__ArrayRange__Group_3__1 : rule__ArrayRange__Group_3__1__Impl ; + // InternalBehaviorAnnexParser.g:13519: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:13401:1: ( rule__ArrayRange__Group_3__1__Impl ) - // InternalBehaviorAnnexParser.g:13402:2: rule__ArrayRange__Group_3__1__Impl + // InternalBehaviorAnnexParser.g:13523:1: ( rule__ArrayRange__Group_3__1__Impl ) + // InternalBehaviorAnnexParser.g:13524:2: rule__ArrayRange__Group_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__Group_3__1__Impl(); @@ -44302,23 +44760,23 @@ public final void rule__ArrayRange__Group_3__1() throws RecognitionException { // $ANTLR start "rule__ArrayRange__Group_3__1__Impl" - // InternalBehaviorAnnexParser.g:13408:1: rule__ArrayRange__Group_3__1__Impl : ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:13530: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:13412:1: ( ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:13413:1: ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:13534:1: ( ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:13535:1: ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) { - // InternalBehaviorAnnexParser.g:13413:1: ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) - // InternalBehaviorAnnexParser.g:13414:2: ( rule__ArrayRange__UpperBoundAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:13535:1: ( ( rule__ArrayRange__UpperBoundAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:13536:2: ( rule__ArrayRange__UpperBoundAssignment_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getUpperBoundAssignment_3_1()); } - // InternalBehaviorAnnexParser.g:13415:2: ( rule__ArrayRange__UpperBoundAssignment_3_1 ) - // InternalBehaviorAnnexParser.g:13415:3: rule__ArrayRange__UpperBoundAssignment_3_1 + // InternalBehaviorAnnexParser.g:13537:2: ( rule__ArrayRange__UpperBoundAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:13537:3: rule__ArrayRange__UpperBoundAssignment_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__ArrayRange__UpperBoundAssignment_3_1(); @@ -44353,16 +44811,16 @@ public final void rule__ArrayRange__Group_3__1__Impl() throws RecognitionExcepti // $ANTLR start "rule__SignedConstant__Group__0" - // InternalBehaviorAnnexParser.g:13424:1: rule__SignedConstant__Group__0 : rule__SignedConstant__Group__0__Impl rule__SignedConstant__Group__1 ; + // InternalBehaviorAnnexParser.g:13546: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:13428:1: ( rule__SignedConstant__Group__0__Impl rule__SignedConstant__Group__1 ) - // InternalBehaviorAnnexParser.g:13429:2: rule__SignedConstant__Group__0__Impl rule__SignedConstant__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_88); + pushFollow(FollowSets000.FOLLOW_89); rule__SignedConstant__Group__0__Impl(); state._fsp--; @@ -44391,23 +44849,23 @@ public final void rule__SignedConstant__Group__0() throws RecognitionException { // $ANTLR start "rule__SignedConstant__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13436:1: rule__SignedConstant__Group__0__Impl : ( ( rule__SignedConstant__OpAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:13558: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:13440:1: ( ( ( rule__SignedConstant__OpAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:13441:1: ( ( rule__SignedConstant__OpAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13562:1: ( ( ( rule__SignedConstant__OpAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:13563:1: ( ( rule__SignedConstant__OpAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:13441:1: ( ( rule__SignedConstant__OpAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:13442:2: ( rule__SignedConstant__OpAssignment_0 ) + // InternalBehaviorAnnexParser.g:13563:1: ( ( rule__SignedConstant__OpAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13564:2: ( rule__SignedConstant__OpAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSignedConstantAccess().getOpAssignment_0()); } - // InternalBehaviorAnnexParser.g:13443:2: ( rule__SignedConstant__OpAssignment_0 ) - // InternalBehaviorAnnexParser.g:13443:3: rule__SignedConstant__OpAssignment_0 + // InternalBehaviorAnnexParser.g:13565:2: ( rule__SignedConstant__OpAssignment_0 ) + // InternalBehaviorAnnexParser.g:13565:3: rule__SignedConstant__OpAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedConstant__OpAssignment_0(); @@ -44442,14 +44900,14 @@ public final void rule__SignedConstant__Group__0__Impl() throws RecognitionExcep // $ANTLR start "rule__SignedConstant__Group__1" - // InternalBehaviorAnnexParser.g:13451:1: rule__SignedConstant__Group__1 : rule__SignedConstant__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13573: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:13455:1: ( rule__SignedConstant__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13456:2: rule__SignedConstant__Group__1__Impl + // InternalBehaviorAnnexParser.g:13577:1: ( rule__SignedConstant__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13578:2: rule__SignedConstant__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__SignedConstant__Group__1__Impl(); @@ -44475,23 +44933,23 @@ public final void rule__SignedConstant__Group__1() throws RecognitionException { // $ANTLR start "rule__SignedConstant__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13462:1: rule__SignedConstant__Group__1__Impl : ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) ; + // InternalBehaviorAnnexParser.g:13584: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:13466:1: ( ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) ) - // InternalBehaviorAnnexParser.g:13467:1: ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:13588:1: ( ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) ) + // InternalBehaviorAnnexParser.g:13589:1: ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) { - // InternalBehaviorAnnexParser.g:13467:1: ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) - // InternalBehaviorAnnexParser.g:13468:2: ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) + // InternalBehaviorAnnexParser.g:13589:1: ( ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) ) + // InternalBehaviorAnnexParser.g:13590:2: ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getSignedConstantAccess().getOwnedPropertyExpressionAssignment_1()); } - // InternalBehaviorAnnexParser.g:13469:2: ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) - // InternalBehaviorAnnexParser.g:13469:3: rule__SignedConstant__OwnedPropertyExpressionAssignment_1 + // InternalBehaviorAnnexParser.g:13591:2: ( rule__SignedConstant__OwnedPropertyExpressionAssignment_1 ) + // InternalBehaviorAnnexParser.g:13591:3: rule__SignedConstant__OwnedPropertyExpressionAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedConstant__OwnedPropertyExpressionAssignment_1(); @@ -44526,14 +44984,14 @@ public final void rule__SignedConstant__Group__1__Impl() throws RecognitionExcep // $ANTLR start "rule__IntegerTerm__Group__0" - // InternalBehaviorAnnexParser.g:13478:1: rule__IntegerTerm__Group__0 : rule__IntegerTerm__Group__0__Impl rule__IntegerTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:13600: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:13482:1: ( rule__IntegerTerm__Group__0__Impl rule__IntegerTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:13483:2: rule__IntegerTerm__Group__0__Impl rule__IntegerTerm__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__IntegerTerm__Group__0__Impl(); @@ -44564,23 +45022,23 @@ public final void rule__IntegerTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__IntegerTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13490:1: rule__IntegerTerm__Group__0__Impl : ( ( rule__IntegerTerm__ValueAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:13612: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:13494:1: ( ( ( rule__IntegerTerm__ValueAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:13495:1: ( ( rule__IntegerTerm__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13616:1: ( ( ( rule__IntegerTerm__ValueAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:13617:1: ( ( rule__IntegerTerm__ValueAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:13495:1: ( ( rule__IntegerTerm__ValueAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:13496:2: ( rule__IntegerTerm__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:13617:1: ( ( rule__IntegerTerm__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13618:2: ( rule__IntegerTerm__ValueAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getValueAssignment_0()); } - // InternalBehaviorAnnexParser.g:13497:2: ( rule__IntegerTerm__ValueAssignment_0 ) - // InternalBehaviorAnnexParser.g:13497:3: rule__IntegerTerm__ValueAssignment_0 + // InternalBehaviorAnnexParser.g:13619:2: ( rule__IntegerTerm__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:13619:3: rule__IntegerTerm__ValueAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__IntegerTerm__ValueAssignment_0(); @@ -44615,14 +45073,14 @@ public final void rule__IntegerTerm__Group__0__Impl() throws RecognitionExceptio // $ANTLR start "rule__IntegerTerm__Group__1" - // InternalBehaviorAnnexParser.g:13505:1: rule__IntegerTerm__Group__1 : rule__IntegerTerm__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13627: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:13509:1: ( rule__IntegerTerm__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13510:2: rule__IntegerTerm__Group__1__Impl + // InternalBehaviorAnnexParser.g:13631:1: ( rule__IntegerTerm__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13632:2: rule__IntegerTerm__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__IntegerTerm__Group__1__Impl(); @@ -44648,31 +45106,31 @@ public final void rule__IntegerTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__IntegerTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13516:1: rule__IntegerTerm__Group__1__Impl : ( ( rule__IntegerTerm__UnitAssignment_1 )? ) ; + // InternalBehaviorAnnexParser.g:13638: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:13520:1: ( ( ( rule__IntegerTerm__UnitAssignment_1 )? ) ) - // InternalBehaviorAnnexParser.g:13521:1: ( ( rule__IntegerTerm__UnitAssignment_1 )? ) + // InternalBehaviorAnnexParser.g:13642:1: ( ( ( rule__IntegerTerm__UnitAssignment_1 )? ) ) + // InternalBehaviorAnnexParser.g:13643:1: ( ( rule__IntegerTerm__UnitAssignment_1 )? ) { - // InternalBehaviorAnnexParser.g:13521:1: ( ( rule__IntegerTerm__UnitAssignment_1 )? ) - // InternalBehaviorAnnexParser.g:13522:2: ( rule__IntegerTerm__UnitAssignment_1 )? + // InternalBehaviorAnnexParser.g:13643:1: ( ( rule__IntegerTerm__UnitAssignment_1 )? ) + // InternalBehaviorAnnexParser.g:13644:2: ( rule__IntegerTerm__UnitAssignment_1 )? { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getUnitAssignment_1()); } - // InternalBehaviorAnnexParser.g:13523:2: ( rule__IntegerTerm__UnitAssignment_1 )? - int alt112=2; - int LA112_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13645:2: ( rule__IntegerTerm__UnitAssignment_1 )? + int alt114=2; + int LA114_0 = input.LA(1); - if ( (LA112_0==RULE_ID) ) { - alt112=1; + if ( (LA114_0==RULE_ID) ) { + alt114=1; } - switch (alt112) { + switch (alt114) { case 1 : - // InternalBehaviorAnnexParser.g:13523:3: rule__IntegerTerm__UnitAssignment_1 + // InternalBehaviorAnnexParser.g:13645:3: rule__IntegerTerm__UnitAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__IntegerTerm__UnitAssignment_1(); @@ -44710,16 +45168,16 @@ public final void rule__IntegerTerm__Group__1__Impl() throws RecognitionExceptio // $ANTLR start "rule__SignedInt__Group__0" - // InternalBehaviorAnnexParser.g:13532:1: rule__SignedInt__Group__0 : rule__SignedInt__Group__0__Impl rule__SignedInt__Group__1 ; + // InternalBehaviorAnnexParser.g:13654: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:13536:1: ( rule__SignedInt__Group__0__Impl rule__SignedInt__Group__1 ) - // InternalBehaviorAnnexParser.g:13537:2: rule__SignedInt__Group__0__Impl rule__SignedInt__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_89); + pushFollow(FollowSets000.FOLLOW_90); rule__SignedInt__Group__0__Impl(); state._fsp--; @@ -44748,31 +45206,31 @@ public final void rule__SignedInt__Group__0() throws RecognitionException { // $ANTLR start "rule__SignedInt__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13544:1: rule__SignedInt__Group__0__Impl : ( ( rule__SignedInt__Alternatives_0 )? ) ; + // InternalBehaviorAnnexParser.g:13666: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:13548:1: ( ( ( rule__SignedInt__Alternatives_0 )? ) ) - // InternalBehaviorAnnexParser.g:13549:1: ( ( rule__SignedInt__Alternatives_0 )? ) + // InternalBehaviorAnnexParser.g:13670:1: ( ( ( rule__SignedInt__Alternatives_0 )? ) ) + // InternalBehaviorAnnexParser.g:13671:1: ( ( rule__SignedInt__Alternatives_0 )? ) { - // InternalBehaviorAnnexParser.g:13549:1: ( ( rule__SignedInt__Alternatives_0 )? ) - // InternalBehaviorAnnexParser.g:13550:2: ( rule__SignedInt__Alternatives_0 )? + // InternalBehaviorAnnexParser.g:13671:1: ( ( rule__SignedInt__Alternatives_0 )? ) + // InternalBehaviorAnnexParser.g:13672:2: ( rule__SignedInt__Alternatives_0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getSignedIntAccess().getAlternatives_0()); } - // InternalBehaviorAnnexParser.g:13551:2: ( rule__SignedInt__Alternatives_0 )? - int alt113=2; - int LA113_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13673:2: ( rule__SignedInt__Alternatives_0 )? + int alt115=2; + int LA115_0 = input.LA(1); - if ( (LA113_0==PlusSign||LA113_0==HyphenMinus) ) { - alt113=1; + if ( (LA115_0==PlusSign||LA115_0==HyphenMinus) ) { + alt115=1; } - switch (alt113) { + switch (alt115) { case 1 : - // InternalBehaviorAnnexParser.g:13551:3: rule__SignedInt__Alternatives_0 + // InternalBehaviorAnnexParser.g:13673:3: rule__SignedInt__Alternatives_0 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedInt__Alternatives_0(); @@ -44810,14 +45268,14 @@ public final void rule__SignedInt__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__SignedInt__Group__1" - // InternalBehaviorAnnexParser.g:13559:1: rule__SignedInt__Group__1 : rule__SignedInt__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13681: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:13563:1: ( rule__SignedInt__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13564:2: rule__SignedInt__Group__1__Impl + // InternalBehaviorAnnexParser.g:13685:1: ( rule__SignedInt__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13686:2: rule__SignedInt__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__SignedInt__Group__1__Impl(); @@ -44843,17 +45301,17 @@ public final void rule__SignedInt__Group__1() throws RecognitionException { // $ANTLR start "rule__SignedInt__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13570:1: rule__SignedInt__Group__1__Impl : ( RULE_INTEGER_LIT ) ; + // InternalBehaviorAnnexParser.g:13692: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:13574:1: ( ( RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:13575:1: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:13696:1: ( ( RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:13697:1: ( RULE_INTEGER_LIT ) { - // InternalBehaviorAnnexParser.g:13575:1: ( RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:13576:2: RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:13697:1: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:13698:2: RULE_INTEGER_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getSignedIntAccess().getINTEGER_LITTerminalRuleCall_1()); @@ -44884,14 +45342,14 @@ public final void rule__SignedInt__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__RealTerm__Group__0" - // InternalBehaviorAnnexParser.g:13586:1: rule__RealTerm__Group__0 : rule__RealTerm__Group__0__Impl rule__RealTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:13708: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:13590:1: ( rule__RealTerm__Group__0__Impl rule__RealTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:13591:2: rule__RealTerm__Group__0__Impl rule__RealTerm__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__RealTerm__Group__0__Impl(); @@ -44922,23 +45380,23 @@ public final void rule__RealTerm__Group__0() throws RecognitionException { // $ANTLR start "rule__RealTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13598:1: rule__RealTerm__Group__0__Impl : ( ( rule__RealTerm__ValueAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:13720: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:13602:1: ( ( ( rule__RealTerm__ValueAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:13603:1: ( ( rule__RealTerm__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13724:1: ( ( ( rule__RealTerm__ValueAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:13725:1: ( ( rule__RealTerm__ValueAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:13603:1: ( ( rule__RealTerm__ValueAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:13604:2: ( rule__RealTerm__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:13725:1: ( ( rule__RealTerm__ValueAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13726:2: ( rule__RealTerm__ValueAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getValueAssignment_0()); } - // InternalBehaviorAnnexParser.g:13605:2: ( rule__RealTerm__ValueAssignment_0 ) - // InternalBehaviorAnnexParser.g:13605:3: rule__RealTerm__ValueAssignment_0 + // InternalBehaviorAnnexParser.g:13727:2: ( rule__RealTerm__ValueAssignment_0 ) + // InternalBehaviorAnnexParser.g:13727:3: rule__RealTerm__ValueAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__RealTerm__ValueAssignment_0(); @@ -44973,14 +45431,14 @@ public final void rule__RealTerm__Group__0__Impl() throws RecognitionException { // $ANTLR start "rule__RealTerm__Group__1" - // InternalBehaviorAnnexParser.g:13613:1: rule__RealTerm__Group__1 : rule__RealTerm__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13735: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:13617:1: ( rule__RealTerm__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13618:2: rule__RealTerm__Group__1__Impl + // InternalBehaviorAnnexParser.g:13739:1: ( rule__RealTerm__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13740:2: rule__RealTerm__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__RealTerm__Group__1__Impl(); @@ -45006,31 +45464,31 @@ public final void rule__RealTerm__Group__1() throws RecognitionException { // $ANTLR start "rule__RealTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13624:1: rule__RealTerm__Group__1__Impl : ( ( rule__RealTerm__UnitAssignment_1 )? ) ; + // InternalBehaviorAnnexParser.g:13746: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:13628:1: ( ( ( rule__RealTerm__UnitAssignment_1 )? ) ) - // InternalBehaviorAnnexParser.g:13629:1: ( ( rule__RealTerm__UnitAssignment_1 )? ) + // InternalBehaviorAnnexParser.g:13750:1: ( ( ( rule__RealTerm__UnitAssignment_1 )? ) ) + // InternalBehaviorAnnexParser.g:13751:1: ( ( rule__RealTerm__UnitAssignment_1 )? ) { - // InternalBehaviorAnnexParser.g:13629:1: ( ( rule__RealTerm__UnitAssignment_1 )? ) - // InternalBehaviorAnnexParser.g:13630:2: ( rule__RealTerm__UnitAssignment_1 )? + // InternalBehaviorAnnexParser.g:13751:1: ( ( rule__RealTerm__UnitAssignment_1 )? ) + // InternalBehaviorAnnexParser.g:13752:2: ( rule__RealTerm__UnitAssignment_1 )? { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getUnitAssignment_1()); } - // InternalBehaviorAnnexParser.g:13631:2: ( rule__RealTerm__UnitAssignment_1 )? - int alt114=2; - int LA114_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13753:2: ( rule__RealTerm__UnitAssignment_1 )? + int alt116=2; + int LA116_0 = input.LA(1); - if ( (LA114_0==RULE_ID) ) { - alt114=1; + if ( (LA116_0==RULE_ID) ) { + alt116=1; } - switch (alt114) { + switch (alt116) { case 1 : - // InternalBehaviorAnnexParser.g:13631:3: rule__RealTerm__UnitAssignment_1 + // InternalBehaviorAnnexParser.g:13753:3: rule__RealTerm__UnitAssignment_1 { pushFollow(FollowSets000.FOLLOW_2); rule__RealTerm__UnitAssignment_1(); @@ -45068,16 +45526,16 @@ public final void rule__RealTerm__Group__1__Impl() throws RecognitionException { // $ANTLR start "rule__SignedReal__Group__0" - // InternalBehaviorAnnexParser.g:13640:1: rule__SignedReal__Group__0 : rule__SignedReal__Group__0__Impl rule__SignedReal__Group__1 ; + // InternalBehaviorAnnexParser.g:13762: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:13644:1: ( rule__SignedReal__Group__0__Impl rule__SignedReal__Group__1 ) - // InternalBehaviorAnnexParser.g:13645:2: rule__SignedReal__Group__0__Impl rule__SignedReal__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_90); + pushFollow(FollowSets000.FOLLOW_91); rule__SignedReal__Group__0__Impl(); state._fsp--; @@ -45106,31 +45564,31 @@ public final void rule__SignedReal__Group__0() throws RecognitionException { // $ANTLR start "rule__SignedReal__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13652:1: rule__SignedReal__Group__0__Impl : ( ( rule__SignedReal__Alternatives_0 )? ) ; + // InternalBehaviorAnnexParser.g:13774: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:13656:1: ( ( ( rule__SignedReal__Alternatives_0 )? ) ) - // InternalBehaviorAnnexParser.g:13657:1: ( ( rule__SignedReal__Alternatives_0 )? ) + // InternalBehaviorAnnexParser.g:13778:1: ( ( ( rule__SignedReal__Alternatives_0 )? ) ) + // InternalBehaviorAnnexParser.g:13779:1: ( ( rule__SignedReal__Alternatives_0 )? ) { - // InternalBehaviorAnnexParser.g:13657:1: ( ( rule__SignedReal__Alternatives_0 )? ) - // InternalBehaviorAnnexParser.g:13658:2: ( rule__SignedReal__Alternatives_0 )? + // InternalBehaviorAnnexParser.g:13779:1: ( ( rule__SignedReal__Alternatives_0 )? ) + // InternalBehaviorAnnexParser.g:13780:2: ( rule__SignedReal__Alternatives_0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getSignedRealAccess().getAlternatives_0()); } - // InternalBehaviorAnnexParser.g:13659:2: ( rule__SignedReal__Alternatives_0 )? - int alt115=2; - int LA115_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13781:2: ( rule__SignedReal__Alternatives_0 )? + int alt117=2; + int LA117_0 = input.LA(1); - if ( (LA115_0==PlusSign||LA115_0==HyphenMinus) ) { - alt115=1; + if ( (LA117_0==PlusSign||LA117_0==HyphenMinus) ) { + alt117=1; } - switch (alt115) { + switch (alt117) { case 1 : - // InternalBehaviorAnnexParser.g:13659:3: rule__SignedReal__Alternatives_0 + // InternalBehaviorAnnexParser.g:13781:3: rule__SignedReal__Alternatives_0 { pushFollow(FollowSets000.FOLLOW_2); rule__SignedReal__Alternatives_0(); @@ -45168,14 +45626,14 @@ public final void rule__SignedReal__Group__0__Impl() throws RecognitionException // $ANTLR start "rule__SignedReal__Group__1" - // InternalBehaviorAnnexParser.g:13667:1: rule__SignedReal__Group__1 : rule__SignedReal__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:13789: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:13671:1: ( rule__SignedReal__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13672:2: rule__SignedReal__Group__1__Impl + // InternalBehaviorAnnexParser.g:13793:1: ( rule__SignedReal__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:13794:2: rule__SignedReal__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__SignedReal__Group__1__Impl(); @@ -45201,17 +45659,17 @@ public final void rule__SignedReal__Group__1() throws RecognitionException { // $ANTLR start "rule__SignedReal__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13678:1: rule__SignedReal__Group__1__Impl : ( RULE_REAL_LIT ) ; + // InternalBehaviorAnnexParser.g:13800: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:13682:1: ( ( RULE_REAL_LIT ) ) - // InternalBehaviorAnnexParser.g:13683:1: ( RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:13804:1: ( ( RULE_REAL_LIT ) ) + // InternalBehaviorAnnexParser.g:13805:1: ( RULE_REAL_LIT ) { - // InternalBehaviorAnnexParser.g:13683:1: ( RULE_REAL_LIT ) - // InternalBehaviorAnnexParser.g:13684:2: RULE_REAL_LIT + // InternalBehaviorAnnexParser.g:13805:1: ( RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:13806:2: RULE_REAL_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getSignedRealAccess().getREAL_LITTerminalRuleCall_1()); @@ -45242,14 +45700,14 @@ public final void rule__SignedReal__Group__1__Impl() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__Group__0" - // InternalBehaviorAnnexParser.g:13694:1: rule__NumericRangeTerm__Group__0 : rule__NumericRangeTerm__Group__0__Impl rule__NumericRangeTerm__Group__1 ; + // InternalBehaviorAnnexParser.g:13816: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:13698:1: ( rule__NumericRangeTerm__Group__0__Impl rule__NumericRangeTerm__Group__1 ) - // InternalBehaviorAnnexParser.g:13699:2: rule__NumericRangeTerm__Group__0__Impl rule__NumericRangeTerm__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_58); rule__NumericRangeTerm__Group__0__Impl(); @@ -45280,23 +45738,23 @@ public final void rule__NumericRangeTerm__Group__0() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13706:1: rule__NumericRangeTerm__Group__0__Impl : ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) ; + // InternalBehaviorAnnexParser.g:13828: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:13710:1: ( ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) ) - // InternalBehaviorAnnexParser.g:13711:1: ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13832:1: ( ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) ) + // InternalBehaviorAnnexParser.g:13833:1: ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) { - // InternalBehaviorAnnexParser.g:13711:1: ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) - // InternalBehaviorAnnexParser.g:13712:2: ( rule__NumericRangeTerm__MinimumAssignment_0 ) + // InternalBehaviorAnnexParser.g:13833:1: ( ( rule__NumericRangeTerm__MinimumAssignment_0 ) ) + // InternalBehaviorAnnexParser.g:13834:2: ( rule__NumericRangeTerm__MinimumAssignment_0 ) { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getMinimumAssignment_0()); } - // InternalBehaviorAnnexParser.g:13713:2: ( rule__NumericRangeTerm__MinimumAssignment_0 ) - // InternalBehaviorAnnexParser.g:13713:3: rule__NumericRangeTerm__MinimumAssignment_0 + // InternalBehaviorAnnexParser.g:13835:2: ( rule__NumericRangeTerm__MinimumAssignment_0 ) + // InternalBehaviorAnnexParser.g:13835:3: rule__NumericRangeTerm__MinimumAssignment_0 { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__MinimumAssignment_0(); @@ -45331,16 +45789,16 @@ public final void rule__NumericRangeTerm__Group__0__Impl() throws RecognitionExc // $ANTLR start "rule__NumericRangeTerm__Group__1" - // InternalBehaviorAnnexParser.g:13721:1: rule__NumericRangeTerm__Group__1 : rule__NumericRangeTerm__Group__1__Impl rule__NumericRangeTerm__Group__2 ; + // InternalBehaviorAnnexParser.g:13843: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:13725:1: ( rule__NumericRangeTerm__Group__1__Impl rule__NumericRangeTerm__Group__2 ) - // InternalBehaviorAnnexParser.g:13726:2: rule__NumericRangeTerm__Group__1__Impl rule__NumericRangeTerm__Group__2 + // 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 { - pushFollow(FollowSets000.FOLLOW_88); + pushFollow(FollowSets000.FOLLOW_89); rule__NumericRangeTerm__Group__1__Impl(); state._fsp--; @@ -45369,17 +45827,17 @@ public final void rule__NumericRangeTerm__Group__1() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13733:1: rule__NumericRangeTerm__Group__1__Impl : ( FullStopFullStop ) ; + // InternalBehaviorAnnexParser.g:13855:1: rule__NumericRangeTerm__Group__1__Impl : ( FullStopFullStop ) ; public final void rule__NumericRangeTerm__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13737:1: ( ( FullStopFullStop ) ) - // InternalBehaviorAnnexParser.g:13738:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:13859:1: ( ( FullStopFullStop ) ) + // InternalBehaviorAnnexParser.g:13860:1: ( FullStopFullStop ) { - // InternalBehaviorAnnexParser.g:13738:1: ( FullStopFullStop ) - // InternalBehaviorAnnexParser.g:13739:2: FullStopFullStop + // InternalBehaviorAnnexParser.g:13860:1: ( FullStopFullStop ) + // InternalBehaviorAnnexParser.g:13861:2: FullStopFullStop { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getFullStopFullStopKeyword_1()); @@ -45410,16 +45868,16 @@ public final void rule__NumericRangeTerm__Group__1__Impl() throws RecognitionExc // $ANTLR start "rule__NumericRangeTerm__Group__2" - // InternalBehaviorAnnexParser.g:13748:1: rule__NumericRangeTerm__Group__2 : rule__NumericRangeTerm__Group__2__Impl rule__NumericRangeTerm__Group__3 ; + // InternalBehaviorAnnexParser.g:13870: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:13752:1: ( rule__NumericRangeTerm__Group__2__Impl rule__NumericRangeTerm__Group__3 ) - // InternalBehaviorAnnexParser.g:13753:2: rule__NumericRangeTerm__Group__2__Impl rule__NumericRangeTerm__Group__3 + // 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 { - pushFollow(FollowSets000.FOLLOW_91); + pushFollow(FollowSets000.FOLLOW_92); rule__NumericRangeTerm__Group__2__Impl(); state._fsp--; @@ -45448,23 +45906,23 @@ public final void rule__NumericRangeTerm__Group__2() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__Group__2__Impl" - // InternalBehaviorAnnexParser.g:13760:1: rule__NumericRangeTerm__Group__2__Impl : ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) ; + // InternalBehaviorAnnexParser.g:13882: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:13764:1: ( ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) ) - // InternalBehaviorAnnexParser.g:13765:1: ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13886:1: ( ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) ) + // InternalBehaviorAnnexParser.g:13887:1: ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) { - // InternalBehaviorAnnexParser.g:13765:1: ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) - // InternalBehaviorAnnexParser.g:13766:2: ( rule__NumericRangeTerm__MaximumAssignment_2 ) + // InternalBehaviorAnnexParser.g:13887:1: ( ( rule__NumericRangeTerm__MaximumAssignment_2 ) ) + // InternalBehaviorAnnexParser.g:13888:2: ( rule__NumericRangeTerm__MaximumAssignment_2 ) { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getMaximumAssignment_2()); } - // InternalBehaviorAnnexParser.g:13767:2: ( rule__NumericRangeTerm__MaximumAssignment_2 ) - // InternalBehaviorAnnexParser.g:13767:3: rule__NumericRangeTerm__MaximumAssignment_2 + // InternalBehaviorAnnexParser.g:13889:2: ( rule__NumericRangeTerm__MaximumAssignment_2 ) + // InternalBehaviorAnnexParser.g:13889:3: rule__NumericRangeTerm__MaximumAssignment_2 { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__MaximumAssignment_2(); @@ -45499,14 +45957,14 @@ public final void rule__NumericRangeTerm__Group__2__Impl() throws RecognitionExc // $ANTLR start "rule__NumericRangeTerm__Group__3" - // InternalBehaviorAnnexParser.g:13775:1: rule__NumericRangeTerm__Group__3 : rule__NumericRangeTerm__Group__3__Impl ; + // InternalBehaviorAnnexParser.g:13897: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:13779:1: ( rule__NumericRangeTerm__Group__3__Impl ) - // InternalBehaviorAnnexParser.g:13780:2: rule__NumericRangeTerm__Group__3__Impl + // InternalBehaviorAnnexParser.g:13901:1: ( rule__NumericRangeTerm__Group__3__Impl ) + // InternalBehaviorAnnexParser.g:13902:2: rule__NumericRangeTerm__Group__3__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__Group__3__Impl(); @@ -45532,31 +45990,31 @@ public final void rule__NumericRangeTerm__Group__3() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__Group__3__Impl" - // InternalBehaviorAnnexParser.g:13786:1: rule__NumericRangeTerm__Group__3__Impl : ( ( rule__NumericRangeTerm__Group_3__0 )? ) ; + // InternalBehaviorAnnexParser.g:13908: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:13790:1: ( ( ( rule__NumericRangeTerm__Group_3__0 )? ) ) - // InternalBehaviorAnnexParser.g:13791:1: ( ( rule__NumericRangeTerm__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:13912:1: ( ( ( rule__NumericRangeTerm__Group_3__0 )? ) ) + // InternalBehaviorAnnexParser.g:13913:1: ( ( rule__NumericRangeTerm__Group_3__0 )? ) { - // InternalBehaviorAnnexParser.g:13791:1: ( ( rule__NumericRangeTerm__Group_3__0 )? ) - // InternalBehaviorAnnexParser.g:13792:2: ( rule__NumericRangeTerm__Group_3__0 )? + // InternalBehaviorAnnexParser.g:13913:1: ( ( rule__NumericRangeTerm__Group_3__0 )? ) + // InternalBehaviorAnnexParser.g:13914:2: ( rule__NumericRangeTerm__Group_3__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getGroup_3()); } - // InternalBehaviorAnnexParser.g:13793:2: ( rule__NumericRangeTerm__Group_3__0 )? - int alt116=2; - int LA116_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:13915:2: ( rule__NumericRangeTerm__Group_3__0 )? + int alt118=2; + int LA118_0 = input.LA(1); - if ( (LA116_0==Delta) ) { - alt116=1; + if ( (LA118_0==Delta) ) { + alt118=1; } - switch (alt116) { + switch (alt118) { case 1 : - // InternalBehaviorAnnexParser.g:13793:3: rule__NumericRangeTerm__Group_3__0 + // InternalBehaviorAnnexParser.g:13915:3: rule__NumericRangeTerm__Group_3__0 { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__Group_3__0(); @@ -45594,16 +46052,16 @@ public final void rule__NumericRangeTerm__Group__3__Impl() throws RecognitionExc // $ANTLR start "rule__NumericRangeTerm__Group_3__0" - // InternalBehaviorAnnexParser.g:13802:1: rule__NumericRangeTerm__Group_3__0 : rule__NumericRangeTerm__Group_3__0__Impl rule__NumericRangeTerm__Group_3__1 ; + // InternalBehaviorAnnexParser.g:13924: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:13806:1: ( rule__NumericRangeTerm__Group_3__0__Impl rule__NumericRangeTerm__Group_3__1 ) - // InternalBehaviorAnnexParser.g:13807:2: rule__NumericRangeTerm__Group_3__0__Impl rule__NumericRangeTerm__Group_3__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_88); + pushFollow(FollowSets000.FOLLOW_89); rule__NumericRangeTerm__Group_3__0__Impl(); state._fsp--; @@ -45632,17 +46090,17 @@ public final void rule__NumericRangeTerm__Group_3__0() throws RecognitionExcepti // $ANTLR start "rule__NumericRangeTerm__Group_3__0__Impl" - // InternalBehaviorAnnexParser.g:13814:1: rule__NumericRangeTerm__Group_3__0__Impl : ( Delta ) ; + // InternalBehaviorAnnexParser.g:13936: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:13818:1: ( ( Delta ) ) - // InternalBehaviorAnnexParser.g:13819:1: ( Delta ) + // InternalBehaviorAnnexParser.g:13940:1: ( ( Delta ) ) + // InternalBehaviorAnnexParser.g:13941:1: ( Delta ) { - // InternalBehaviorAnnexParser.g:13819:1: ( Delta ) - // InternalBehaviorAnnexParser.g:13820:2: Delta + // InternalBehaviorAnnexParser.g:13941:1: ( Delta ) + // InternalBehaviorAnnexParser.g:13942:2: Delta { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getDeltaKeyword_3_0()); @@ -45673,14 +46131,14 @@ public final void rule__NumericRangeTerm__Group_3__0__Impl() throws RecognitionE // $ANTLR start "rule__NumericRangeTerm__Group_3__1" - // InternalBehaviorAnnexParser.g:13829:1: rule__NumericRangeTerm__Group_3__1 : rule__NumericRangeTerm__Group_3__1__Impl ; + // InternalBehaviorAnnexParser.g:13951: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:13833:1: ( rule__NumericRangeTerm__Group_3__1__Impl ) - // InternalBehaviorAnnexParser.g:13834:2: rule__NumericRangeTerm__Group_3__1__Impl + // InternalBehaviorAnnexParser.g:13955:1: ( rule__NumericRangeTerm__Group_3__1__Impl ) + // InternalBehaviorAnnexParser.g:13956:2: rule__NumericRangeTerm__Group_3__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__Group_3__1__Impl(); @@ -45706,23 +46164,23 @@ public final void rule__NumericRangeTerm__Group_3__1() throws RecognitionExcepti // $ANTLR start "rule__NumericRangeTerm__Group_3__1__Impl" - // InternalBehaviorAnnexParser.g:13840:1: rule__NumericRangeTerm__Group_3__1__Impl : ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) ; + // InternalBehaviorAnnexParser.g:13962: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:13844:1: ( ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) ) - // InternalBehaviorAnnexParser.g:13845:1: ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:13966:1: ( ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) ) + // InternalBehaviorAnnexParser.g:13967:1: ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) { - // InternalBehaviorAnnexParser.g:13845:1: ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) - // InternalBehaviorAnnexParser.g:13846:2: ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:13967:1: ( ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) ) + // InternalBehaviorAnnexParser.g:13968:2: ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getDeltaAssignment_3_1()); } - // InternalBehaviorAnnexParser.g:13847:2: ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) - // InternalBehaviorAnnexParser.g:13847:3: rule__NumericRangeTerm__DeltaAssignment_3_1 + // InternalBehaviorAnnexParser.g:13969:2: ( rule__NumericRangeTerm__DeltaAssignment_3_1 ) + // InternalBehaviorAnnexParser.g:13969:3: rule__NumericRangeTerm__DeltaAssignment_3_1 { pushFollow(FollowSets000.FOLLOW_2); rule__NumericRangeTerm__DeltaAssignment_3_1(); @@ -45757,16 +46215,16 @@ public final void rule__NumericRangeTerm__Group_3__1__Impl() throws RecognitionE // $ANTLR start "rule__QPREF__Group__0" - // InternalBehaviorAnnexParser.g:13856:1: rule__QPREF__Group__0 : rule__QPREF__Group__0__Impl rule__QPREF__Group__1 ; + // InternalBehaviorAnnexParser.g:13978: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:13860:1: ( rule__QPREF__Group__0__Impl rule__QPREF__Group__1 ) - // InternalBehaviorAnnexParser.g:13861:2: rule__QPREF__Group__0__Impl rule__QPREF__Group__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_77); + pushFollow(FollowSets000.FOLLOW_78); rule__QPREF__Group__0__Impl(); state._fsp--; @@ -45795,17 +46253,17 @@ public final void rule__QPREF__Group__0() throws RecognitionException { // $ANTLR start "rule__QPREF__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13868:1: rule__QPREF__Group__0__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:13990:1: rule__QPREF__Group__0__Impl : ( RULE_ID ) ; public final void rule__QPREF__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:13872:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:13873:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:13994:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:13995:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:13873:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:13874:2: RULE_ID + // InternalBehaviorAnnexParser.g:13995:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:13996:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQPREFAccess().getIDTerminalRuleCall_0()); @@ -45836,14 +46294,14 @@ public final void rule__QPREF__Group__0__Impl() throws RecognitionException { // $ANTLR start "rule__QPREF__Group__1" - // InternalBehaviorAnnexParser.g:13883:1: rule__QPREF__Group__1 : rule__QPREF__Group__1__Impl ; + // InternalBehaviorAnnexParser.g:14005: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:13887:1: ( rule__QPREF__Group__1__Impl ) - // InternalBehaviorAnnexParser.g:13888:2: rule__QPREF__Group__1__Impl + // InternalBehaviorAnnexParser.g:14009:1: ( rule__QPREF__Group__1__Impl ) + // InternalBehaviorAnnexParser.g:14010:2: rule__QPREF__Group__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QPREF__Group__1__Impl(); @@ -45869,31 +46327,31 @@ public final void rule__QPREF__Group__1() throws RecognitionException { // $ANTLR start "rule__QPREF__Group__1__Impl" - // InternalBehaviorAnnexParser.g:13894:1: rule__QPREF__Group__1__Impl : ( ( rule__QPREF__Group_1__0 )? ) ; + // InternalBehaviorAnnexParser.g:14016: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:13898:1: ( ( ( rule__QPREF__Group_1__0 )? ) ) - // InternalBehaviorAnnexParser.g:13899:1: ( ( rule__QPREF__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:14020:1: ( ( ( rule__QPREF__Group_1__0 )? ) ) + // InternalBehaviorAnnexParser.g:14021:1: ( ( rule__QPREF__Group_1__0 )? ) { - // InternalBehaviorAnnexParser.g:13899:1: ( ( rule__QPREF__Group_1__0 )? ) - // InternalBehaviorAnnexParser.g:13900:2: ( rule__QPREF__Group_1__0 )? + // InternalBehaviorAnnexParser.g:14021:1: ( ( rule__QPREF__Group_1__0 )? ) + // InternalBehaviorAnnexParser.g:14022:2: ( rule__QPREF__Group_1__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getQPREFAccess().getGroup_1()); } - // InternalBehaviorAnnexParser.g:13901:2: ( rule__QPREF__Group_1__0 )? - int alt117=2; - int LA117_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:14023:2: ( rule__QPREF__Group_1__0 )? + int alt119=2; + int LA119_0 = input.LA(1); - if ( (LA117_0==ColonColon) ) { - alt117=1; + if ( (LA119_0==ColonColon) ) { + alt119=1; } - switch (alt117) { + switch (alt119) { case 1 : - // InternalBehaviorAnnexParser.g:13901:3: rule__QPREF__Group_1__0 + // InternalBehaviorAnnexParser.g:14023:3: rule__QPREF__Group_1__0 { pushFollow(FollowSets000.FOLLOW_2); rule__QPREF__Group_1__0(); @@ -45931,14 +46389,14 @@ public final void rule__QPREF__Group__1__Impl() throws RecognitionException { // $ANTLR start "rule__QPREF__Group_1__0" - // InternalBehaviorAnnexParser.g:13910:1: rule__QPREF__Group_1__0 : rule__QPREF__Group_1__0__Impl rule__QPREF__Group_1__1 ; + // InternalBehaviorAnnexParser.g:14032: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:13914:1: ( rule__QPREF__Group_1__0__Impl rule__QPREF__Group_1__1 ) - // InternalBehaviorAnnexParser.g:13915:2: rule__QPREF__Group_1__0__Impl rule__QPREF__Group_1__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__QPREF__Group_1__0__Impl(); @@ -45969,17 +46427,17 @@ public final void rule__QPREF__Group_1__0() throws RecognitionException { // $ANTLR start "rule__QPREF__Group_1__0__Impl" - // InternalBehaviorAnnexParser.g:13922:1: rule__QPREF__Group_1__0__Impl : ( ColonColon ) ; + // InternalBehaviorAnnexParser.g:14044: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:13926:1: ( ( ColonColon ) ) - // InternalBehaviorAnnexParser.g:13927:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:14048:1: ( ( ColonColon ) ) + // InternalBehaviorAnnexParser.g:14049:1: ( ColonColon ) { - // InternalBehaviorAnnexParser.g:13927:1: ( ColonColon ) - // InternalBehaviorAnnexParser.g:13928:2: ColonColon + // InternalBehaviorAnnexParser.g:14049:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:14050:2: ColonColon { if ( state.backtracking==0 ) { before(grammarAccess.getQPREFAccess().getColonColonKeyword_1_0()); @@ -46010,14 +46468,14 @@ public final void rule__QPREF__Group_1__0__Impl() throws RecognitionException { // $ANTLR start "rule__QPREF__Group_1__1" - // InternalBehaviorAnnexParser.g:13937:1: rule__QPREF__Group_1__1 : rule__QPREF__Group_1__1__Impl ; + // InternalBehaviorAnnexParser.g:14059: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:13941:1: ( rule__QPREF__Group_1__1__Impl ) - // InternalBehaviorAnnexParser.g:13942:2: rule__QPREF__Group_1__1__Impl + // InternalBehaviorAnnexParser.g:14063:1: ( rule__QPREF__Group_1__1__Impl ) + // InternalBehaviorAnnexParser.g:14064:2: rule__QPREF__Group_1__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QPREF__Group_1__1__Impl(); @@ -46043,17 +46501,17 @@ public final void rule__QPREF__Group_1__1() throws RecognitionException { // $ANTLR start "rule__QPREF__Group_1__1__Impl" - // InternalBehaviorAnnexParser.g:13948:1: rule__QPREF__Group_1__1__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14070: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:13952:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:13953:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14074:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14075:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:13953:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:13954:2: RULE_ID + // InternalBehaviorAnnexParser.g:14075:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14076:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQPREFAccess().getIDTerminalRuleCall_1_1()); @@ -46084,14 +46542,14 @@ public final void rule__QPREF__Group_1__1__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__0" - // InternalBehaviorAnnexParser.g:13964:1: rule__QCREF__Group__0 : rule__QCREF__Group__0__Impl rule__QCREF__Group__1 ; + // InternalBehaviorAnnexParser.g:14086: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:13968:1: ( rule__QCREF__Group__0__Impl rule__QCREF__Group__1 ) - // InternalBehaviorAnnexParser.g:13969:2: rule__QCREF__Group__0__Impl rule__QCREF__Group__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__QCREF__Group__0__Impl(); @@ -46122,41 +46580,41 @@ public final void rule__QCREF__Group__0() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__0__Impl" - // InternalBehaviorAnnexParser.g:13976:1: rule__QCREF__Group__0__Impl : ( ( rule__QCREF__Group_0__0 )* ) ; + // InternalBehaviorAnnexParser.g:14098: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:13980:1: ( ( ( rule__QCREF__Group_0__0 )* ) ) - // InternalBehaviorAnnexParser.g:13981:1: ( ( rule__QCREF__Group_0__0 )* ) + // InternalBehaviorAnnexParser.g:14102:1: ( ( ( rule__QCREF__Group_0__0 )* ) ) + // InternalBehaviorAnnexParser.g:14103:1: ( ( rule__QCREF__Group_0__0 )* ) { - // InternalBehaviorAnnexParser.g:13981:1: ( ( rule__QCREF__Group_0__0 )* ) - // InternalBehaviorAnnexParser.g:13982:2: ( rule__QCREF__Group_0__0 )* + // InternalBehaviorAnnexParser.g:14103:1: ( ( rule__QCREF__Group_0__0 )* ) + // InternalBehaviorAnnexParser.g:14104:2: ( rule__QCREF__Group_0__0 )* { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getGroup_0()); } - // InternalBehaviorAnnexParser.g:13983:2: ( rule__QCREF__Group_0__0 )* - loop118: + // InternalBehaviorAnnexParser.g:14105:2: ( rule__QCREF__Group_0__0 )* + loop120: do { - int alt118=2; - int LA118_0 = input.LA(1); + int alt120=2; + int LA120_0 = input.LA(1); - if ( (LA118_0==RULE_ID) ) { - int LA118_1 = input.LA(2); + if ( (LA120_0==RULE_ID) ) { + int LA120_1 = input.LA(2); - if ( (LA118_1==ColonColon) ) { - alt118=1; + if ( (LA120_1==ColonColon) ) { + alt120=1; } } - switch (alt118) { + switch (alt120) { case 1 : - // InternalBehaviorAnnexParser.g:13983:3: rule__QCREF__Group_0__0 + // InternalBehaviorAnnexParser.g:14105:3: rule__QCREF__Group_0__0 { pushFollow(FollowSets000.FOLLOW_5); rule__QCREF__Group_0__0(); @@ -46168,7 +46626,7 @@ public final void rule__QCREF__Group__0__Impl() throws RecognitionException { break; default : - break loop118; + break loop120; } } while (true); @@ -46197,16 +46655,16 @@ public final void rule__QCREF__Group__0__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__1" - // InternalBehaviorAnnexParser.g:13991:1: rule__QCREF__Group__1 : rule__QCREF__Group__1__Impl rule__QCREF__Group__2 ; + // InternalBehaviorAnnexParser.g:14113: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:13995:1: ( rule__QCREF__Group__1__Impl rule__QCREF__Group__2 ) - // InternalBehaviorAnnexParser.g:13996:2: rule__QCREF__Group__1__Impl rule__QCREF__Group__2 + // 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 { - pushFollow(FollowSets000.FOLLOW_86); + pushFollow(FollowSets000.FOLLOW_87); rule__QCREF__Group__1__Impl(); state._fsp--; @@ -46235,17 +46693,17 @@ public final void rule__QCREF__Group__1() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__1__Impl" - // InternalBehaviorAnnexParser.g:14003:1: rule__QCREF__Group__1__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14125:1: rule__QCREF__Group__1__Impl : ( RULE_ID ) ; public final void rule__QCREF__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14007:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14008:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14129:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14130:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14008:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14009:2: RULE_ID + // InternalBehaviorAnnexParser.g:14130:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14131:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getIDTerminalRuleCall_1()); @@ -46276,14 +46734,14 @@ public final void rule__QCREF__Group__1__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__2" - // InternalBehaviorAnnexParser.g:14018:1: rule__QCREF__Group__2 : rule__QCREF__Group__2__Impl ; + // InternalBehaviorAnnexParser.g:14140: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:14022:1: ( rule__QCREF__Group__2__Impl ) - // InternalBehaviorAnnexParser.g:14023:2: rule__QCREF__Group__2__Impl + // InternalBehaviorAnnexParser.g:14144:1: ( rule__QCREF__Group__2__Impl ) + // InternalBehaviorAnnexParser.g:14145:2: rule__QCREF__Group__2__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QCREF__Group__2__Impl(); @@ -46309,31 +46767,31 @@ public final void rule__QCREF__Group__2() throws RecognitionException { // $ANTLR start "rule__QCREF__Group__2__Impl" - // InternalBehaviorAnnexParser.g:14029:1: rule__QCREF__Group__2__Impl : ( ( rule__QCREF__Group_2__0 )? ) ; + // InternalBehaviorAnnexParser.g:14151: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:14033:1: ( ( ( rule__QCREF__Group_2__0 )? ) ) - // InternalBehaviorAnnexParser.g:14034:1: ( ( rule__QCREF__Group_2__0 )? ) + // InternalBehaviorAnnexParser.g:14155:1: ( ( ( rule__QCREF__Group_2__0 )? ) ) + // InternalBehaviorAnnexParser.g:14156:1: ( ( rule__QCREF__Group_2__0 )? ) { - // InternalBehaviorAnnexParser.g:14034:1: ( ( rule__QCREF__Group_2__0 )? ) - // InternalBehaviorAnnexParser.g:14035:2: ( rule__QCREF__Group_2__0 )? + // InternalBehaviorAnnexParser.g:14156:1: ( ( rule__QCREF__Group_2__0 )? ) + // InternalBehaviorAnnexParser.g:14157:2: ( rule__QCREF__Group_2__0 )? { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getGroup_2()); } - // InternalBehaviorAnnexParser.g:14036:2: ( rule__QCREF__Group_2__0 )? - int alt119=2; - int LA119_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:14158:2: ( rule__QCREF__Group_2__0 )? + int alt121=2; + int LA121_0 = input.LA(1); - if ( (LA119_0==FullStop) ) { - alt119=1; + if ( (LA121_0==FullStop) ) { + alt121=1; } - switch (alt119) { + switch (alt121) { case 1 : - // InternalBehaviorAnnexParser.g:14036:3: rule__QCREF__Group_2__0 + // InternalBehaviorAnnexParser.g:14158:3: rule__QCREF__Group_2__0 { pushFollow(FollowSets000.FOLLOW_2); rule__QCREF__Group_2__0(); @@ -46371,16 +46829,16 @@ public final void rule__QCREF__Group__2__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_0__0" - // InternalBehaviorAnnexParser.g:14045:1: rule__QCREF__Group_0__0 : rule__QCREF__Group_0__0__Impl rule__QCREF__Group_0__1 ; + // InternalBehaviorAnnexParser.g:14167: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:14049:1: ( rule__QCREF__Group_0__0__Impl rule__QCREF__Group_0__1 ) - // InternalBehaviorAnnexParser.g:14050:2: rule__QCREF__Group_0__0__Impl rule__QCREF__Group_0__1 + // 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 { - pushFollow(FollowSets000.FOLLOW_77); + pushFollow(FollowSets000.FOLLOW_78); rule__QCREF__Group_0__0__Impl(); state._fsp--; @@ -46409,17 +46867,17 @@ public final void rule__QCREF__Group_0__0() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_0__0__Impl" - // InternalBehaviorAnnexParser.g:14057:1: rule__QCREF__Group_0__0__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14179: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:14061:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14062:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14183:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14184:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14062:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14063:2: RULE_ID + // InternalBehaviorAnnexParser.g:14184:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14185:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getIDTerminalRuleCall_0_0()); @@ -46450,14 +46908,14 @@ public final void rule__QCREF__Group_0__0__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_0__1" - // InternalBehaviorAnnexParser.g:14072:1: rule__QCREF__Group_0__1 : rule__QCREF__Group_0__1__Impl ; + // InternalBehaviorAnnexParser.g:14194: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:14076:1: ( rule__QCREF__Group_0__1__Impl ) - // InternalBehaviorAnnexParser.g:14077:2: rule__QCREF__Group_0__1__Impl + // InternalBehaviorAnnexParser.g:14198:1: ( rule__QCREF__Group_0__1__Impl ) + // InternalBehaviorAnnexParser.g:14199:2: rule__QCREF__Group_0__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QCREF__Group_0__1__Impl(); @@ -46483,17 +46941,17 @@ public final void rule__QCREF__Group_0__1() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_0__1__Impl" - // InternalBehaviorAnnexParser.g:14083:1: rule__QCREF__Group_0__1__Impl : ( ColonColon ) ; + // InternalBehaviorAnnexParser.g:14205: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:14087:1: ( ( ColonColon ) ) - // InternalBehaviorAnnexParser.g:14088:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:14209:1: ( ( ColonColon ) ) + // InternalBehaviorAnnexParser.g:14210:1: ( ColonColon ) { - // InternalBehaviorAnnexParser.g:14088:1: ( ColonColon ) - // InternalBehaviorAnnexParser.g:14089:2: ColonColon + // InternalBehaviorAnnexParser.g:14210:1: ( ColonColon ) + // InternalBehaviorAnnexParser.g:14211:2: ColonColon { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getColonColonKeyword_0_1()); @@ -46524,14 +46982,14 @@ public final void rule__QCREF__Group_0__1__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_2__0" - // InternalBehaviorAnnexParser.g:14099:1: rule__QCREF__Group_2__0 : rule__QCREF__Group_2__0__Impl rule__QCREF__Group_2__1 ; + // InternalBehaviorAnnexParser.g:14221: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:14103:1: ( rule__QCREF__Group_2__0__Impl rule__QCREF__Group_2__1 ) - // InternalBehaviorAnnexParser.g:14104:2: rule__QCREF__Group_2__0__Impl rule__QCREF__Group_2__1 + // 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 { pushFollow(FollowSets000.FOLLOW_4); rule__QCREF__Group_2__0__Impl(); @@ -46562,17 +47020,17 @@ public final void rule__QCREF__Group_2__0() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_2__0__Impl" - // InternalBehaviorAnnexParser.g:14111:1: rule__QCREF__Group_2__0__Impl : ( FullStop ) ; + // InternalBehaviorAnnexParser.g:14233: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:14115:1: ( ( FullStop ) ) - // InternalBehaviorAnnexParser.g:14116:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:14237:1: ( ( FullStop ) ) + // InternalBehaviorAnnexParser.g:14238:1: ( FullStop ) { - // InternalBehaviorAnnexParser.g:14116:1: ( FullStop ) - // InternalBehaviorAnnexParser.g:14117:2: FullStop + // InternalBehaviorAnnexParser.g:14238:1: ( FullStop ) + // InternalBehaviorAnnexParser.g:14239:2: FullStop { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getFullStopKeyword_2_0()); @@ -46603,14 +47061,14 @@ public final void rule__QCREF__Group_2__0__Impl() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_2__1" - // InternalBehaviorAnnexParser.g:14126:1: rule__QCREF__Group_2__1 : rule__QCREF__Group_2__1__Impl ; + // InternalBehaviorAnnexParser.g:14248: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:14130:1: ( rule__QCREF__Group_2__1__Impl ) - // InternalBehaviorAnnexParser.g:14131:2: rule__QCREF__Group_2__1__Impl + // InternalBehaviorAnnexParser.g:14252:1: ( rule__QCREF__Group_2__1__Impl ) + // InternalBehaviorAnnexParser.g:14253:2: rule__QCREF__Group_2__1__Impl { pushFollow(FollowSets000.FOLLOW_2); rule__QCREF__Group_2__1__Impl(); @@ -46636,17 +47094,17 @@ public final void rule__QCREF__Group_2__1() throws RecognitionException { // $ANTLR start "rule__QCREF__Group_2__1__Impl" - // InternalBehaviorAnnexParser.g:14137:1: rule__QCREF__Group_2__1__Impl : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14259: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:14141:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14142:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14263:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14264:1: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14142:1: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14143:2: RULE_ID + // InternalBehaviorAnnexParser.g:14264:1: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14265:2: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getQCREFAccess().getIDTerminalRuleCall_2_1()); @@ -46677,17 +47135,17 @@ public final void rule__QCREF__Group_2__1__Impl() throws RecognitionException { // $ANTLR start "rule__BehaviorAnnex__VariableGroupsAssignment_1_1" - // InternalBehaviorAnnexParser.g:14153:1: rule__BehaviorAnnex__VariableGroupsAssignment_1_1 : ( ruleBehaviorVariableGroup ) ; + // InternalBehaviorAnnexParser.g:14275:1: rule__BehaviorAnnex__VariableGroupsAssignment_1_1 : ( ruleBehaviorVariableGroup ) ; public final void rule__BehaviorAnnex__VariableGroupsAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14157:1: ( ( ruleBehaviorVariableGroup ) ) - // InternalBehaviorAnnexParser.g:14158:2: ( ruleBehaviorVariableGroup ) + // InternalBehaviorAnnexParser.g:14279:1: ( ( ruleBehaviorVariableGroup ) ) + // InternalBehaviorAnnexParser.g:14280:2: ( ruleBehaviorVariableGroup ) { - // InternalBehaviorAnnexParser.g:14158:2: ( ruleBehaviorVariableGroup ) - // InternalBehaviorAnnexParser.g:14159:3: ruleBehaviorVariableGroup + // InternalBehaviorAnnexParser.g:14280:2: ( ruleBehaviorVariableGroup ) + // InternalBehaviorAnnexParser.g:14281:3: ruleBehaviorVariableGroup { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getVariableGroupsBehaviorVariableGroupParserRuleCall_1_1_0()); @@ -46722,17 +47180,17 @@ public final void rule__BehaviorAnnex__VariableGroupsAssignment_1_1() throws Rec // $ANTLR start "rule__BehaviorAnnex__StateGroupsAssignment_2_1" - // InternalBehaviorAnnexParser.g:14168:1: rule__BehaviorAnnex__StateGroupsAssignment_2_1 : ( ruleBehaviorStateGroup ) ; + // InternalBehaviorAnnexParser.g:14290:1: rule__BehaviorAnnex__StateGroupsAssignment_2_1 : ( ruleBehaviorStateGroup ) ; public final void rule__BehaviorAnnex__StateGroupsAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14172:1: ( ( ruleBehaviorStateGroup ) ) - // InternalBehaviorAnnexParser.g:14173:2: ( ruleBehaviorStateGroup ) + // InternalBehaviorAnnexParser.g:14294:1: ( ( ruleBehaviorStateGroup ) ) + // InternalBehaviorAnnexParser.g:14295:2: ( ruleBehaviorStateGroup ) { - // InternalBehaviorAnnexParser.g:14173:2: ( ruleBehaviorStateGroup ) - // InternalBehaviorAnnexParser.g:14174:3: ruleBehaviorStateGroup + // InternalBehaviorAnnexParser.g:14295:2: ( ruleBehaviorStateGroup ) + // InternalBehaviorAnnexParser.g:14296:3: ruleBehaviorStateGroup { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getStateGroupsBehaviorStateGroupParserRuleCall_2_1_0()); @@ -46767,17 +47225,17 @@ public final void rule__BehaviorAnnex__StateGroupsAssignment_2_1() throws Recogn // $ANTLR start "rule__BehaviorAnnex__TransitionsAssignment_3_1" - // InternalBehaviorAnnexParser.g:14183:1: rule__BehaviorAnnex__TransitionsAssignment_3_1 : ( ruleBehaviorTransition ) ; + // InternalBehaviorAnnexParser.g:14305:1: rule__BehaviorAnnex__TransitionsAssignment_3_1 : ( ruleBehaviorTransition ) ; public final void rule__BehaviorAnnex__TransitionsAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14187:1: ( ( ruleBehaviorTransition ) ) - // InternalBehaviorAnnexParser.g:14188:2: ( ruleBehaviorTransition ) + // InternalBehaviorAnnexParser.g:14309:1: ( ( ruleBehaviorTransition ) ) + // InternalBehaviorAnnexParser.g:14310:2: ( ruleBehaviorTransition ) { - // InternalBehaviorAnnexParser.g:14188:2: ( ruleBehaviorTransition ) - // InternalBehaviorAnnexParser.g:14189:3: ruleBehaviorTransition + // InternalBehaviorAnnexParser.g:14310:2: ( ruleBehaviorTransition ) + // InternalBehaviorAnnexParser.g:14311:3: ruleBehaviorTransition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorAnnexAccess().getTransitionsBehaviorTransitionParserRuleCall_3_1_0()); @@ -46812,17 +47270,17 @@ public final void rule__BehaviorAnnex__TransitionsAssignment_3_1() throws Recogn // $ANTLR start "rule__BehaviorVariableGroup__VariablesAssignment_0" - // InternalBehaviorAnnexParser.g:14198:1: rule__BehaviorVariableGroup__VariablesAssignment_0 : ( ruleBehaviorVariable ) ; + // InternalBehaviorAnnexParser.g:14320:1: rule__BehaviorVariableGroup__VariablesAssignment_0 : ( ruleBehaviorVariable ) ; public final void rule__BehaviorVariableGroup__VariablesAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14202:1: ( ( ruleBehaviorVariable ) ) - // InternalBehaviorAnnexParser.g:14203:2: ( ruleBehaviorVariable ) + // InternalBehaviorAnnexParser.g:14324:1: ( ( ruleBehaviorVariable ) ) + // InternalBehaviorAnnexParser.g:14325:2: ( ruleBehaviorVariable ) { - // InternalBehaviorAnnexParser.g:14203:2: ( ruleBehaviorVariable ) - // InternalBehaviorAnnexParser.g:14204:3: ruleBehaviorVariable + // InternalBehaviorAnnexParser.g:14325:2: ( ruleBehaviorVariable ) + // InternalBehaviorAnnexParser.g:14326:3: ruleBehaviorVariable { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getVariablesBehaviorVariableParserRuleCall_0_0()); @@ -46857,17 +47315,17 @@ public final void rule__BehaviorVariableGroup__VariablesAssignment_0() throws Re // $ANTLR start "rule__BehaviorVariableGroup__VariablesAssignment_1_1" - // InternalBehaviorAnnexParser.g:14213:1: rule__BehaviorVariableGroup__VariablesAssignment_1_1 : ( ruleBehaviorVariable ) ; + // InternalBehaviorAnnexParser.g:14335:1: rule__BehaviorVariableGroup__VariablesAssignment_1_1 : ( ruleBehaviorVariable ) ; public final void rule__BehaviorVariableGroup__VariablesAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14217:1: ( ( ruleBehaviorVariable ) ) - // InternalBehaviorAnnexParser.g:14218:2: ( ruleBehaviorVariable ) + // InternalBehaviorAnnexParser.g:14339:1: ( ( ruleBehaviorVariable ) ) + // InternalBehaviorAnnexParser.g:14340:2: ( ruleBehaviorVariable ) { - // InternalBehaviorAnnexParser.g:14218:2: ( ruleBehaviorVariable ) - // InternalBehaviorAnnexParser.g:14219:3: ruleBehaviorVariable + // InternalBehaviorAnnexParser.g:14340:2: ( ruleBehaviorVariable ) + // InternalBehaviorAnnexParser.g:14341:3: ruleBehaviorVariable { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getVariablesBehaviorVariableParserRuleCall_1_1_0()); @@ -46902,23 +47360,23 @@ public final void rule__BehaviorVariableGroup__VariablesAssignment_1_1() throws // $ANTLR start "rule__BehaviorVariableGroup__DataClassifierAssignment_3" - // InternalBehaviorAnnexParser.g:14228:1: rule__BehaviorVariableGroup__DataClassifierAssignment_3 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:14350:1: rule__BehaviorVariableGroup__DataClassifierAssignment_3 : ( ( ruleQCREF ) ) ; public final void rule__BehaviorVariableGroup__DataClassifierAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14232:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:14233:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:14354:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:14355:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:14233:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:14234:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:14355:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:14356:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getDataClassifierComponentClassifierCrossReference_3_0()); } - // InternalBehaviorAnnexParser.g:14235:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:14236:4: ruleQCREF + // InternalBehaviorAnnexParser.g:14357:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:14358:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_3_0_1()); @@ -46959,17 +47417,17 @@ public final void rule__BehaviorVariableGroup__DataClassifierAssignment_3() thro // $ANTLR start "rule__BehaviorVariableGroup__InitialValueAssignment_4_1" - // InternalBehaviorAnnexParser.g:14247:1: rule__BehaviorVariableGroup__InitialValueAssignment_4_1 : ( ruleValueConstant ) ; + // InternalBehaviorAnnexParser.g:14369:1: rule__BehaviorVariableGroup__InitialValueAssignment_4_1 : ( ruleValueConstant ) ; public final void rule__BehaviorVariableGroup__InitialValueAssignment_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14251:1: ( ( ruleValueConstant ) ) - // InternalBehaviorAnnexParser.g:14252:2: ( ruleValueConstant ) + // InternalBehaviorAnnexParser.g:14373:1: ( ( ruleValueConstant ) ) + // InternalBehaviorAnnexParser.g:14374:2: ( ruleValueConstant ) { - // InternalBehaviorAnnexParser.g:14252:2: ( ruleValueConstant ) - // InternalBehaviorAnnexParser.g:14253:3: ruleValueConstant + // InternalBehaviorAnnexParser.g:14374:2: ( ruleValueConstant ) + // InternalBehaviorAnnexParser.g:14375:3: ruleValueConstant { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getInitialValueValueConstantParserRuleCall_4_1_0()); @@ -47004,17 +47462,17 @@ public final void rule__BehaviorVariableGroup__InitialValueAssignment_4_1() thro // $ANTLR start "rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1" - // InternalBehaviorAnnexParser.g:14262:1: rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 : ( ruleBehaviorPropertyAssociation ) ; + // InternalBehaviorAnnexParser.g:14384:1: rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1 : ( ruleBehaviorPropertyAssociation ) ; public final void rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14266:1: ( ( ruleBehaviorPropertyAssociation ) ) - // InternalBehaviorAnnexParser.g:14267:2: ( ruleBehaviorPropertyAssociation ) + // InternalBehaviorAnnexParser.g:14388:1: ( ( ruleBehaviorPropertyAssociation ) ) + // InternalBehaviorAnnexParser.g:14389:2: ( ruleBehaviorPropertyAssociation ) { - // InternalBehaviorAnnexParser.g:14267:2: ( ruleBehaviorPropertyAssociation ) - // InternalBehaviorAnnexParser.g:14268:3: ruleBehaviorPropertyAssociation + // InternalBehaviorAnnexParser.g:14389:2: ( ruleBehaviorPropertyAssociation ) + // InternalBehaviorAnnexParser.g:14390:3: ruleBehaviorPropertyAssociation { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableGroupAccess().getPropertyAssociationsBehaviorPropertyAssociationParserRuleCall_5_1_0()); @@ -47049,17 +47507,17 @@ public final void rule__BehaviorVariableGroup__PropertyAssociationsAssignment_5_ // $ANTLR start "rule__BehaviorVariable__NameAssignment_0" - // InternalBehaviorAnnexParser.g:14277:1: rule__BehaviorVariable__NameAssignment_0 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14399:1: rule__BehaviorVariable__NameAssignment_0 : ( RULE_ID ) ; public final void rule__BehaviorVariable__NameAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14281:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14282:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14403:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14404:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14282:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14283:3: RULE_ID + // InternalBehaviorAnnexParser.g:14404:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14405:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableAccess().getNameIDTerminalRuleCall_0_0()); @@ -47090,17 +47548,17 @@ public final void rule__BehaviorVariable__NameAssignment_0() throws RecognitionE // $ANTLR start "rule__BehaviorVariable__ArrayDimensionsAssignment_1" - // InternalBehaviorAnnexParser.g:14292:1: rule__BehaviorVariable__ArrayDimensionsAssignment_1 : ( ruleArrayDimension ) ; + // InternalBehaviorAnnexParser.g:14414:1: rule__BehaviorVariable__ArrayDimensionsAssignment_1 : ( ruleArrayDimension ) ; public final void rule__BehaviorVariable__ArrayDimensionsAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14296:1: ( ( ruleArrayDimension ) ) - // InternalBehaviorAnnexParser.g:14297:2: ( ruleArrayDimension ) + // InternalBehaviorAnnexParser.g:14418:1: ( ( ruleArrayDimension ) ) + // InternalBehaviorAnnexParser.g:14419:2: ( ruleArrayDimension ) { - // InternalBehaviorAnnexParser.g:14297:2: ( ruleArrayDimension ) - // InternalBehaviorAnnexParser.g:14298:3: ruleArrayDimension + // InternalBehaviorAnnexParser.g:14419:2: ( ruleArrayDimension ) + // InternalBehaviorAnnexParser.g:14420:3: ruleArrayDimension { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorVariableAccess().getArrayDimensionsArrayDimensionParserRuleCall_1_0()); @@ -47135,17 +47593,17 @@ public final void rule__BehaviorVariable__ArrayDimensionsAssignment_1() throws R // $ANTLR start "rule__ArrayDimension__SizeAssignment_1" - // InternalBehaviorAnnexParser.g:14307:1: rule__ArrayDimension__SizeAssignment_1 : ( ruleIntegerValue ) ; + // InternalBehaviorAnnexParser.g:14429:1: rule__ArrayDimension__SizeAssignment_1 : ( ruleIntegerValue ) ; public final void rule__ArrayDimension__SizeAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14311:1: ( ( ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:14312:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:14433:1: ( ( ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:14434:2: ( ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:14312:2: ( ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:14313:3: ruleIntegerValue + // InternalBehaviorAnnexParser.g:14434:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:14435:3: ruleIntegerValue { if ( state.backtracking==0 ) { before(grammarAccess.getArrayDimensionAccess().getSizeIntegerValueParserRuleCall_1_0()); @@ -47180,23 +47638,23 @@ public final void rule__ArrayDimension__SizeAssignment_1() throws RecognitionExc // $ANTLR start "rule__BehaviorPropertyAssociation__PropertyAssignment_0" - // InternalBehaviorAnnexParser.g:14322:1: rule__BehaviorPropertyAssociation__PropertyAssignment_0 : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:14444:1: rule__BehaviorPropertyAssociation__PropertyAssignment_0 : ( ( ruleQPREF ) ) ; public final void rule__BehaviorPropertyAssociation__PropertyAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14326:1: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:14327:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:14448:1: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:14449:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:14327:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:14328:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:14449:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:14450:3: ( ruleQPREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorPropertyAssociationAccess().getPropertyPropertyCrossReference_0_0()); } - // InternalBehaviorAnnexParser.g:14329:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:14330:4: ruleQPREF + // InternalBehaviorAnnexParser.g:14451:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:14452:4: ruleQPREF { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorPropertyAssociationAccess().getPropertyPropertyQPREFParserRuleCall_0_0_1()); @@ -47237,17 +47695,17 @@ public final void rule__BehaviorPropertyAssociation__PropertyAssignment_0() thro // $ANTLR start "rule__BehaviorPropertyAssociation__OwnedValueAssignment_2" - // InternalBehaviorAnnexParser.g:14341:1: rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:14463:1: rule__BehaviorPropertyAssociation__OwnedValueAssignment_2 : ( rulePropertyExpression ) ; public final void rule__BehaviorPropertyAssociation__OwnedValueAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14345:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:14346:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:14467:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:14468:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:14346:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:14347:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:14468:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:14469:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorPropertyAssociationAccess().getOwnedValuePropertyExpressionParserRuleCall_2_0()); @@ -47282,17 +47740,17 @@ public final void rule__BehaviorPropertyAssociation__OwnedValueAssignment_2() th // $ANTLR start "rule__BehaviorStateGroup__StatesAssignment_0" - // InternalBehaviorAnnexParser.g:14356:1: rule__BehaviorStateGroup__StatesAssignment_0 : ( ruleBehaviorState ) ; + // InternalBehaviorAnnexParser.g:14478:1: rule__BehaviorStateGroup__StatesAssignment_0 : ( ruleBehaviorState ) ; public final void rule__BehaviorStateGroup__StatesAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14360:1: ( ( ruleBehaviorState ) ) - // InternalBehaviorAnnexParser.g:14361:2: ( ruleBehaviorState ) + // InternalBehaviorAnnexParser.g:14482:1: ( ( ruleBehaviorState ) ) + // InternalBehaviorAnnexParser.g:14483:2: ( ruleBehaviorState ) { - // InternalBehaviorAnnexParser.g:14361:2: ( ruleBehaviorState ) - // InternalBehaviorAnnexParser.g:14362:3: ruleBehaviorState + // InternalBehaviorAnnexParser.g:14483:2: ( ruleBehaviorState ) + // InternalBehaviorAnnexParser.g:14484:3: ruleBehaviorState { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getStatesBehaviorStateParserRuleCall_0_0()); @@ -47327,17 +47785,17 @@ public final void rule__BehaviorStateGroup__StatesAssignment_0() throws Recognit // $ANTLR start "rule__BehaviorStateGroup__StatesAssignment_1_1" - // InternalBehaviorAnnexParser.g:14371:1: rule__BehaviorStateGroup__StatesAssignment_1_1 : ( ruleBehaviorState ) ; + // InternalBehaviorAnnexParser.g:14493:1: rule__BehaviorStateGroup__StatesAssignment_1_1 : ( ruleBehaviorState ) ; public final void rule__BehaviorStateGroup__StatesAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14375:1: ( ( ruleBehaviorState ) ) - // InternalBehaviorAnnexParser.g:14376:2: ( ruleBehaviorState ) + // InternalBehaviorAnnexParser.g:14497:1: ( ( ruleBehaviorState ) ) + // InternalBehaviorAnnexParser.g:14498:2: ( ruleBehaviorState ) { - // InternalBehaviorAnnexParser.g:14376:2: ( ruleBehaviorState ) - // InternalBehaviorAnnexParser.g:14377:3: ruleBehaviorState + // InternalBehaviorAnnexParser.g:14498:2: ( ruleBehaviorState ) + // InternalBehaviorAnnexParser.g:14499:3: ruleBehaviorState { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getStatesBehaviorStateParserRuleCall_1_1_0()); @@ -47372,23 +47830,23 @@ public final void rule__BehaviorStateGroup__StatesAssignment_1_1() throws Recogn // $ANTLR start "rule__BehaviorStateGroup__InitialAssignment_3" - // InternalBehaviorAnnexParser.g:14386:1: rule__BehaviorStateGroup__InitialAssignment_3 : ( ( Initial ) ) ; + // InternalBehaviorAnnexParser.g:14508:1: rule__BehaviorStateGroup__InitialAssignment_3 : ( ( Initial ) ) ; public final void rule__BehaviorStateGroup__InitialAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14390:1: ( ( ( Initial ) ) ) - // InternalBehaviorAnnexParser.g:14391:2: ( ( Initial ) ) + // InternalBehaviorAnnexParser.g:14512:1: ( ( ( Initial ) ) ) + // InternalBehaviorAnnexParser.g:14513:2: ( ( Initial ) ) { - // InternalBehaviorAnnexParser.g:14391:2: ( ( Initial ) ) - // InternalBehaviorAnnexParser.g:14392:3: ( Initial ) + // InternalBehaviorAnnexParser.g:14513:2: ( ( Initial ) ) + // InternalBehaviorAnnexParser.g:14514:3: ( Initial ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getInitialInitialKeyword_3_0()); } - // InternalBehaviorAnnexParser.g:14393:3: ( Initial ) - // InternalBehaviorAnnexParser.g:14394:4: Initial + // InternalBehaviorAnnexParser.g:14515:3: ( Initial ) + // InternalBehaviorAnnexParser.g:14516:4: Initial { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getInitialInitialKeyword_3_0()); @@ -47425,23 +47883,23 @@ public final void rule__BehaviorStateGroup__InitialAssignment_3() throws Recogni // $ANTLR start "rule__BehaviorStateGroup__CompleteAssignment_4" - // InternalBehaviorAnnexParser.g:14405:1: rule__BehaviorStateGroup__CompleteAssignment_4 : ( ( Complete ) ) ; + // InternalBehaviorAnnexParser.g:14527:1: rule__BehaviorStateGroup__CompleteAssignment_4 : ( ( Complete ) ) ; public final void rule__BehaviorStateGroup__CompleteAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14409:1: ( ( ( Complete ) ) ) - // InternalBehaviorAnnexParser.g:14410:2: ( ( Complete ) ) + // InternalBehaviorAnnexParser.g:14531:1: ( ( ( Complete ) ) ) + // InternalBehaviorAnnexParser.g:14532:2: ( ( Complete ) ) { - // InternalBehaviorAnnexParser.g:14410:2: ( ( Complete ) ) - // InternalBehaviorAnnexParser.g:14411:3: ( Complete ) + // InternalBehaviorAnnexParser.g:14532:2: ( ( Complete ) ) + // InternalBehaviorAnnexParser.g:14533:3: ( Complete ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getCompleteCompleteKeyword_4_0()); } - // InternalBehaviorAnnexParser.g:14412:3: ( Complete ) - // InternalBehaviorAnnexParser.g:14413:4: Complete + // InternalBehaviorAnnexParser.g:14534:3: ( Complete ) + // InternalBehaviorAnnexParser.g:14535:4: Complete { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getCompleteCompleteKeyword_4_0()); @@ -47478,23 +47936,23 @@ public final void rule__BehaviorStateGroup__CompleteAssignment_4() throws Recogn // $ANTLR start "rule__BehaviorStateGroup__FinalAssignment_5" - // InternalBehaviorAnnexParser.g:14424:1: rule__BehaviorStateGroup__FinalAssignment_5 : ( ( Final ) ) ; + // InternalBehaviorAnnexParser.g:14546:1: rule__BehaviorStateGroup__FinalAssignment_5 : ( ( Final ) ) ; public final void rule__BehaviorStateGroup__FinalAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14428:1: ( ( ( Final ) ) ) - // InternalBehaviorAnnexParser.g:14429:2: ( ( Final ) ) + // InternalBehaviorAnnexParser.g:14550:1: ( ( ( Final ) ) ) + // InternalBehaviorAnnexParser.g:14551:2: ( ( Final ) ) { - // InternalBehaviorAnnexParser.g:14429:2: ( ( Final ) ) - // InternalBehaviorAnnexParser.g:14430:3: ( Final ) + // InternalBehaviorAnnexParser.g:14551:2: ( ( Final ) ) + // InternalBehaviorAnnexParser.g:14552:3: ( Final ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getFinalFinalKeyword_5_0()); } - // InternalBehaviorAnnexParser.g:14431:3: ( Final ) - // InternalBehaviorAnnexParser.g:14432:4: Final + // InternalBehaviorAnnexParser.g:14553:3: ( Final ) + // InternalBehaviorAnnexParser.g:14554:4: Final { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateGroupAccess().getFinalFinalKeyword_5_0()); @@ -47531,17 +47989,17 @@ public final void rule__BehaviorStateGroup__FinalAssignment_5() throws Recogniti // $ANTLR start "rule__BehaviorState__NameAssignment" - // InternalBehaviorAnnexParser.g:14443:1: rule__BehaviorState__NameAssignment : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14565:1: rule__BehaviorState__NameAssignment : ( RULE_ID ) ; public final void rule__BehaviorState__NameAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14447:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14448:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14569:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14570:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14448:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14449:3: RULE_ID + // InternalBehaviorAnnexParser.g:14570:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14571:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStateAccess().getNameIDTerminalRuleCall_0()); @@ -47572,17 +48030,17 @@ public final void rule__BehaviorState__NameAssignment() throws RecognitionExcept // $ANTLR start "rule__BehaviorTransition__NameAssignment_0_0" - // InternalBehaviorAnnexParser.g:14458:1: rule__BehaviorTransition__NameAssignment_0_0 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:14580:1: rule__BehaviorTransition__NameAssignment_0_0 : ( RULE_ID ) ; public final void rule__BehaviorTransition__NameAssignment_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14462:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14463:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14584:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14585:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:14463:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14464:3: RULE_ID + // InternalBehaviorAnnexParser.g:14585:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14586:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getNameIDTerminalRuleCall_0_0_0()); @@ -47613,17 +48071,17 @@ public final void rule__BehaviorTransition__NameAssignment_0_0() throws Recognit // $ANTLR start "rule__BehaviorTransition__PriorityAssignment_0_1_1" - // InternalBehaviorAnnexParser.g:14473:1: rule__BehaviorTransition__PriorityAssignment_0_1_1 : ( RULE_INTEGER_LIT ) ; + // InternalBehaviorAnnexParser.g:14595: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:14477:1: ( ( RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:14478:2: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:14599:1: ( ( RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:14600:2: ( RULE_INTEGER_LIT ) { - // InternalBehaviorAnnexParser.g:14478:2: ( RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:14479:3: RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:14600:2: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:14601:3: RULE_INTEGER_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getPriorityINTEGER_LITTerminalRuleCall_0_1_1_0()); @@ -47654,23 +48112,23 @@ public final void rule__BehaviorTransition__PriorityAssignment_0_1_1() throws Re // $ANTLR start "rule__BehaviorTransition__SourceStatesAssignment_1" - // InternalBehaviorAnnexParser.g:14488:1: rule__BehaviorTransition__SourceStatesAssignment_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:14610:1: rule__BehaviorTransition__SourceStatesAssignment_1 : ( ( RULE_ID ) ) ; public final void rule__BehaviorTransition__SourceStatesAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14492:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:14493:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14614:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:14615:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:14493:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14494:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14615:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14616:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSourceStatesBehaviorStateCrossReference_1_0()); } - // InternalBehaviorAnnexParser.g:14495:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14496:4: RULE_ID + // InternalBehaviorAnnexParser.g:14617:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14618:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSourceStatesBehaviorStateIDTerminalRuleCall_1_0_1()); @@ -47707,23 +48165,23 @@ public final void rule__BehaviorTransition__SourceStatesAssignment_1() throws Re // $ANTLR start "rule__BehaviorTransition__SourceStatesAssignment_2_1" - // InternalBehaviorAnnexParser.g:14507:1: rule__BehaviorTransition__SourceStatesAssignment_2_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:14629:1: rule__BehaviorTransition__SourceStatesAssignment_2_1 : ( ( RULE_ID ) ) ; public final void rule__BehaviorTransition__SourceStatesAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14511:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:14512:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14633:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:14634:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:14512:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14513:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14634:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14635:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSourceStatesBehaviorStateCrossReference_2_1_0()); } - // InternalBehaviorAnnexParser.g:14514:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14515:4: RULE_ID + // InternalBehaviorAnnexParser.g:14636:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14637:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getSourceStatesBehaviorStateIDTerminalRuleCall_2_1_0_1()); @@ -47760,17 +48218,17 @@ public final void rule__BehaviorTransition__SourceStatesAssignment_2_1() throws // $ANTLR start "rule__BehaviorTransition__ConditionAssignment_4" - // InternalBehaviorAnnexParser.g:14526:1: rule__BehaviorTransition__ConditionAssignment_4 : ( ruleBehaviorCondition ) ; + // InternalBehaviorAnnexParser.g:14648:1: rule__BehaviorTransition__ConditionAssignment_4 : ( ruleBehaviorCondition ) ; public final void rule__BehaviorTransition__ConditionAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14530:1: ( ( ruleBehaviorCondition ) ) - // InternalBehaviorAnnexParser.g:14531:2: ( ruleBehaviorCondition ) + // InternalBehaviorAnnexParser.g:14652:1: ( ( ruleBehaviorCondition ) ) + // InternalBehaviorAnnexParser.g:14653:2: ( ruleBehaviorCondition ) { - // InternalBehaviorAnnexParser.g:14531:2: ( ruleBehaviorCondition ) - // InternalBehaviorAnnexParser.g:14532:3: ruleBehaviorCondition + // InternalBehaviorAnnexParser.g:14653:2: ( ruleBehaviorCondition ) + // InternalBehaviorAnnexParser.g:14654:3: ruleBehaviorCondition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getConditionBehaviorConditionParserRuleCall_4_0()); @@ -47805,23 +48263,23 @@ public final void rule__BehaviorTransition__ConditionAssignment_4() throws Recog // $ANTLR start "rule__BehaviorTransition__DestinationStateAssignment_6" - // InternalBehaviorAnnexParser.g:14541:1: rule__BehaviorTransition__DestinationStateAssignment_6 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:14663:1: rule__BehaviorTransition__DestinationStateAssignment_6 : ( ( RULE_ID ) ) ; public final void rule__BehaviorTransition__DestinationStateAssignment_6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14545:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:14546:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14667:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:14668:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:14546:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:14547:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14668:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:14669:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getDestinationStateBehaviorStateCrossReference_6_0()); } - // InternalBehaviorAnnexParser.g:14548:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:14549:4: RULE_ID + // InternalBehaviorAnnexParser.g:14670:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:14671:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getDestinationStateBehaviorStateIDTerminalRuleCall_6_0_1()); @@ -47858,17 +48316,17 @@ public final void rule__BehaviorTransition__DestinationStateAssignment_6() throw // $ANTLR start "rule__BehaviorTransition__ActionBlockAssignment_7" - // InternalBehaviorAnnexParser.g:14560:1: rule__BehaviorTransition__ActionBlockAssignment_7 : ( ruleBehaviorActionBlock ) ; + // InternalBehaviorAnnexParser.g:14682:1: rule__BehaviorTransition__ActionBlockAssignment_7 : ( ruleBehaviorActionBlock ) ; public final void rule__BehaviorTransition__ActionBlockAssignment_7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14564:1: ( ( ruleBehaviorActionBlock ) ) - // InternalBehaviorAnnexParser.g:14565:2: ( ruleBehaviorActionBlock ) + // InternalBehaviorAnnexParser.g:14686:1: ( ( ruleBehaviorActionBlock ) ) + // InternalBehaviorAnnexParser.g:14687:2: ( ruleBehaviorActionBlock ) { - // InternalBehaviorAnnexParser.g:14565:2: ( ruleBehaviorActionBlock ) - // InternalBehaviorAnnexParser.g:14566:3: ruleBehaviorActionBlock + // InternalBehaviorAnnexParser.g:14687:2: ( ruleBehaviorActionBlock ) + // InternalBehaviorAnnexParser.g:14688:3: ruleBehaviorActionBlock { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTransitionAccess().getActionBlockBehaviorActionBlockParserRuleCall_7_0()); @@ -47903,17 +48361,17 @@ public final void rule__BehaviorTransition__ActionBlockAssignment_7() throws Rec // $ANTLR start "rule__BehaviorCondition__DispatchAssignment_0_1_0" - // InternalBehaviorAnnexParser.g:14575:1: rule__BehaviorCondition__DispatchAssignment_0_1_0 : ( ruleDispatchCondition ) ; + // InternalBehaviorAnnexParser.g:14697: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:14579:1: ( ( ruleDispatchCondition ) ) - // InternalBehaviorAnnexParser.g:14580:2: ( ruleDispatchCondition ) + // InternalBehaviorAnnexParser.g:14701:1: ( ( ruleDispatchCondition ) ) + // InternalBehaviorAnnexParser.g:14702:2: ( ruleDispatchCondition ) { - // InternalBehaviorAnnexParser.g:14580:2: ( ruleDispatchCondition ) - // InternalBehaviorAnnexParser.g:14581:3: ruleDispatchCondition + // InternalBehaviorAnnexParser.g:14702:2: ( ruleDispatchCondition ) + // InternalBehaviorAnnexParser.g:14703:3: ruleDispatchCondition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getDispatchDispatchConditionParserRuleCall_0_1_0_0()); @@ -47948,17 +48406,17 @@ public final void rule__BehaviorCondition__DispatchAssignment_0_1_0() throws Rec // $ANTLR start "rule__BehaviorCondition__InternalAssignment_0_1_1" - // InternalBehaviorAnnexParser.g:14590:1: rule__BehaviorCondition__InternalAssignment_0_1_1 : ( ruleInternalCondition ) ; + // InternalBehaviorAnnexParser.g:14712: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:14594:1: ( ( ruleInternalCondition ) ) - // InternalBehaviorAnnexParser.g:14595:2: ( ruleInternalCondition ) + // InternalBehaviorAnnexParser.g:14716:1: ( ( ruleInternalCondition ) ) + // InternalBehaviorAnnexParser.g:14717:2: ( ruleInternalCondition ) { - // InternalBehaviorAnnexParser.g:14595:2: ( ruleInternalCondition ) - // InternalBehaviorAnnexParser.g:14596:3: ruleInternalCondition + // InternalBehaviorAnnexParser.g:14717:2: ( ruleInternalCondition ) + // InternalBehaviorAnnexParser.g:14718:3: ruleInternalCondition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getInternalInternalConditionParserRuleCall_0_1_1_0()); @@ -47993,17 +48451,17 @@ public final void rule__BehaviorCondition__InternalAssignment_0_1_1() throws Rec // $ANTLR start "rule__BehaviorCondition__ModeSwitchAssignment_0_1_2" - // InternalBehaviorAnnexParser.g:14605:1: rule__BehaviorCondition__ModeSwitchAssignment_0_1_2 : ( ruleModeSwitchCondition ) ; + // InternalBehaviorAnnexParser.g:14727: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:14609:1: ( ( ruleModeSwitchCondition ) ) - // InternalBehaviorAnnexParser.g:14610:2: ( ruleModeSwitchCondition ) + // InternalBehaviorAnnexParser.g:14731:1: ( ( ruleModeSwitchCondition ) ) + // InternalBehaviorAnnexParser.g:14732:2: ( ruleModeSwitchCondition ) { - // InternalBehaviorAnnexParser.g:14610:2: ( ruleModeSwitchCondition ) - // InternalBehaviorAnnexParser.g:14611:3: ruleModeSwitchCondition + // InternalBehaviorAnnexParser.g:14732:2: ( ruleModeSwitchCondition ) + // InternalBehaviorAnnexParser.g:14733:3: ruleModeSwitchCondition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getModeSwitchModeSwitchConditionParserRuleCall_0_1_2_0()); @@ -48038,17 +48496,17 @@ public final void rule__BehaviorCondition__ModeSwitchAssignment_0_1_2() throws R // $ANTLR start "rule__BehaviorCondition__ExecuteAssignment_1" - // InternalBehaviorAnnexParser.g:14620:1: rule__BehaviorCondition__ExecuteAssignment_1 : ( ruleExecuteCondition ) ; + // InternalBehaviorAnnexParser.g:14742:1: rule__BehaviorCondition__ExecuteAssignment_1 : ( ruleExecuteCondition ) ; public final void rule__BehaviorCondition__ExecuteAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14624:1: ( ( ruleExecuteCondition ) ) - // InternalBehaviorAnnexParser.g:14625:2: ( ruleExecuteCondition ) + // InternalBehaviorAnnexParser.g:14746:1: ( ( ruleExecuteCondition ) ) + // InternalBehaviorAnnexParser.g:14747:2: ( ruleExecuteCondition ) { - // InternalBehaviorAnnexParser.g:14625:2: ( ruleExecuteCondition ) - // InternalBehaviorAnnexParser.g:14626:3: ruleExecuteCondition + // InternalBehaviorAnnexParser.g:14747:2: ( ruleExecuteCondition ) + // InternalBehaviorAnnexParser.g:14748:3: ruleExecuteCondition { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorConditionAccess().getExecuteExecuteConditionParserRuleCall_1_0()); @@ -48083,17 +48541,17 @@ public final void rule__BehaviorCondition__ExecuteAssignment_1() throws Recognit // $ANTLR start "rule__ExecuteCondition__ValueAssignment_0" - // InternalBehaviorAnnexParser.g:14635:1: rule__ExecuteCondition__ValueAssignment_0 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:14757:1: rule__ExecuteCondition__ValueAssignment_0 : ( ruleValueExpression ) ; public final void rule__ExecuteCondition__ValueAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14639:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:14640:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:14761:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:14762:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:14640:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:14641:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:14762:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:14763:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getValueValueExpressionParserRuleCall_0_0()); @@ -48128,23 +48586,23 @@ public final void rule__ExecuteCondition__ValueAssignment_0() throws Recognition // $ANTLR start "rule__ExecuteCondition__TimeoutAssignment_1" - // InternalBehaviorAnnexParser.g:14650:1: rule__ExecuteCondition__TimeoutAssignment_1 : ( ( Timeout ) ) ; + // InternalBehaviorAnnexParser.g:14772:1: rule__ExecuteCondition__TimeoutAssignment_1 : ( ( Timeout ) ) ; public final void rule__ExecuteCondition__TimeoutAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14654:1: ( ( ( Timeout ) ) ) - // InternalBehaviorAnnexParser.g:14655:2: ( ( Timeout ) ) + // InternalBehaviorAnnexParser.g:14776:1: ( ( ( Timeout ) ) ) + // InternalBehaviorAnnexParser.g:14777:2: ( ( Timeout ) ) { - // InternalBehaviorAnnexParser.g:14655:2: ( ( Timeout ) ) - // InternalBehaviorAnnexParser.g:14656:3: ( Timeout ) + // InternalBehaviorAnnexParser.g:14777:2: ( ( Timeout ) ) + // InternalBehaviorAnnexParser.g:14778:3: ( Timeout ) { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getTimeoutTimeoutKeyword_1_0()); } - // InternalBehaviorAnnexParser.g:14657:3: ( Timeout ) - // InternalBehaviorAnnexParser.g:14658:4: Timeout + // InternalBehaviorAnnexParser.g:14779:3: ( Timeout ) + // InternalBehaviorAnnexParser.g:14780:4: Timeout { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getTimeoutTimeoutKeyword_1_0()); @@ -48181,23 +48639,23 @@ public final void rule__ExecuteCondition__TimeoutAssignment_1() throws Recogniti // $ANTLR start "rule__ExecuteCondition__OtherwiseAssignment_2" - // InternalBehaviorAnnexParser.g:14669:1: rule__ExecuteCondition__OtherwiseAssignment_2 : ( ( Otherwise ) ) ; + // InternalBehaviorAnnexParser.g:14791:1: rule__ExecuteCondition__OtherwiseAssignment_2 : ( ( Otherwise ) ) ; public final void rule__ExecuteCondition__OtherwiseAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14673:1: ( ( ( Otherwise ) ) ) - // InternalBehaviorAnnexParser.g:14674:2: ( ( Otherwise ) ) + // InternalBehaviorAnnexParser.g:14795:1: ( ( ( Otherwise ) ) ) + // InternalBehaviorAnnexParser.g:14796:2: ( ( Otherwise ) ) { - // InternalBehaviorAnnexParser.g:14674:2: ( ( Otherwise ) ) - // InternalBehaviorAnnexParser.g:14675:3: ( Otherwise ) + // InternalBehaviorAnnexParser.g:14796:2: ( ( Otherwise ) ) + // InternalBehaviorAnnexParser.g:14797:3: ( Otherwise ) { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getOtherwiseOtherwiseKeyword_2_0()); } - // InternalBehaviorAnnexParser.g:14676:3: ( Otherwise ) - // InternalBehaviorAnnexParser.g:14677:4: Otherwise + // InternalBehaviorAnnexParser.g:14798:3: ( Otherwise ) + // InternalBehaviorAnnexParser.g:14799:4: Otherwise { if ( state.backtracking==0 ) { before(grammarAccess.getExecuteConditionAccess().getOtherwiseOtherwiseKeyword_2_0()); @@ -48234,17 +48692,17 @@ public final void rule__ExecuteCondition__OtherwiseAssignment_2() throws Recogni // $ANTLR start "rule__DispatchCondition__TriggerAssignment_2" - // InternalBehaviorAnnexParser.g:14688:1: rule__DispatchCondition__TriggerAssignment_2 : ( ruleDispatchTriggerCondition ) ; + // InternalBehaviorAnnexParser.g:14810:1: rule__DispatchCondition__TriggerAssignment_2 : ( ruleDispatchTriggerCondition ) ; public final void rule__DispatchCondition__TriggerAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14692:1: ( ( ruleDispatchTriggerCondition ) ) - // InternalBehaviorAnnexParser.g:14693:2: ( ruleDispatchTriggerCondition ) + // InternalBehaviorAnnexParser.g:14814:1: ( ( ruleDispatchTriggerCondition ) ) + // InternalBehaviorAnnexParser.g:14815:2: ( ruleDispatchTriggerCondition ) { - // InternalBehaviorAnnexParser.g:14693:2: ( ruleDispatchTriggerCondition ) - // InternalBehaviorAnnexParser.g:14694:3: ruleDispatchTriggerCondition + // InternalBehaviorAnnexParser.g:14815:2: ( ruleDispatchTriggerCondition ) + // InternalBehaviorAnnexParser.g:14816:3: ruleDispatchTriggerCondition { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getTriggerDispatchTriggerConditionParserRuleCall_2_0()); @@ -48279,17 +48737,17 @@ public final void rule__DispatchCondition__TriggerAssignment_2() throws Recognit // $ANTLR start "rule__DispatchCondition__FrozenPortsAssignment_3_2" - // InternalBehaviorAnnexParser.g:14703:1: rule__DispatchCondition__FrozenPortsAssignment_3_2 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:14825:1: rule__DispatchCondition__FrozenPortsAssignment_3_2 : ( ruleReference ) ; public final void rule__DispatchCondition__FrozenPortsAssignment_3_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14707:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14708:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14829:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:14830:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14708:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14709:3: ruleReference + // InternalBehaviorAnnexParser.g:14830:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14831:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getFrozenPortsReferenceParserRuleCall_3_2_0()); @@ -48324,17 +48782,17 @@ public final void rule__DispatchCondition__FrozenPortsAssignment_3_2() throws Re // $ANTLR start "rule__DispatchCondition__FrozenPortsAssignment_3_3_1" - // InternalBehaviorAnnexParser.g:14718:1: rule__DispatchCondition__FrozenPortsAssignment_3_3_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:14840: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:14722:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14723:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14844:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:14845:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14723:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14724:3: ruleReference + // InternalBehaviorAnnexParser.g:14845:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14846:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConditionAccess().getFrozenPortsReferenceParserRuleCall_3_3_1_0()); @@ -48369,17 +48827,17 @@ public final void rule__DispatchCondition__FrozenPortsAssignment_3_3_1() throws // $ANTLR start "rule__DispatchTriggerCondition__ExpressionAssignment_0" - // InternalBehaviorAnnexParser.g:14733:1: rule__DispatchTriggerCondition__ExpressionAssignment_0 : ( ruleDispatchTriggerLogicalExpression ) ; + // InternalBehaviorAnnexParser.g:14855:1: rule__DispatchTriggerCondition__ExpressionAssignment_0 : ( ruleDispatchTriggerLogicalExpression ) ; public final void rule__DispatchTriggerCondition__ExpressionAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14737:1: ( ( ruleDispatchTriggerLogicalExpression ) ) - // InternalBehaviorAnnexParser.g:14738:2: ( ruleDispatchTriggerLogicalExpression ) + // InternalBehaviorAnnexParser.g:14859:1: ( ( ruleDispatchTriggerLogicalExpression ) ) + // InternalBehaviorAnnexParser.g:14860:2: ( ruleDispatchTriggerLogicalExpression ) { - // InternalBehaviorAnnexParser.g:14738:2: ( ruleDispatchTriggerLogicalExpression ) - // InternalBehaviorAnnexParser.g:14739:3: ruleDispatchTriggerLogicalExpression + // InternalBehaviorAnnexParser.g:14860:2: ( ruleDispatchTriggerLogicalExpression ) + // InternalBehaviorAnnexParser.g:14861:3: ruleDispatchTriggerLogicalExpression { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getExpressionDispatchTriggerLogicalExpressionParserRuleCall_0_0()); @@ -48414,23 +48872,23 @@ public final void rule__DispatchTriggerCondition__ExpressionAssignment_0() throw // $ANTLR start "rule__DispatchTriggerCondition__TimeoutAssignment_1_0" - // InternalBehaviorAnnexParser.g:14748:1: rule__DispatchTriggerCondition__TimeoutAssignment_1_0 : ( ( Timeout ) ) ; + // InternalBehaviorAnnexParser.g:14870:1: rule__DispatchTriggerCondition__TimeoutAssignment_1_0 : ( ( Timeout ) ) ; public final void rule__DispatchTriggerCondition__TimeoutAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14752:1: ( ( ( Timeout ) ) ) - // InternalBehaviorAnnexParser.g:14753:2: ( ( Timeout ) ) + // InternalBehaviorAnnexParser.g:14874:1: ( ( ( Timeout ) ) ) + // InternalBehaviorAnnexParser.g:14875:2: ( ( Timeout ) ) { - // InternalBehaviorAnnexParser.g:14753:2: ( ( Timeout ) ) - // InternalBehaviorAnnexParser.g:14754:3: ( Timeout ) + // InternalBehaviorAnnexParser.g:14875:2: ( ( Timeout ) ) + // InternalBehaviorAnnexParser.g:14876:3: ( Timeout ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getTimeoutTimeoutKeyword_1_0_0()); } - // InternalBehaviorAnnexParser.g:14755:3: ( Timeout ) - // InternalBehaviorAnnexParser.g:14756:4: Timeout + // InternalBehaviorAnnexParser.g:14877:3: ( Timeout ) + // InternalBehaviorAnnexParser.g:14878:4: Timeout { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getTimeoutTimeoutKeyword_1_0_0()); @@ -48467,17 +48925,17 @@ public final void rule__DispatchTriggerCondition__TimeoutAssignment_1_0() throws // $ANTLR start "rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1" - // InternalBehaviorAnnexParser.g:14767:1: rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:14889: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:14771:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14772:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14893:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:14894:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14772:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14773:3: ruleReference + // InternalBehaviorAnnexParser.g:14894:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14895:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getResetPortsReferenceParserRuleCall_1_1_1_0()); @@ -48512,17 +48970,17 @@ public final void rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_1() t // $ANTLR start "rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1" - // InternalBehaviorAnnexParser.g:14782:1: rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:14904: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:14786:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14787:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14908:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:14909:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14787:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14788:3: ruleReference + // InternalBehaviorAnnexParser.g:14909:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14910:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getResetPortsReferenceParserRuleCall_1_1_2_1_0()); @@ -48557,17 +49015,17 @@ public final void rule__DispatchTriggerCondition__ResetPortsAssignment_1_1_2_1() // $ANTLR start "rule__DispatchTriggerCondition__TimeAssignment_1_2" - // InternalBehaviorAnnexParser.g:14797:1: rule__DispatchTriggerCondition__TimeAssignment_1_2 : ( ruleBehaviorTime ) ; + // InternalBehaviorAnnexParser.g:14919:1: rule__DispatchTriggerCondition__TimeAssignment_1_2 : ( ruleBehaviorTime ) ; public final void rule__DispatchTriggerCondition__TimeAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14801:1: ( ( ruleBehaviorTime ) ) - // InternalBehaviorAnnexParser.g:14802:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:14923:1: ( ( ruleBehaviorTime ) ) + // InternalBehaviorAnnexParser.g:14924:2: ( ruleBehaviorTime ) { - // InternalBehaviorAnnexParser.g:14802:2: ( ruleBehaviorTime ) - // InternalBehaviorAnnexParser.g:14803:3: ruleBehaviorTime + // InternalBehaviorAnnexParser.g:14924:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:14925:3: ruleBehaviorTime { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getTimeBehaviorTimeParserRuleCall_1_2_0()); @@ -48602,23 +49060,23 @@ public final void rule__DispatchTriggerCondition__TimeAssignment_1_2() throws Re // $ANTLR start "rule__DispatchTriggerCondition__StopAssignment_2" - // InternalBehaviorAnnexParser.g:14812:1: rule__DispatchTriggerCondition__StopAssignment_2 : ( ( Stop ) ) ; + // InternalBehaviorAnnexParser.g:14934:1: rule__DispatchTriggerCondition__StopAssignment_2 : ( ( Stop ) ) ; public final void rule__DispatchTriggerCondition__StopAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14816:1: ( ( ( Stop ) ) ) - // InternalBehaviorAnnexParser.g:14817:2: ( ( Stop ) ) + // InternalBehaviorAnnexParser.g:14938:1: ( ( ( Stop ) ) ) + // InternalBehaviorAnnexParser.g:14939:2: ( ( Stop ) ) { - // InternalBehaviorAnnexParser.g:14817:2: ( ( Stop ) ) - // InternalBehaviorAnnexParser.g:14818:3: ( Stop ) + // InternalBehaviorAnnexParser.g:14939:2: ( ( Stop ) ) + // InternalBehaviorAnnexParser.g:14940:3: ( Stop ) { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getStopStopKeyword_2_0()); } - // InternalBehaviorAnnexParser.g:14819:3: ( Stop ) - // InternalBehaviorAnnexParser.g:14820:4: Stop + // InternalBehaviorAnnexParser.g:14941:3: ( Stop ) + // InternalBehaviorAnnexParser.g:14942:4: Stop { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerConditionAccess().getStopStopKeyword_2_0()); @@ -48655,17 +49113,17 @@ public final void rule__DispatchTriggerCondition__StopAssignment_2() throws Reco // $ANTLR start "rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0" - // InternalBehaviorAnnexParser.g:14831:1: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 : ( ruleDispatchConjunction ) ; + // InternalBehaviorAnnexParser.g:14953:1: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0 : ( ruleDispatchConjunction ) ; public final void rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14835:1: ( ( ruleDispatchConjunction ) ) - // InternalBehaviorAnnexParser.g:14836:2: ( ruleDispatchConjunction ) + // InternalBehaviorAnnexParser.g:14957:1: ( ( ruleDispatchConjunction ) ) + // InternalBehaviorAnnexParser.g:14958:2: ( ruleDispatchConjunction ) { - // InternalBehaviorAnnexParser.g:14836:2: ( ruleDispatchConjunction ) - // InternalBehaviorAnnexParser.g:14837:3: ruleDispatchConjunction + // InternalBehaviorAnnexParser.g:14958:2: ( ruleDispatchConjunction ) + // InternalBehaviorAnnexParser.g:14959:3: ruleDispatchConjunction { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerLogicalExpressionAccess().getConjunctionsDispatchConjunctionParserRuleCall_0_0()); @@ -48700,17 +49158,17 @@ public final void rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment // $ANTLR start "rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1" - // InternalBehaviorAnnexParser.g:14846:1: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 : ( ruleDispatchConjunction ) ; + // InternalBehaviorAnnexParser.g:14968:1: rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1 : ( ruleDispatchConjunction ) ; public final void rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14850:1: ( ( ruleDispatchConjunction ) ) - // InternalBehaviorAnnexParser.g:14851:2: ( ruleDispatchConjunction ) + // InternalBehaviorAnnexParser.g:14972:1: ( ( ruleDispatchConjunction ) ) + // InternalBehaviorAnnexParser.g:14973:2: ( ruleDispatchConjunction ) { - // InternalBehaviorAnnexParser.g:14851:2: ( ruleDispatchConjunction ) - // InternalBehaviorAnnexParser.g:14852:3: ruleDispatchConjunction + // InternalBehaviorAnnexParser.g:14973:2: ( ruleDispatchConjunction ) + // InternalBehaviorAnnexParser.g:14974:3: ruleDispatchConjunction { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchTriggerLogicalExpressionAccess().getConjunctionsDispatchConjunctionParserRuleCall_1_1_0()); @@ -48745,17 +49203,17 @@ public final void rule__DispatchTriggerLogicalExpression__ConjunctionsAssignment // $ANTLR start "rule__DispatchConjunction__TriggersAssignment_0" - // InternalBehaviorAnnexParser.g:14861:1: rule__DispatchConjunction__TriggersAssignment_0 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:14983:1: rule__DispatchConjunction__TriggersAssignment_0 : ( ruleReference ) ; public final void rule__DispatchConjunction__TriggersAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14865:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14866:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14987:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:14988:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14866:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14867:3: ruleReference + // InternalBehaviorAnnexParser.g:14988:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:14989:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConjunctionAccess().getTriggersReferenceParserRuleCall_0_0()); @@ -48790,17 +49248,17 @@ public final void rule__DispatchConjunction__TriggersAssignment_0() throws Recog // $ANTLR start "rule__DispatchConjunction__TriggersAssignment_1_1" - // InternalBehaviorAnnexParser.g:14876:1: rule__DispatchConjunction__TriggersAssignment_1_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:14998:1: rule__DispatchConjunction__TriggersAssignment_1_1 : ( ruleReference ) ; public final void rule__DispatchConjunction__TriggersAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14880:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14881:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15002:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15003:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14881:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14882:3: ruleReference + // InternalBehaviorAnnexParser.g:15003:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15004:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getDispatchConjunctionAccess().getTriggersReferenceParserRuleCall_1_1_0()); @@ -48835,17 +49293,17 @@ public final void rule__DispatchConjunction__TriggersAssignment_1_1() throws Rec // $ANTLR start "rule__ModeSwitchCondition__ConjunctionsAssignment_0" - // InternalBehaviorAnnexParser.g:14891:1: rule__ModeSwitchCondition__ConjunctionsAssignment_0 : ( ruleModeSwitchConjunction ) ; + // InternalBehaviorAnnexParser.g:15013:1: rule__ModeSwitchCondition__ConjunctionsAssignment_0 : ( ruleModeSwitchConjunction ) ; public final void rule__ModeSwitchCondition__ConjunctionsAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14895:1: ( ( ruleModeSwitchConjunction ) ) - // InternalBehaviorAnnexParser.g:14896:2: ( ruleModeSwitchConjunction ) + // InternalBehaviorAnnexParser.g:15017:1: ( ( ruleModeSwitchConjunction ) ) + // InternalBehaviorAnnexParser.g:15018:2: ( ruleModeSwitchConjunction ) { - // InternalBehaviorAnnexParser.g:14896:2: ( ruleModeSwitchConjunction ) - // InternalBehaviorAnnexParser.g:14897:3: ruleModeSwitchConjunction + // InternalBehaviorAnnexParser.g:15018:2: ( ruleModeSwitchConjunction ) + // InternalBehaviorAnnexParser.g:15019:3: ruleModeSwitchConjunction { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConditionAccess().getConjunctionsModeSwitchConjunctionParserRuleCall_0_0()); @@ -48880,17 +49338,17 @@ public final void rule__ModeSwitchCondition__ConjunctionsAssignment_0() throws R // $ANTLR start "rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0" - // InternalBehaviorAnnexParser.g:14906:1: rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 : ( ruleLogicalOrOperator ) ; + // InternalBehaviorAnnexParser.g:15028:1: rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0 : ( ruleLogicalOrOperator ) ; public final void rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14910:1: ( ( ruleLogicalOrOperator ) ) - // InternalBehaviorAnnexParser.g:14911:2: ( ruleLogicalOrOperator ) + // InternalBehaviorAnnexParser.g:15032:1: ( ( ruleLogicalOrOperator ) ) + // InternalBehaviorAnnexParser.g:15033:2: ( ruleLogicalOrOperator ) { - // InternalBehaviorAnnexParser.g:14911:2: ( ruleLogicalOrOperator ) - // InternalBehaviorAnnexParser.g:14912:3: ruleLogicalOrOperator + // InternalBehaviorAnnexParser.g:15033:2: ( ruleLogicalOrOperator ) + // InternalBehaviorAnnexParser.g:15034:3: ruleLogicalOrOperator { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConditionAccess().getLogicalOperatorsLogicalOrOperatorParserRuleCall_1_0_0()); @@ -48925,17 +49383,17 @@ public final void rule__ModeSwitchCondition__LogicalOperatorsAssignment_1_0() th // $ANTLR start "rule__ModeSwitchCondition__ConjunctionsAssignment_1_1" - // InternalBehaviorAnnexParser.g:14921:1: rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 : ( ruleModeSwitchConjunction ) ; + // InternalBehaviorAnnexParser.g:15043:1: rule__ModeSwitchCondition__ConjunctionsAssignment_1_1 : ( ruleModeSwitchConjunction ) ; public final void rule__ModeSwitchCondition__ConjunctionsAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14925:1: ( ( ruleModeSwitchConjunction ) ) - // InternalBehaviorAnnexParser.g:14926:2: ( ruleModeSwitchConjunction ) + // InternalBehaviorAnnexParser.g:15047:1: ( ( ruleModeSwitchConjunction ) ) + // InternalBehaviorAnnexParser.g:15048:2: ( ruleModeSwitchConjunction ) { - // InternalBehaviorAnnexParser.g:14926:2: ( ruleModeSwitchConjunction ) - // InternalBehaviorAnnexParser.g:14927:3: ruleModeSwitchConjunction + // InternalBehaviorAnnexParser.g:15048:2: ( ruleModeSwitchConjunction ) + // InternalBehaviorAnnexParser.g:15049:3: ruleModeSwitchConjunction { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConditionAccess().getConjunctionsModeSwitchConjunctionParserRuleCall_1_1_0()); @@ -48970,17 +49428,17 @@ public final void rule__ModeSwitchCondition__ConjunctionsAssignment_1_1() throws // $ANTLR start "rule__ModeSwitchConjunction__TriggersAssignment_0" - // InternalBehaviorAnnexParser.g:14936:1: rule__ModeSwitchConjunction__TriggersAssignment_0 : ( ruleModeSwitchTrigger ) ; + // InternalBehaviorAnnexParser.g:15058:1: rule__ModeSwitchConjunction__TriggersAssignment_0 : ( ruleModeSwitchTrigger ) ; public final void rule__ModeSwitchConjunction__TriggersAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14940:1: ( ( ruleModeSwitchTrigger ) ) - // InternalBehaviorAnnexParser.g:14941:2: ( ruleModeSwitchTrigger ) + // InternalBehaviorAnnexParser.g:15062:1: ( ( ruleModeSwitchTrigger ) ) + // InternalBehaviorAnnexParser.g:15063:2: ( ruleModeSwitchTrigger ) { - // InternalBehaviorAnnexParser.g:14941:2: ( ruleModeSwitchTrigger ) - // InternalBehaviorAnnexParser.g:14942:3: ruleModeSwitchTrigger + // InternalBehaviorAnnexParser.g:15063:2: ( ruleModeSwitchTrigger ) + // InternalBehaviorAnnexParser.g:15064:3: ruleModeSwitchTrigger { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConjunctionAccess().getTriggersModeSwitchTriggerParserRuleCall_0_0()); @@ -49015,17 +49473,17 @@ public final void rule__ModeSwitchConjunction__TriggersAssignment_0() throws Rec // $ANTLR start "rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0" - // InternalBehaviorAnnexParser.g:14951:1: rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 : ( ruleLogicalAndOperator ) ; + // InternalBehaviorAnnexParser.g:15073:1: rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0 : ( ruleLogicalAndOperator ) ; public final void rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14955:1: ( ( ruleLogicalAndOperator ) ) - // InternalBehaviorAnnexParser.g:14956:2: ( ruleLogicalAndOperator ) + // InternalBehaviorAnnexParser.g:15077:1: ( ( ruleLogicalAndOperator ) ) + // InternalBehaviorAnnexParser.g:15078:2: ( ruleLogicalAndOperator ) { - // InternalBehaviorAnnexParser.g:14956:2: ( ruleLogicalAndOperator ) - // InternalBehaviorAnnexParser.g:14957:3: ruleLogicalAndOperator + // InternalBehaviorAnnexParser.g:15078:2: ( ruleLogicalAndOperator ) + // InternalBehaviorAnnexParser.g:15079:3: ruleLogicalAndOperator { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConjunctionAccess().getLogicalOperatorsLogicalAndOperatorParserRuleCall_1_0_0()); @@ -49060,17 +49518,17 @@ public final void rule__ModeSwitchConjunction__LogicalOperatorsAssignment_1_0() // $ANTLR start "rule__ModeSwitchConjunction__TriggersAssignment_1_1" - // InternalBehaviorAnnexParser.g:14966:1: rule__ModeSwitchConjunction__TriggersAssignment_1_1 : ( ruleModeSwitchTrigger ) ; + // InternalBehaviorAnnexParser.g:15088:1: rule__ModeSwitchConjunction__TriggersAssignment_1_1 : ( ruleModeSwitchTrigger ) ; public final void rule__ModeSwitchConjunction__TriggersAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14970:1: ( ( ruleModeSwitchTrigger ) ) - // InternalBehaviorAnnexParser.g:14971:2: ( ruleModeSwitchTrigger ) + // InternalBehaviorAnnexParser.g:15092:1: ( ( ruleModeSwitchTrigger ) ) + // InternalBehaviorAnnexParser.g:15093:2: ( ruleModeSwitchTrigger ) { - // InternalBehaviorAnnexParser.g:14971:2: ( ruleModeSwitchTrigger ) - // InternalBehaviorAnnexParser.g:14972:3: ruleModeSwitchTrigger + // InternalBehaviorAnnexParser.g:15093:2: ( ruleModeSwitchTrigger ) + // InternalBehaviorAnnexParser.g:15094:3: ruleModeSwitchTrigger { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchConjunctionAccess().getTriggersModeSwitchTriggerParserRuleCall_1_1_0()); @@ -49105,17 +49563,17 @@ public final void rule__ModeSwitchConjunction__TriggersAssignment_1_1() throws R // $ANTLR start "rule__ModeSwitchTrigger__ReferenceAssignment_0" - // InternalBehaviorAnnexParser.g:14981:1: rule__ModeSwitchTrigger__ReferenceAssignment_0 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15103:1: rule__ModeSwitchTrigger__ReferenceAssignment_0 : ( ruleReference ) ; public final void rule__ModeSwitchTrigger__ReferenceAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:14985:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:14986:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15107:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15108:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:14986:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:14987:3: ruleReference + // InternalBehaviorAnnexParser.g:15108:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15109:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchTriggerAccess().getReferenceReferenceParserRuleCall_0_0()); @@ -49150,17 +49608,17 @@ public final void rule__ModeSwitchTrigger__ReferenceAssignment_0() throws Recogn // $ANTLR start "rule__ModeSwitchTrigger__ExpressionAssignment_1_1" - // InternalBehaviorAnnexParser.g:14996:1: rule__ModeSwitchTrigger__ExpressionAssignment_1_1 : ( ruleModeSwitchCondition ) ; + // InternalBehaviorAnnexParser.g:15118:1: rule__ModeSwitchTrigger__ExpressionAssignment_1_1 : ( ruleModeSwitchCondition ) ; public final void rule__ModeSwitchTrigger__ExpressionAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15000:1: ( ( ruleModeSwitchCondition ) ) - // InternalBehaviorAnnexParser.g:15001:2: ( ruleModeSwitchCondition ) + // InternalBehaviorAnnexParser.g:15122:1: ( ( ruleModeSwitchCondition ) ) + // InternalBehaviorAnnexParser.g:15123:2: ( ruleModeSwitchCondition ) { - // InternalBehaviorAnnexParser.g:15001:2: ( ruleModeSwitchCondition ) - // InternalBehaviorAnnexParser.g:15002:3: ruleModeSwitchCondition + // InternalBehaviorAnnexParser.g:15123:2: ( ruleModeSwitchCondition ) + // InternalBehaviorAnnexParser.g:15124:3: ruleModeSwitchCondition { if ( state.backtracking==0 ) { before(grammarAccess.getModeSwitchTriggerAccess().getExpressionModeSwitchConditionParserRuleCall_1_1_0()); @@ -49195,17 +49653,17 @@ public final void rule__ModeSwitchTrigger__ExpressionAssignment_1_1() throws Rec // $ANTLR start "rule__InternalCondition__InternalPortsAssignment_1" - // InternalBehaviorAnnexParser.g:15011:1: rule__InternalCondition__InternalPortsAssignment_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15133:1: rule__InternalCondition__InternalPortsAssignment_1 : ( ruleReference ) ; public final void rule__InternalCondition__InternalPortsAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15015:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15016:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15137:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15138:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15016:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15017:3: ruleReference + // InternalBehaviorAnnexParser.g:15138:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15139:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getInternalConditionAccess().getInternalPortsReferenceParserRuleCall_1_0()); @@ -49240,17 +49698,17 @@ public final void rule__InternalCondition__InternalPortsAssignment_1() throws Re // $ANTLR start "rule__InternalCondition__InternalPortsAssignment_2_1" - // InternalBehaviorAnnexParser.g:15026:1: rule__InternalCondition__InternalPortsAssignment_2_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15148:1: rule__InternalCondition__InternalPortsAssignment_2_1 : ( ruleReference ) ; public final void rule__InternalCondition__InternalPortsAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15030:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15031:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15152:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15153:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15031:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15032:3: ruleReference + // InternalBehaviorAnnexParser.g:15153:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15154:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getInternalConditionAccess().getInternalPortsReferenceParserRuleCall_2_1_0()); @@ -49285,17 +49743,17 @@ public final void rule__InternalCondition__InternalPortsAssignment_2_1() throws // $ANTLR start "rule__BehaviorActionBlock__ContentAssignment_1" - // InternalBehaviorAnnexParser.g:15041:1: rule__BehaviorActionBlock__ContentAssignment_1 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15163:1: rule__BehaviorActionBlock__ContentAssignment_1 : ( ruleBehaviorActions ) ; public final void rule__BehaviorActionBlock__ContentAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15045:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15046:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15167:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15168:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15046:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15047:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15168:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15169:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionBlockAccess().getContentBehaviorActionsParserRuleCall_1_0()); @@ -49330,17 +49788,17 @@ public final void rule__BehaviorActionBlock__ContentAssignment_1() throws Recogn // $ANTLR start "rule__BehaviorActionBlock__TimeoutAssignment_3_1" - // InternalBehaviorAnnexParser.g:15056:1: rule__BehaviorActionBlock__TimeoutAssignment_3_1 : ( ruleBehaviorTime ) ; + // InternalBehaviorAnnexParser.g:15178:1: rule__BehaviorActionBlock__TimeoutAssignment_3_1 : ( ruleBehaviorTime ) ; public final void rule__BehaviorActionBlock__TimeoutAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15060:1: ( ( ruleBehaviorTime ) ) - // InternalBehaviorAnnexParser.g:15061:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15182:1: ( ( ruleBehaviorTime ) ) + // InternalBehaviorAnnexParser.g:15183:2: ( ruleBehaviorTime ) { - // InternalBehaviorAnnexParser.g:15061:2: ( ruleBehaviorTime ) - // InternalBehaviorAnnexParser.g:15062:3: ruleBehaviorTime + // InternalBehaviorAnnexParser.g:15183:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15184:3: ruleBehaviorTime { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionBlockAccess().getTimeoutBehaviorTimeParserRuleCall_3_1_0()); @@ -49375,17 +49833,17 @@ public final void rule__BehaviorActionBlock__TimeoutAssignment_3_1() throws Reco // $ANTLR start "rule__BehaviorActions__ActionsAssignment_1_0_2" - // InternalBehaviorAnnexParser.g:15071:1: rule__BehaviorActions__ActionsAssignment_1_0_2 : ( ruleBehaviorAction ) ; + // InternalBehaviorAnnexParser.g:15193: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:15075:1: ( ( ruleBehaviorAction ) ) - // InternalBehaviorAnnexParser.g:15076:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15197:1: ( ( ruleBehaviorAction ) ) + // InternalBehaviorAnnexParser.g:15198:2: ( ruleBehaviorAction ) { - // InternalBehaviorAnnexParser.g:15076:2: ( ruleBehaviorAction ) - // InternalBehaviorAnnexParser.g:15077:3: ruleBehaviorAction + // InternalBehaviorAnnexParser.g:15198:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15199:3: ruleBehaviorAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsBehaviorActionParserRuleCall_1_0_2_0()); @@ -49420,17 +49878,17 @@ public final void rule__BehaviorActions__ActionsAssignment_1_0_2() throws Recogn // $ANTLR start "rule__BehaviorActions__ActionsAssignment_1_0_3_1" - // InternalBehaviorAnnexParser.g:15086:1: rule__BehaviorActions__ActionsAssignment_1_0_3_1 : ( ruleBehaviorAction ) ; + // InternalBehaviorAnnexParser.g:15208: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:15090:1: ( ( ruleBehaviorAction ) ) - // InternalBehaviorAnnexParser.g:15091:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15212:1: ( ( ruleBehaviorAction ) ) + // InternalBehaviorAnnexParser.g:15213:2: ( ruleBehaviorAction ) { - // InternalBehaviorAnnexParser.g:15091:2: ( ruleBehaviorAction ) - // InternalBehaviorAnnexParser.g:15092:3: ruleBehaviorAction + // InternalBehaviorAnnexParser.g:15213:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15214:3: ruleBehaviorAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsBehaviorActionParserRuleCall_1_0_3_1_0()); @@ -49465,17 +49923,17 @@ public final void rule__BehaviorActions__ActionsAssignment_1_0_3_1() throws Reco // $ANTLR start "rule__BehaviorActions__ActionsAssignment_1_1_2" - // InternalBehaviorAnnexParser.g:15101:1: rule__BehaviorActions__ActionsAssignment_1_1_2 : ( ruleBehaviorAction ) ; + // InternalBehaviorAnnexParser.g:15223: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:15105:1: ( ( ruleBehaviorAction ) ) - // InternalBehaviorAnnexParser.g:15106:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15227:1: ( ( ruleBehaviorAction ) ) + // InternalBehaviorAnnexParser.g:15228:2: ( ruleBehaviorAction ) { - // InternalBehaviorAnnexParser.g:15106:2: ( ruleBehaviorAction ) - // InternalBehaviorAnnexParser.g:15107:3: ruleBehaviorAction + // InternalBehaviorAnnexParser.g:15228:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15229:3: ruleBehaviorAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsBehaviorActionParserRuleCall_1_1_2_0()); @@ -49510,17 +49968,17 @@ public final void rule__BehaviorActions__ActionsAssignment_1_1_2() throws Recogn // $ANTLR start "rule__BehaviorActions__ActionsAssignment_1_1_3_1" - // InternalBehaviorAnnexParser.g:15116:1: rule__BehaviorActions__ActionsAssignment_1_1_3_1 : ( ruleBehaviorAction ) ; + // InternalBehaviorAnnexParser.g:15238: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:15120:1: ( ( ruleBehaviorAction ) ) - // InternalBehaviorAnnexParser.g:15121:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15242:1: ( ( ruleBehaviorAction ) ) + // InternalBehaviorAnnexParser.g:15243:2: ( ruleBehaviorAction ) { - // InternalBehaviorAnnexParser.g:15121:2: ( ruleBehaviorAction ) - // InternalBehaviorAnnexParser.g:15122:3: ruleBehaviorAction + // InternalBehaviorAnnexParser.g:15243:2: ( ruleBehaviorAction ) + // InternalBehaviorAnnexParser.g:15244:3: ruleBehaviorAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionsAccess().getActionsBehaviorActionParserRuleCall_1_1_3_1_0()); @@ -49555,17 +50013,17 @@ public final void rule__BehaviorActions__ActionsAssignment_1_1_3_1() throws Reco // $ANTLR start "rule__AssignmentAction__TargetAssignment_0" - // InternalBehaviorAnnexParser.g:15131:1: rule__AssignmentAction__TargetAssignment_0 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15253:1: rule__AssignmentAction__TargetAssignment_0 : ( ruleReference ) ; public final void rule__AssignmentAction__TargetAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15135:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15136:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15257:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15258:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15136:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15137:3: ruleReference + // InternalBehaviorAnnexParser.g:15258:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15259:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getTargetReferenceParserRuleCall_0_0()); @@ -49600,17 +50058,17 @@ public final void rule__AssignmentAction__TargetAssignment_0() throws Recognitio // $ANTLR start "rule__AssignmentAction__ValueAssignment_2_0" - // InternalBehaviorAnnexParser.g:15146:1: rule__AssignmentAction__ValueAssignment_2_0 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15268:1: rule__AssignmentAction__ValueAssignment_2_0 : ( ruleValueExpression ) ; public final void rule__AssignmentAction__ValueAssignment_2_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15150:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15151:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15272:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15273:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15151:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15152:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15273:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15274:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getValueValueExpressionParserRuleCall_2_0_0()); @@ -49645,23 +50103,23 @@ public final void rule__AssignmentAction__ValueAssignment_2_0() throws Recogniti // $ANTLR start "rule__AssignmentAction__AnyAssignment_2_1" - // InternalBehaviorAnnexParser.g:15161:1: rule__AssignmentAction__AnyAssignment_2_1 : ( ( Any ) ) ; + // InternalBehaviorAnnexParser.g:15283:1: rule__AssignmentAction__AnyAssignment_2_1 : ( ( Any ) ) ; public final void rule__AssignmentAction__AnyAssignment_2_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15165:1: ( ( ( Any ) ) ) - // InternalBehaviorAnnexParser.g:15166:2: ( ( Any ) ) + // InternalBehaviorAnnexParser.g:15287:1: ( ( ( Any ) ) ) + // InternalBehaviorAnnexParser.g:15288:2: ( ( Any ) ) { - // InternalBehaviorAnnexParser.g:15166:2: ( ( Any ) ) - // InternalBehaviorAnnexParser.g:15167:3: ( Any ) + // InternalBehaviorAnnexParser.g:15288:2: ( ( Any ) ) + // InternalBehaviorAnnexParser.g:15289:3: ( Any ) { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getAnyAnyKeyword_2_1_0()); } - // InternalBehaviorAnnexParser.g:15168:3: ( Any ) - // InternalBehaviorAnnexParser.g:15169:4: Any + // InternalBehaviorAnnexParser.g:15290:3: ( Any ) + // InternalBehaviorAnnexParser.g:15291:4: Any { if ( state.backtracking==0 ) { before(grammarAccess.getAssignmentActionAccess().getAnyAnyKeyword_2_1_0()); @@ -49698,17 +50156,17 @@ public final void rule__AssignmentAction__AnyAssignment_2_1() throws Recognition // $ANTLR start "rule__CommunicationAction__ReferenceAssignment_0_0" - // InternalBehaviorAnnexParser.g:15180:1: rule__CommunicationAction__ReferenceAssignment_0_0 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15302:1: rule__CommunicationAction__ReferenceAssignment_0_0 : ( ruleReference ) ; public final void rule__CommunicationAction__ReferenceAssignment_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15184:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15185:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15306:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15307:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15185:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15186:3: ruleReference + // InternalBehaviorAnnexParser.g:15307:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15308:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getReferenceReferenceParserRuleCall_0_0_0()); @@ -49743,23 +50201,23 @@ public final void rule__CommunicationAction__ReferenceAssignment_0_0() throws Re // $ANTLR start "rule__CommunicationAction__SendAssignment_0_1_0_0" - // InternalBehaviorAnnexParser.g:15195:1: rule__CommunicationAction__SendAssignment_0_1_0_0 : ( ( ExclamationMark ) ) ; + // InternalBehaviorAnnexParser.g:15317: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:15199:1: ( ( ( ExclamationMark ) ) ) - // InternalBehaviorAnnexParser.g:15200:2: ( ( ExclamationMark ) ) + // InternalBehaviorAnnexParser.g:15321:1: ( ( ( ExclamationMark ) ) ) + // InternalBehaviorAnnexParser.g:15322:2: ( ( ExclamationMark ) ) { - // InternalBehaviorAnnexParser.g:15200:2: ( ( ExclamationMark ) ) - // InternalBehaviorAnnexParser.g:15201:3: ( ExclamationMark ) + // InternalBehaviorAnnexParser.g:15322:2: ( ( ExclamationMark ) ) + // InternalBehaviorAnnexParser.g:15323:3: ( ExclamationMark ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getSendExclamationMarkKeyword_0_1_0_0_0()); } - // InternalBehaviorAnnexParser.g:15202:3: ( ExclamationMark ) - // InternalBehaviorAnnexParser.g:15203:4: ExclamationMark + // InternalBehaviorAnnexParser.g:15324:3: ( ExclamationMark ) + // InternalBehaviorAnnexParser.g:15325:4: ExclamationMark { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getSendExclamationMarkKeyword_0_1_0_0_0()); @@ -49796,17 +50254,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:15214:1: rule__CommunicationAction__ParametersAssignment_0_1_0_1_1 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15336: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:15218:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15219:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15340:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15341:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15219:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15220:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15341:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15342:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getParametersValueExpressionParserRuleCall_0_1_0_1_1_0()); @@ -49841,17 +50299,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:15229:1: rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15351: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:15233:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15234:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15355:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15356:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15234:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15235:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15356:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15357:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getParametersValueExpressionParserRuleCall_0_1_0_1_2_1_0()); @@ -49886,23 +50344,23 @@ public final void rule__CommunicationAction__ParametersAssignment_0_1_0_1_2_1() // $ANTLR start "rule__CommunicationAction__DequeueAssignment_0_1_1_0" - // InternalBehaviorAnnexParser.g:15244:1: rule__CommunicationAction__DequeueAssignment_0_1_1_0 : ( ( QuestionMark ) ) ; + // InternalBehaviorAnnexParser.g:15366: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:15248:1: ( ( ( QuestionMark ) ) ) - // InternalBehaviorAnnexParser.g:15249:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:15370:1: ( ( ( QuestionMark ) ) ) + // InternalBehaviorAnnexParser.g:15371:2: ( ( QuestionMark ) ) { - // InternalBehaviorAnnexParser.g:15249:2: ( ( QuestionMark ) ) - // InternalBehaviorAnnexParser.g:15250:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:15371:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:15372:3: ( QuestionMark ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getDequeueQuestionMarkKeyword_0_1_1_0_0()); } - // InternalBehaviorAnnexParser.g:15251:3: ( QuestionMark ) - // InternalBehaviorAnnexParser.g:15252:4: QuestionMark + // InternalBehaviorAnnexParser.g:15373:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:15374:4: QuestionMark { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getDequeueQuestionMarkKeyword_0_1_1_0_0()); @@ -49939,17 +50397,17 @@ public final void rule__CommunicationAction__DequeueAssignment_0_1_1_0() throws // $ANTLR start "rule__CommunicationAction__TargetAssignment_0_1_1_1_1" - // InternalBehaviorAnnexParser.g:15263:1: rule__CommunicationAction__TargetAssignment_0_1_1_1_1 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:15385: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:15267:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:15268:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15389:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:15390:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:15268:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:15269:3: ruleReference + // InternalBehaviorAnnexParser.g:15390:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:15391:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getTargetReferenceParserRuleCall_0_1_1_1_1_0()); @@ -49984,23 +50442,23 @@ public final void rule__CommunicationAction__TargetAssignment_0_1_1_1_1() throws // $ANTLR start "rule__CommunicationAction__FreezeAssignment_0_1_2" - // InternalBehaviorAnnexParser.g:15278:1: rule__CommunicationAction__FreezeAssignment_0_1_2 : ( ( GreaterThanSignGreaterThanSign ) ) ; + // InternalBehaviorAnnexParser.g:15400: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:15282:1: ( ( ( GreaterThanSignGreaterThanSign ) ) ) - // InternalBehaviorAnnexParser.g:15283:2: ( ( GreaterThanSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15404:1: ( ( ( GreaterThanSignGreaterThanSign ) ) ) + // InternalBehaviorAnnexParser.g:15405:2: ( ( GreaterThanSignGreaterThanSign ) ) { - // InternalBehaviorAnnexParser.g:15283:2: ( ( GreaterThanSignGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:15284:3: ( GreaterThanSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15405:2: ( ( GreaterThanSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15406:3: ( GreaterThanSignGreaterThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getFreezeGreaterThanSignGreaterThanSignKeyword_0_1_2_0()); } - // InternalBehaviorAnnexParser.g:15285:3: ( GreaterThanSignGreaterThanSign ) - // InternalBehaviorAnnexParser.g:15286:4: GreaterThanSignGreaterThanSign + // InternalBehaviorAnnexParser.g:15407:3: ( GreaterThanSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15408:4: GreaterThanSignGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getFreezeGreaterThanSignGreaterThanSignKeyword_0_1_2_0()); @@ -50037,23 +50495,23 @@ public final void rule__CommunicationAction__FreezeAssignment_0_1_2() throws Rec // $ANTLR start "rule__CommunicationAction__LockAssignment_0_1_3" - // InternalBehaviorAnnexParser.g:15297:1: rule__CommunicationAction__LockAssignment_0_1_3 : ( ( ExclamationMarkLessThanSign ) ) ; + // InternalBehaviorAnnexParser.g:15419: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:15301:1: ( ( ( ExclamationMarkLessThanSign ) ) ) - // InternalBehaviorAnnexParser.g:15302:2: ( ( ExclamationMarkLessThanSign ) ) + // InternalBehaviorAnnexParser.g:15423:1: ( ( ( ExclamationMarkLessThanSign ) ) ) + // InternalBehaviorAnnexParser.g:15424:2: ( ( ExclamationMarkLessThanSign ) ) { - // InternalBehaviorAnnexParser.g:15302:2: ( ( ExclamationMarkLessThanSign ) ) - // InternalBehaviorAnnexParser.g:15303:3: ( ExclamationMarkLessThanSign ) + // InternalBehaviorAnnexParser.g:15424:2: ( ( ExclamationMarkLessThanSign ) ) + // InternalBehaviorAnnexParser.g:15425:3: ( ExclamationMarkLessThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getLockExclamationMarkLessThanSignKeyword_0_1_3_0()); } - // InternalBehaviorAnnexParser.g:15304:3: ( ExclamationMarkLessThanSign ) - // InternalBehaviorAnnexParser.g:15305:4: ExclamationMarkLessThanSign + // InternalBehaviorAnnexParser.g:15426:3: ( ExclamationMarkLessThanSign ) + // InternalBehaviorAnnexParser.g:15427:4: ExclamationMarkLessThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getLockExclamationMarkLessThanSignKeyword_0_1_3_0()); @@ -50090,23 +50548,23 @@ public final void rule__CommunicationAction__LockAssignment_0_1_3() throws Recog // $ANTLR start "rule__CommunicationAction__UnlockAssignment_0_1_4" - // InternalBehaviorAnnexParser.g:15316:1: rule__CommunicationAction__UnlockAssignment_0_1_4 : ( ( ExclamationMarkGreaterThanSign ) ) ; + // InternalBehaviorAnnexParser.g:15438: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:15320:1: ( ( ( ExclamationMarkGreaterThanSign ) ) ) - // InternalBehaviorAnnexParser.g:15321:2: ( ( ExclamationMarkGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15442:1: ( ( ( ExclamationMarkGreaterThanSign ) ) ) + // InternalBehaviorAnnexParser.g:15443:2: ( ( ExclamationMarkGreaterThanSign ) ) { - // InternalBehaviorAnnexParser.g:15321:2: ( ( ExclamationMarkGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:15322:3: ( ExclamationMarkGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15443:2: ( ( ExclamationMarkGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15444:3: ( ExclamationMarkGreaterThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getUnlockExclamationMarkGreaterThanSignKeyword_0_1_4_0()); } - // InternalBehaviorAnnexParser.g:15323:3: ( ExclamationMarkGreaterThanSign ) - // InternalBehaviorAnnexParser.g:15324:4: ExclamationMarkGreaterThanSign + // InternalBehaviorAnnexParser.g:15445:3: ( ExclamationMarkGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15446:4: ExclamationMarkGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getUnlockExclamationMarkGreaterThanSignKeyword_0_1_4_0()); @@ -50143,23 +50601,23 @@ public final void rule__CommunicationAction__UnlockAssignment_0_1_4() throws Rec // $ANTLR start "rule__CommunicationAction__AllAssignment_1_0" - // InternalBehaviorAnnexParser.g:15335:1: rule__CommunicationAction__AllAssignment_1_0 : ( ( Asterisk ) ) ; + // InternalBehaviorAnnexParser.g:15457:1: rule__CommunicationAction__AllAssignment_1_0 : ( ( Asterisk ) ) ; public final void rule__CommunicationAction__AllAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15339:1: ( ( ( Asterisk ) ) ) - // InternalBehaviorAnnexParser.g:15340:2: ( ( Asterisk ) ) + // InternalBehaviorAnnexParser.g:15461:1: ( ( ( Asterisk ) ) ) + // InternalBehaviorAnnexParser.g:15462:2: ( ( Asterisk ) ) { - // InternalBehaviorAnnexParser.g:15340:2: ( ( Asterisk ) ) - // InternalBehaviorAnnexParser.g:15341:3: ( Asterisk ) + // InternalBehaviorAnnexParser.g:15462:2: ( ( Asterisk ) ) + // InternalBehaviorAnnexParser.g:15463:3: ( Asterisk ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllAsteriskKeyword_1_0_0()); } - // InternalBehaviorAnnexParser.g:15342:3: ( Asterisk ) - // InternalBehaviorAnnexParser.g:15343:4: Asterisk + // InternalBehaviorAnnexParser.g:15464:3: ( Asterisk ) + // InternalBehaviorAnnexParser.g:15465:4: Asterisk { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllAsteriskKeyword_1_0_0()); @@ -50196,23 +50654,23 @@ public final void rule__CommunicationAction__AllAssignment_1_0() throws Recognit // $ANTLR start "rule__CommunicationAction__AllLockAssignment_1_1_0" - // InternalBehaviorAnnexParser.g:15354:1: rule__CommunicationAction__AllLockAssignment_1_1_0 : ( ( ExclamationMarkLessThanSign ) ) ; + // InternalBehaviorAnnexParser.g:15476: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:15358:1: ( ( ( ExclamationMarkLessThanSign ) ) ) - // InternalBehaviorAnnexParser.g:15359:2: ( ( ExclamationMarkLessThanSign ) ) + // InternalBehaviorAnnexParser.g:15480:1: ( ( ( ExclamationMarkLessThanSign ) ) ) + // InternalBehaviorAnnexParser.g:15481:2: ( ( ExclamationMarkLessThanSign ) ) { - // InternalBehaviorAnnexParser.g:15359:2: ( ( ExclamationMarkLessThanSign ) ) - // InternalBehaviorAnnexParser.g:15360:3: ( ExclamationMarkLessThanSign ) + // InternalBehaviorAnnexParser.g:15481:2: ( ( ExclamationMarkLessThanSign ) ) + // InternalBehaviorAnnexParser.g:15482:3: ( ExclamationMarkLessThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllLockExclamationMarkLessThanSignKeyword_1_1_0_0()); } - // InternalBehaviorAnnexParser.g:15361:3: ( ExclamationMarkLessThanSign ) - // InternalBehaviorAnnexParser.g:15362:4: ExclamationMarkLessThanSign + // InternalBehaviorAnnexParser.g:15483:3: ( ExclamationMarkLessThanSign ) + // InternalBehaviorAnnexParser.g:15484:4: ExclamationMarkLessThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllLockExclamationMarkLessThanSignKeyword_1_1_0_0()); @@ -50249,23 +50707,23 @@ public final void rule__CommunicationAction__AllLockAssignment_1_1_0() throws Re // $ANTLR start "rule__CommunicationAction__AllUnlockAssignment_1_1_1" - // InternalBehaviorAnnexParser.g:15373:1: rule__CommunicationAction__AllUnlockAssignment_1_1_1 : ( ( ExclamationMarkGreaterThanSign ) ) ; + // InternalBehaviorAnnexParser.g:15495: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:15377:1: ( ( ( ExclamationMarkGreaterThanSign ) ) ) - // InternalBehaviorAnnexParser.g:15378:2: ( ( ExclamationMarkGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15499:1: ( ( ( ExclamationMarkGreaterThanSign ) ) ) + // InternalBehaviorAnnexParser.g:15500:2: ( ( ExclamationMarkGreaterThanSign ) ) { - // InternalBehaviorAnnexParser.g:15378:2: ( ( ExclamationMarkGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:15379:3: ( ExclamationMarkGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15500:2: ( ( ExclamationMarkGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:15501:3: ( ExclamationMarkGreaterThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllUnlockExclamationMarkGreaterThanSignKeyword_1_1_1_0()); } - // InternalBehaviorAnnexParser.g:15380:3: ( ExclamationMarkGreaterThanSign ) - // InternalBehaviorAnnexParser.g:15381:4: ExclamationMarkGreaterThanSign + // InternalBehaviorAnnexParser.g:15502:3: ( ExclamationMarkGreaterThanSign ) + // InternalBehaviorAnnexParser.g:15503:4: ExclamationMarkGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getCommunicationActionAccess().getAllUnlockExclamationMarkGreaterThanSignKeyword_1_1_1_0()); @@ -50302,17 +50760,17 @@ public final void rule__CommunicationAction__AllUnlockAssignment_1_1_1() throws // $ANTLR start "rule__TimedAction__LowerTimeAssignment_2" - // InternalBehaviorAnnexParser.g:15392:1: rule__TimedAction__LowerTimeAssignment_2 : ( ruleBehaviorTime ) ; + // InternalBehaviorAnnexParser.g:15514:1: rule__TimedAction__LowerTimeAssignment_2 : ( ruleBehaviorTime ) ; public final void rule__TimedAction__LowerTimeAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15396:1: ( ( ruleBehaviorTime ) ) - // InternalBehaviorAnnexParser.g:15397:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15518:1: ( ( ruleBehaviorTime ) ) + // InternalBehaviorAnnexParser.g:15519:2: ( ruleBehaviorTime ) { - // InternalBehaviorAnnexParser.g:15397:2: ( ruleBehaviorTime ) - // InternalBehaviorAnnexParser.g:15398:3: ruleBehaviorTime + // InternalBehaviorAnnexParser.g:15519:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15520:3: ruleBehaviorTime { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getLowerTimeBehaviorTimeParserRuleCall_2_0()); @@ -50347,17 +50805,17 @@ public final void rule__TimedAction__LowerTimeAssignment_2() throws RecognitionE // $ANTLR start "rule__TimedAction__UpperTimeAssignment_3_1" - // InternalBehaviorAnnexParser.g:15407:1: rule__TimedAction__UpperTimeAssignment_3_1 : ( ruleBehaviorTime ) ; + // InternalBehaviorAnnexParser.g:15529:1: rule__TimedAction__UpperTimeAssignment_3_1 : ( ruleBehaviorTime ) ; public final void rule__TimedAction__UpperTimeAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15411:1: ( ( ruleBehaviorTime ) ) - // InternalBehaviorAnnexParser.g:15412:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15533:1: ( ( ruleBehaviorTime ) ) + // InternalBehaviorAnnexParser.g:15534:2: ( ruleBehaviorTime ) { - // InternalBehaviorAnnexParser.g:15412:2: ( ruleBehaviorTime ) - // InternalBehaviorAnnexParser.g:15413:3: ruleBehaviorTime + // InternalBehaviorAnnexParser.g:15534:2: ( ruleBehaviorTime ) + // InternalBehaviorAnnexParser.g:15535:3: ruleBehaviorTime { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getUpperTimeBehaviorTimeParserRuleCall_3_1_0()); @@ -50392,23 +50850,23 @@ public final void rule__TimedAction__UpperTimeAssignment_3_1() throws Recognitio // $ANTLR start "rule__TimedAction__ProcessorsAssignment_5_3" - // InternalBehaviorAnnexParser.g:15422:1: rule__TimedAction__ProcessorsAssignment_5_3 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:15544:1: rule__TimedAction__ProcessorsAssignment_5_3 : ( ( ruleQCREF ) ) ; public final void rule__TimedAction__ProcessorsAssignment_5_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15426:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:15427:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15548:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:15549:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:15427:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:15428:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15549:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15550:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getProcessorsComponentClassifierCrossReference_5_3_0()); } - // InternalBehaviorAnnexParser.g:15429:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:15430:4: ruleQCREF + // InternalBehaviorAnnexParser.g:15551:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15552:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getProcessorsComponentClassifierQCREFParserRuleCall_5_3_0_1()); @@ -50449,23 +50907,23 @@ public final void rule__TimedAction__ProcessorsAssignment_5_3() throws Recogniti // $ANTLR start "rule__TimedAction__ProcessorsAssignment_5_4_1" - // InternalBehaviorAnnexParser.g:15441:1: rule__TimedAction__ProcessorsAssignment_5_4_1 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:15563: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:15445:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:15446:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15567:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:15568:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:15446:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:15447:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15568:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15569:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getProcessorsComponentClassifierCrossReference_5_4_1_0()); } - // InternalBehaviorAnnexParser.g:15448:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:15449:4: ruleQCREF + // InternalBehaviorAnnexParser.g:15570:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15571:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getTimedActionAccess().getProcessorsComponentClassifierQCREFParserRuleCall_5_4_1_0_1()); @@ -50506,17 +50964,17 @@ public final void rule__TimedAction__ProcessorsAssignment_5_4_1() throws Recogni // $ANTLR start "rule__IfStatement__ConditionAssignment_2" - // InternalBehaviorAnnexParser.g:15460:1: rule__IfStatement__ConditionAssignment_2 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15582:1: rule__IfStatement__ConditionAssignment_2 : ( ruleValueExpression ) ; public final void rule__IfStatement__ConditionAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15464:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15465:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15586:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15587:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15465:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15466:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15587:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15588:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getConditionValueExpressionParserRuleCall_2_0()); @@ -50551,17 +51009,17 @@ public final void rule__IfStatement__ConditionAssignment_2() throws RecognitionE // $ANTLR start "rule__IfStatement__ThenActionsAssignment_4" - // InternalBehaviorAnnexParser.g:15475:1: rule__IfStatement__ThenActionsAssignment_4 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15597:1: rule__IfStatement__ThenActionsAssignment_4 : ( ruleBehaviorActions ) ; public final void rule__IfStatement__ThenActionsAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15479:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15480:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15601:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15602:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15480:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15481:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15602:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15603:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getThenActionsBehaviorActionsParserRuleCall_4_0()); @@ -50596,17 +51054,17 @@ public final void rule__IfStatement__ThenActionsAssignment_4() throws Recognitio // $ANTLR start "rule__IfStatement__ElseIfsAssignment_5" - // InternalBehaviorAnnexParser.g:15490:1: rule__IfStatement__ElseIfsAssignment_5 : ( ruleElseIfClause ) ; + // InternalBehaviorAnnexParser.g:15612:1: rule__IfStatement__ElseIfsAssignment_5 : ( ruleElseIfClause ) ; public final void rule__IfStatement__ElseIfsAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15494:1: ( ( ruleElseIfClause ) ) - // InternalBehaviorAnnexParser.g:15495:2: ( ruleElseIfClause ) + // InternalBehaviorAnnexParser.g:15616:1: ( ( ruleElseIfClause ) ) + // InternalBehaviorAnnexParser.g:15617:2: ( ruleElseIfClause ) { - // InternalBehaviorAnnexParser.g:15495:2: ( ruleElseIfClause ) - // InternalBehaviorAnnexParser.g:15496:3: ruleElseIfClause + // InternalBehaviorAnnexParser.g:15617:2: ( ruleElseIfClause ) + // InternalBehaviorAnnexParser.g:15618:3: ruleElseIfClause { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getElseIfsElseIfClauseParserRuleCall_5_0()); @@ -50641,17 +51099,17 @@ public final void rule__IfStatement__ElseIfsAssignment_5() throws RecognitionExc // $ANTLR start "rule__IfStatement__ElseActionsAssignment_6_1" - // InternalBehaviorAnnexParser.g:15505:1: rule__IfStatement__ElseActionsAssignment_6_1 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15627:1: rule__IfStatement__ElseActionsAssignment_6_1 : ( ruleBehaviorActions ) ; public final void rule__IfStatement__ElseActionsAssignment_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15509:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15510:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15631:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15632:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15510:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15511:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15632:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15633:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getIfStatementAccess().getElseActionsBehaviorActionsParserRuleCall_6_1_0()); @@ -50686,17 +51144,17 @@ public final void rule__IfStatement__ElseActionsAssignment_6_1() throws Recognit // $ANTLR start "rule__ElseIfClause__ConditionAssignment_2" - // InternalBehaviorAnnexParser.g:15520:1: rule__ElseIfClause__ConditionAssignment_2 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15642:1: rule__ElseIfClause__ConditionAssignment_2 : ( ruleValueExpression ) ; public final void rule__ElseIfClause__ConditionAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15524:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15525:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15646:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15647:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15525:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15526:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15647:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15648:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getElseIfClauseAccess().getConditionValueExpressionParserRuleCall_2_0()); @@ -50731,17 +51189,17 @@ public final void rule__ElseIfClause__ConditionAssignment_2() throws Recognition // $ANTLR start "rule__ElseIfClause__ActionsAssignment_4" - // InternalBehaviorAnnexParser.g:15535:1: rule__ElseIfClause__ActionsAssignment_4 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15657:1: rule__ElseIfClause__ActionsAssignment_4 : ( ruleBehaviorActions ) ; public final void rule__ElseIfClause__ActionsAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15539:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15540:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15661:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15662:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15540:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15541:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15662:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15663:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getElseIfClauseAccess().getActionsBehaviorActionsParserRuleCall_4_0()); @@ -50776,23 +51234,23 @@ public final void rule__ElseIfClause__ActionsAssignment_4() throws RecognitionEx // $ANTLR start "rule__ForStatement__ForAssignment_0_0" - // InternalBehaviorAnnexParser.g:15550:1: rule__ForStatement__ForAssignment_0_0 : ( ( For ) ) ; + // InternalBehaviorAnnexParser.g:15672:1: rule__ForStatement__ForAssignment_0_0 : ( ( For ) ) ; public final void rule__ForStatement__ForAssignment_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15554:1: ( ( ( For ) ) ) - // InternalBehaviorAnnexParser.g:15555:2: ( ( For ) ) + // InternalBehaviorAnnexParser.g:15676:1: ( ( ( For ) ) ) + // InternalBehaviorAnnexParser.g:15677:2: ( ( For ) ) { - // InternalBehaviorAnnexParser.g:15555:2: ( ( For ) ) - // InternalBehaviorAnnexParser.g:15556:3: ( For ) + // InternalBehaviorAnnexParser.g:15677:2: ( ( For ) ) + // InternalBehaviorAnnexParser.g:15678:3: ( For ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getForForKeyword_0_0_0()); } - // InternalBehaviorAnnexParser.g:15557:3: ( For ) - // InternalBehaviorAnnexParser.g:15558:4: For + // InternalBehaviorAnnexParser.g:15679:3: ( For ) + // InternalBehaviorAnnexParser.g:15680:4: For { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getForForKeyword_0_0_0()); @@ -50829,23 +51287,23 @@ public final void rule__ForStatement__ForAssignment_0_0() throws RecognitionExce // $ANTLR start "rule__ForStatement__ForallAssignment_0_1" - // InternalBehaviorAnnexParser.g:15569:1: rule__ForStatement__ForallAssignment_0_1 : ( ( Forall ) ) ; + // InternalBehaviorAnnexParser.g:15691:1: rule__ForStatement__ForallAssignment_0_1 : ( ( Forall ) ) ; public final void rule__ForStatement__ForallAssignment_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15573:1: ( ( ( Forall ) ) ) - // InternalBehaviorAnnexParser.g:15574:2: ( ( Forall ) ) + // InternalBehaviorAnnexParser.g:15695:1: ( ( ( Forall ) ) ) + // InternalBehaviorAnnexParser.g:15696:2: ( ( Forall ) ) { - // InternalBehaviorAnnexParser.g:15574:2: ( ( Forall ) ) - // InternalBehaviorAnnexParser.g:15575:3: ( Forall ) + // InternalBehaviorAnnexParser.g:15696:2: ( ( Forall ) ) + // InternalBehaviorAnnexParser.g:15697:3: ( Forall ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getForallForallKeyword_0_1_0()); } - // InternalBehaviorAnnexParser.g:15576:3: ( Forall ) - // InternalBehaviorAnnexParser.g:15577:4: Forall + // InternalBehaviorAnnexParser.g:15698:3: ( Forall ) + // InternalBehaviorAnnexParser.g:15699:4: Forall { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getForallForallKeyword_0_1_0()); @@ -50882,17 +51340,17 @@ public final void rule__ForStatement__ForallAssignment_0_1() throws RecognitionE // $ANTLR start "rule__ForStatement__VariableAssignment_2" - // InternalBehaviorAnnexParser.g:15588:1: rule__ForStatement__VariableAssignment_2 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:15710:1: rule__ForStatement__VariableAssignment_2 : ( RULE_ID ) ; public final void rule__ForStatement__VariableAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15592:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:15593:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:15714:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:15715:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:15593:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:15594:3: RULE_ID + // InternalBehaviorAnnexParser.g:15715:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:15716:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getVariableIDTerminalRuleCall_2_0()); @@ -50923,23 +51381,23 @@ public final void rule__ForStatement__VariableAssignment_2() throws RecognitionE // $ANTLR start "rule__ForStatement__DataClassifierAssignment_4" - // InternalBehaviorAnnexParser.g:15603:1: rule__ForStatement__DataClassifierAssignment_4 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:15725:1: rule__ForStatement__DataClassifierAssignment_4 : ( ( ruleQCREF ) ) ; public final void rule__ForStatement__DataClassifierAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15607:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:15608:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15729:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:15730:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:15608:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:15609:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15730:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:15731:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierCrossReference_4_0()); } - // InternalBehaviorAnnexParser.g:15610:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:15611:4: ruleQCREF + // InternalBehaviorAnnexParser.g:15732:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:15733:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getDataClassifierComponentClassifierQCREFParserRuleCall_4_0_1()); @@ -50980,17 +51438,17 @@ public final void rule__ForStatement__DataClassifierAssignment_4() throws Recogn // $ANTLR start "rule__ForStatement__ValuesAssignment_6" - // InternalBehaviorAnnexParser.g:15622:1: rule__ForStatement__ValuesAssignment_6 : ( ruleElementValues ) ; + // InternalBehaviorAnnexParser.g:15744:1: rule__ForStatement__ValuesAssignment_6 : ( ruleElementValues ) ; public final void rule__ForStatement__ValuesAssignment_6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15626:1: ( ( ruleElementValues ) ) - // InternalBehaviorAnnexParser.g:15627:2: ( ruleElementValues ) + // InternalBehaviorAnnexParser.g:15748:1: ( ( ruleElementValues ) ) + // InternalBehaviorAnnexParser.g:15749:2: ( ruleElementValues ) { - // InternalBehaviorAnnexParser.g:15627:2: ( ruleElementValues ) - // InternalBehaviorAnnexParser.g:15628:3: ruleElementValues + // InternalBehaviorAnnexParser.g:15749:2: ( ruleElementValues ) + // InternalBehaviorAnnexParser.g:15750:3: ruleElementValues { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getValuesElementValuesParserRuleCall_6_0()); @@ -51025,17 +51483,17 @@ public final void rule__ForStatement__ValuesAssignment_6() throws RecognitionExc // $ANTLR start "rule__ForStatement__ActionsAssignment_9" - // InternalBehaviorAnnexParser.g:15637:1: rule__ForStatement__ActionsAssignment_9 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15759:1: rule__ForStatement__ActionsAssignment_9 : ( ruleBehaviorActions ) ; public final void rule__ForStatement__ActionsAssignment_9() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15641:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15642:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15763:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15764:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15642:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15643:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15764:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15765:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getForStatementAccess().getActionsBehaviorActionsParserRuleCall_9_0()); @@ -51070,17 +51528,17 @@ public final void rule__ForStatement__ActionsAssignment_9() throws RecognitionEx // $ANTLR start "rule__WhileStatement__ConditionAssignment_2" - // InternalBehaviorAnnexParser.g:15652:1: rule__WhileStatement__ConditionAssignment_2 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15774:1: rule__WhileStatement__ConditionAssignment_2 : ( ruleValueExpression ) ; public final void rule__WhileStatement__ConditionAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15656:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15657:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15778:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15779:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15657:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15658:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15779:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15780:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getConditionValueExpressionParserRuleCall_2_0()); @@ -51115,17 +51573,17 @@ public final void rule__WhileStatement__ConditionAssignment_2() throws Recogniti // $ANTLR start "rule__WhileStatement__ActionsAssignment_5" - // InternalBehaviorAnnexParser.g:15667:1: rule__WhileStatement__ActionsAssignment_5 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15789:1: rule__WhileStatement__ActionsAssignment_5 : ( ruleBehaviorActions ) ; public final void rule__WhileStatement__ActionsAssignment_5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15671:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15672:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15793:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15794:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15672:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15673:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15794:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15795:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getWhileStatementAccess().getActionsBehaviorActionsParserRuleCall_5_0()); @@ -51160,17 +51618,17 @@ public final void rule__WhileStatement__ActionsAssignment_5() throws Recognition // $ANTLR start "rule__DoUntilStatement__ActionsAssignment_1" - // InternalBehaviorAnnexParser.g:15682:1: rule__DoUntilStatement__ActionsAssignment_1 : ( ruleBehaviorActions ) ; + // InternalBehaviorAnnexParser.g:15804:1: rule__DoUntilStatement__ActionsAssignment_1 : ( ruleBehaviorActions ) ; public final void rule__DoUntilStatement__ActionsAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15686:1: ( ( ruleBehaviorActions ) ) - // InternalBehaviorAnnexParser.g:15687:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15808:1: ( ( ruleBehaviorActions ) ) + // InternalBehaviorAnnexParser.g:15809:2: ( ruleBehaviorActions ) { - // InternalBehaviorAnnexParser.g:15687:2: ( ruleBehaviorActions ) - // InternalBehaviorAnnexParser.g:15688:3: ruleBehaviorActions + // InternalBehaviorAnnexParser.g:15809:2: ( ruleBehaviorActions ) + // InternalBehaviorAnnexParser.g:15810:3: ruleBehaviorActions { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getActionsBehaviorActionsParserRuleCall_1_0()); @@ -51205,17 +51663,17 @@ public final void rule__DoUntilStatement__ActionsAssignment_1() throws Recogniti // $ANTLR start "rule__DoUntilStatement__ConditionAssignment_4" - // InternalBehaviorAnnexParser.g:15697:1: rule__DoUntilStatement__ConditionAssignment_4 : ( ruleValueExpression ) ; + // InternalBehaviorAnnexParser.g:15819:1: rule__DoUntilStatement__ConditionAssignment_4 : ( ruleValueExpression ) ; public final void rule__DoUntilStatement__ConditionAssignment_4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15701:1: ( ( ruleValueExpression ) ) - // InternalBehaviorAnnexParser.g:15702:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15823:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:15824:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15702:2: ( ruleValueExpression ) - // InternalBehaviorAnnexParser.g:15703:3: ruleValueExpression + // InternalBehaviorAnnexParser.g:15824:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:15825:3: ruleValueExpression { if ( state.backtracking==0 ) { before(grammarAccess.getDoUntilStatementAccess().getConditionValueExpressionParserRuleCall_4_0()); @@ -51250,17 +51708,17 @@ public final void rule__DoUntilStatement__ConditionAssignment_4() throws Recogni // $ANTLR start "rule__ElementValues__LowerAssignment_0" - // InternalBehaviorAnnexParser.g:15712:1: rule__ElementValues__LowerAssignment_0 : ( ruleIntegerValue ) ; + // InternalBehaviorAnnexParser.g:15834:1: rule__ElementValues__LowerAssignment_0 : ( ruleIntegerValue ) ; public final void rule__ElementValues__LowerAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15716:1: ( ( ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:15717:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15838:1: ( ( ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:15839:2: ( ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:15717:2: ( ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:15718:3: ruleIntegerValue + // InternalBehaviorAnnexParser.g:15839:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15840:3: ruleIntegerValue { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getLowerIntegerValueParserRuleCall_0_0()); @@ -51295,17 +51753,17 @@ public final void rule__ElementValues__LowerAssignment_0() throws RecognitionExc // $ANTLR start "rule__ElementValues__UpperAssignment_1_1" - // InternalBehaviorAnnexParser.g:15727:1: rule__ElementValues__UpperAssignment_1_1 : ( ruleIntegerValue ) ; + // InternalBehaviorAnnexParser.g:15849:1: rule__ElementValues__UpperAssignment_1_1 : ( ruleIntegerValue ) ; public final void rule__ElementValues__UpperAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15731:1: ( ( ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:15732:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15853:1: ( ( ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:15854:2: ( ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:15732:2: ( ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:15733:3: ruleIntegerValue + // InternalBehaviorAnnexParser.g:15854:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15855:3: ruleIntegerValue { if ( state.backtracking==0 ) { before(grammarAccess.getElementValuesAccess().getUpperIntegerValueParserRuleCall_1_1_0()); @@ -51340,17 +51798,17 @@ public final void rule__ElementValues__UpperAssignment_1_1() throws RecognitionE // $ANTLR start "rule__BehaviorTime__ValueAssignment_0" - // InternalBehaviorAnnexParser.g:15742:1: rule__BehaviorTime__ValueAssignment_0 : ( ruleIntegerValue ) ; + // InternalBehaviorAnnexParser.g:15864:1: rule__BehaviorTime__ValueAssignment_0 : ( ruleIntegerValue ) ; public final void rule__BehaviorTime__ValueAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15746:1: ( ( ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:15747:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15868:1: ( ( ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:15869:2: ( ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:15747:2: ( ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:15748:3: ruleIntegerValue + // InternalBehaviorAnnexParser.g:15869:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:15870:3: ruleIntegerValue { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTimeAccess().getValueIntegerValueParserRuleCall_0_0()); @@ -51385,23 +51843,23 @@ public final void rule__BehaviorTime__ValueAssignment_0() throws RecognitionExce // $ANTLR start "rule__BehaviorTime__UnitAssignment_1" - // InternalBehaviorAnnexParser.g:15757:1: rule__BehaviorTime__UnitAssignment_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:15879:1: rule__BehaviorTime__UnitAssignment_1 : ( ( RULE_ID ) ) ; public final void rule__BehaviorTime__UnitAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15761:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:15762:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:15883:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:15884:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:15762:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:15763:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:15884:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:15885:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTimeAccess().getUnitUnitLiteralCrossReference_1_0()); } - // InternalBehaviorAnnexParser.g:15764:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:15765:4: RULE_ID + // InternalBehaviorAnnexParser.g:15886:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:15887:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorTimeAccess().getUnitUnitLiteralIDTerminalRuleCall_1_0_1()); @@ -51437,29 +51895,29 @@ public final void rule__BehaviorTime__UnitAssignment_1() throws RecognitionExcep // $ANTLR end "rule__BehaviorTime__UnitAssignment_1" - // $ANTLR start "rule__LogicalOrExpression__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:15776:1: rule__LogicalOrExpression__OperatorAssignment_1_1 : ( ruleLogicalOrOperator ) ; - public final void rule__LogicalOrExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__ValueExpression__OperatorAssignment_1_1" + // InternalBehaviorAnnexParser.g:15898:1: rule__ValueExpression__OperatorAssignment_1_1 : ( ruleLogicalOperator ) ; + public final void rule__ValueExpression__OperatorAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15780:1: ( ( ruleLogicalOrOperator ) ) - // InternalBehaviorAnnexParser.g:15781:2: ( ruleLogicalOrOperator ) + // InternalBehaviorAnnexParser.g:15902:1: ( ( ruleLogicalOperator ) ) + // InternalBehaviorAnnexParser.g:15903:2: ( ruleLogicalOperator ) { - // InternalBehaviorAnnexParser.g:15781:2: ( ruleLogicalOrOperator ) - // InternalBehaviorAnnexParser.g:15782:3: ruleLogicalOrOperator + // InternalBehaviorAnnexParser.g:15903:2: ( ruleLogicalOperator ) + // InternalBehaviorAnnexParser.g:15904:3: ruleLogicalOperator { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrExpressionAccess().getOperatorLogicalOrOperatorParserRuleCall_1_1_0()); + before(grammarAccess.getValueExpressionAccess().getOperatorLogicalOperatorParserRuleCall_1_1_0()); } pushFollow(FollowSets000.FOLLOW_2); - ruleLogicalOrOperator(); + ruleLogicalOperator(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrExpressionAccess().getOperatorLogicalOrOperatorParserRuleCall_1_1_0()); + after(grammarAccess.getValueExpressionAccess().getOperatorLogicalOperatorParserRuleCall_1_1_0()); } } @@ -51479,32 +51937,32 @@ public final void rule__LogicalOrExpression__OperatorAssignment_1_1() throws Rec } return ; } - // $ANTLR end "rule__LogicalOrExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__ValueExpression__OperatorAssignment_1_1" - // $ANTLR start "rule__LogicalOrExpression__RightAssignment_1_2" - // InternalBehaviorAnnexParser.g:15791:1: rule__LogicalOrExpression__RightAssignment_1_2 : ( ruleLogicalAndExpression ) ; - public final void rule__LogicalOrExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__ValueExpression__RightAssignment_1_2" + // InternalBehaviorAnnexParser.g:15913:1: rule__ValueExpression__RightAssignment_1_2 : ( ruleRelation ) ; + public final void rule__ValueExpression__RightAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15795:1: ( ( ruleLogicalAndExpression ) ) - // InternalBehaviorAnnexParser.g:15796:2: ( ruleLogicalAndExpression ) + // InternalBehaviorAnnexParser.g:15917:1: ( ( ruleRelation ) ) + // InternalBehaviorAnnexParser.g:15918:2: ( ruleRelation ) { - // InternalBehaviorAnnexParser.g:15796:2: ( ruleLogicalAndExpression ) - // InternalBehaviorAnnexParser.g:15797:3: ruleLogicalAndExpression + // InternalBehaviorAnnexParser.g:15918:2: ( ruleRelation ) + // InternalBehaviorAnnexParser.g:15919:3: ruleRelation { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalOrExpressionAccess().getRightLogicalAndExpressionParserRuleCall_1_2_0()); + before(grammarAccess.getValueExpressionAccess().getRightRelationParserRuleCall_1_2_0()); } pushFollow(FollowSets000.FOLLOW_2); - ruleLogicalAndExpression(); + ruleRelation(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalOrExpressionAccess().getRightLogicalAndExpressionParserRuleCall_1_2_0()); + after(grammarAccess.getValueExpressionAccess().getRightRelationParserRuleCall_1_2_0()); } } @@ -51524,32 +51982,32 @@ public final void rule__LogicalOrExpression__RightAssignment_1_2() throws Recogn } return ; } - // $ANTLR end "rule__LogicalOrExpression__RightAssignment_1_2" + // $ANTLR end "rule__ValueExpression__RightAssignment_1_2" - // $ANTLR start "rule__LogicalAndExpression__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:15806:1: rule__LogicalAndExpression__OperatorAssignment_1_1 : ( ruleLogicalAndOperator ) ; - public final void rule__LogicalAndExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__Relation__OperatorAssignment_1_1" + // InternalBehaviorAnnexParser.g:15928:1: rule__Relation__OperatorAssignment_1_1 : ( ruleRelationalOperator ) ; + public final void rule__Relation__OperatorAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15810:1: ( ( ruleLogicalAndOperator ) ) - // InternalBehaviorAnnexParser.g:15811:2: ( ruleLogicalAndOperator ) + // InternalBehaviorAnnexParser.g:15932:1: ( ( ruleRelationalOperator ) ) + // InternalBehaviorAnnexParser.g:15933:2: ( ruleRelationalOperator ) { - // InternalBehaviorAnnexParser.g:15811:2: ( ruleLogicalAndOperator ) - // InternalBehaviorAnnexParser.g:15812:3: ruleLogicalAndOperator + // InternalBehaviorAnnexParser.g:15933:2: ( ruleRelationalOperator ) + // InternalBehaviorAnnexParser.g:15934:3: ruleRelationalOperator { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndExpressionAccess().getOperatorLogicalAndOperatorParserRuleCall_1_1_0()); + before(grammarAccess.getRelationAccess().getOperatorRelationalOperatorParserRuleCall_1_1_0()); } pushFollow(FollowSets000.FOLLOW_2); - ruleLogicalAndOperator(); + ruleRelationalOperator(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndExpressionAccess().getOperatorLogicalAndOperatorParserRuleCall_1_1_0()); + after(grammarAccess.getRelationAccess().getOperatorRelationalOperatorParserRuleCall_1_1_0()); } } @@ -51569,32 +52027,32 @@ public final void rule__LogicalAndExpression__OperatorAssignment_1_1() throws Re } return ; } - // $ANTLR end "rule__LogicalAndExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__Relation__OperatorAssignment_1_1" - // $ANTLR start "rule__LogicalAndExpression__RightAssignment_1_2" - // InternalBehaviorAnnexParser.g:15821:1: rule__LogicalAndExpression__RightAssignment_1_2 : ( ruleRelationalExpression ) ; - public final void rule__LogicalAndExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__Relation__RightAssignment_1_2" + // InternalBehaviorAnnexParser.g:15943:1: rule__Relation__RightAssignment_1_2 : ( ruleSimpleExpression ) ; + public final void rule__Relation__RightAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15825:1: ( ( ruleRelationalExpression ) ) - // InternalBehaviorAnnexParser.g:15826:2: ( ruleRelationalExpression ) + // InternalBehaviorAnnexParser.g:15947:1: ( ( ruleSimpleExpression ) ) + // InternalBehaviorAnnexParser.g:15948:2: ( ruleSimpleExpression ) { - // InternalBehaviorAnnexParser.g:15826:2: ( ruleRelationalExpression ) - // InternalBehaviorAnnexParser.g:15827:3: ruleRelationalExpression + // InternalBehaviorAnnexParser.g:15948:2: ( ruleSimpleExpression ) + // InternalBehaviorAnnexParser.g:15949:3: ruleSimpleExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getLogicalAndExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); + before(grammarAccess.getRelationAccess().getRightSimpleExpressionParserRuleCall_1_2_0()); } pushFollow(FollowSets000.FOLLOW_2); - ruleRelationalExpression(); + ruleSimpleExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLogicalAndExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); + after(grammarAccess.getRelationAccess().getRightSimpleExpressionParserRuleCall_1_2_0()); } } @@ -51614,38 +52072,32 @@ public final void rule__LogicalAndExpression__RightAssignment_1_2() throws Recog } return ; } - // $ANTLR end "rule__LogicalAndExpression__RightAssignment_1_2" + // $ANTLR end "rule__Relation__RightAssignment_1_2" - // $ANTLR start "rule__RelationalExpression__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:15836:1: rule__RelationalExpression__OperatorAssignment_1_1 : ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ; - public final void rule__RelationalExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__OperatorAssignment_0_0_1" + // InternalBehaviorAnnexParser.g:15958: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:15840:1: ( ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ) - // InternalBehaviorAnnexParser.g:15841:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) + // InternalBehaviorAnnexParser.g:15962:1: ( ( ruleUnaryAddingOperator ) ) + // InternalBehaviorAnnexParser.g:15963:2: ( ruleUnaryAddingOperator ) { - // InternalBehaviorAnnexParser.g:15841:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) - // InternalBehaviorAnnexParser.g:15842:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) + // InternalBehaviorAnnexParser.g:15963:2: ( ruleUnaryAddingOperator ) + // InternalBehaviorAnnexParser.g:15964:3: ruleUnaryAddingOperator { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + before(grammarAccess.getSimpleExpressionAccess().getOperatorUnaryAddingOperatorParserRuleCall_0_0_1_0()); } - // InternalBehaviorAnnexParser.g:15843:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) - // InternalBehaviorAnnexParser.g:15843:4: rule__RelationalExpression__OperatorAlternatives_1_1_0 - { pushFollow(FollowSets000.FOLLOW_2); - rule__RelationalExpression__OperatorAlternatives_1_1_0(); + ruleUnaryAddingOperator(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + after(grammarAccess.getSimpleExpressionAccess().getOperatorUnaryAddingOperatorParserRuleCall_0_0_1_0()); } } @@ -51665,32 +52117,32 @@ public final void rule__RelationalExpression__OperatorAssignment_1_1() throws Re } return ; } - // $ANTLR end "rule__RelationalExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__SimpleExpression__OperatorAssignment_0_0_1" - // $ANTLR start "rule__RelationalExpression__RightAssignment_1_2" - // InternalBehaviorAnnexParser.g:15851:1: rule__RelationalExpression__RightAssignment_1_2 : ( ruleAdditiveExpression ) ; - public final void rule__RelationalExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__OperandAssignment_0_0_2" + // InternalBehaviorAnnexParser.g:15973: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:15855:1: ( ( ruleAdditiveExpression ) ) - // InternalBehaviorAnnexParser.g:15856:2: ( ruleAdditiveExpression ) + // InternalBehaviorAnnexParser.g:15977:1: ( ( ruleTerm ) ) + // InternalBehaviorAnnexParser.g:15978:2: ( ruleTerm ) { - // InternalBehaviorAnnexParser.g:15856:2: ( ruleAdditiveExpression ) - // InternalBehaviorAnnexParser.g:15857:3: ruleAdditiveExpression + // InternalBehaviorAnnexParser.g:15978:2: ( ruleTerm ) + // InternalBehaviorAnnexParser.g:15979:3: ruleTerm { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); + before(grammarAccess.getSimpleExpressionAccess().getOperandTermParserRuleCall_0_0_2_0()); } pushFollow(FollowSets000.FOLLOW_2); - ruleAdditiveExpression(); + ruleTerm(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); + after(grammarAccess.getSimpleExpressionAccess().getOperandTermParserRuleCall_0_0_2_0()); } } @@ -51710,38 +52162,32 @@ public final void rule__RelationalExpression__RightAssignment_1_2() throws Recog } return ; } - // $ANTLR end "rule__RelationalExpression__RightAssignment_1_2" + // $ANTLR end "rule__SimpleExpression__OperandAssignment_0_0_2" - // $ANTLR start "rule__AdditiveExpression__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:15866:1: rule__AdditiveExpression__OperatorAssignment_1_1 : ( ( rule__AdditiveExpression__OperatorAlternatives_1_1_0 ) ) ; - public final void rule__AdditiveExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__OperatorAssignment_1_1" + // InternalBehaviorAnnexParser.g:15988:1: rule__SimpleExpression__OperatorAssignment_1_1 : ( ruleBinaryAddingOperator ) ; + public final void rule__SimpleExpression__OperatorAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15870:1: ( ( ( rule__AdditiveExpression__OperatorAlternatives_1_1_0 ) ) ) - // InternalBehaviorAnnexParser.g:15871:2: ( ( rule__AdditiveExpression__OperatorAlternatives_1_1_0 ) ) + // InternalBehaviorAnnexParser.g:15992:1: ( ( ruleBinaryAddingOperator ) ) + // InternalBehaviorAnnexParser.g:15993:2: ( ruleBinaryAddingOperator ) { - // InternalBehaviorAnnexParser.g:15871:2: ( ( rule__AdditiveExpression__OperatorAlternatives_1_1_0 ) ) - // InternalBehaviorAnnexParser.g:15872:3: ( rule__AdditiveExpression__OperatorAlternatives_1_1_0 ) + // InternalBehaviorAnnexParser.g:15993:2: ( ruleBinaryAddingOperator ) + // InternalBehaviorAnnexParser.g:15994:3: ruleBinaryAddingOperator { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getOperatorAlternatives_1_1_0()); + before(grammarAccess.getSimpleExpressionAccess().getOperatorBinaryAddingOperatorParserRuleCall_1_1_0()); } - // InternalBehaviorAnnexParser.g:15873:3: ( rule__AdditiveExpression__OperatorAlternatives_1_1_0 ) - // InternalBehaviorAnnexParser.g:15873:4: rule__AdditiveExpression__OperatorAlternatives_1_1_0 - { pushFollow(FollowSets000.FOLLOW_2); - rule__AdditiveExpression__OperatorAlternatives_1_1_0(); + ruleBinaryAddingOperator(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getOperatorAlternatives_1_1_0()); + after(grammarAccess.getSimpleExpressionAccess().getOperatorBinaryAddingOperatorParserRuleCall_1_1_0()); } } @@ -51761,32 +52207,32 @@ public final void rule__AdditiveExpression__OperatorAssignment_1_1() throws Reco } return ; } - // $ANTLR end "rule__AdditiveExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__SimpleExpression__OperatorAssignment_1_1" - // $ANTLR start "rule__AdditiveExpression__RightAssignment_1_2" - // InternalBehaviorAnnexParser.g:15881:1: rule__AdditiveExpression__RightAssignment_1_2 : ( ruleMultiplicativeExpression ) ; - public final void rule__AdditiveExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__SimpleExpression__RightAssignment_1_2" + // InternalBehaviorAnnexParser.g:16003:1: rule__SimpleExpression__RightAssignment_1_2 : ( ruleTerm ) ; + public final void rule__SimpleExpression__RightAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15885:1: ( ( ruleMultiplicativeExpression ) ) - // InternalBehaviorAnnexParser.g:15886:2: ( ruleMultiplicativeExpression ) + // InternalBehaviorAnnexParser.g:16007:1: ( ( ruleTerm ) ) + // InternalBehaviorAnnexParser.g:16008:2: ( ruleTerm ) { - // InternalBehaviorAnnexParser.g:15886:2: ( ruleMultiplicativeExpression ) - // InternalBehaviorAnnexParser.g:15887:3: ruleMultiplicativeExpression + // InternalBehaviorAnnexParser.g:16008:2: ( ruleTerm ) + // InternalBehaviorAnnexParser.g:16009:3: ruleTerm { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); + before(grammarAccess.getSimpleExpressionAccess().getRightTermParserRuleCall_1_2_0()); } pushFollow(FollowSets000.FOLLOW_2); - ruleMultiplicativeExpression(); + ruleTerm(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); + after(grammarAccess.getSimpleExpressionAccess().getRightTermParserRuleCall_1_2_0()); } } @@ -51806,38 +52252,32 @@ public final void rule__AdditiveExpression__RightAssignment_1_2() throws Recogni } return ; } - // $ANTLR end "rule__AdditiveExpression__RightAssignment_1_2" + // $ANTLR end "rule__SimpleExpression__RightAssignment_1_2" - // $ANTLR start "rule__MultiplicativeExpression__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:15896:1: rule__MultiplicativeExpression__OperatorAssignment_1_1 : ( ( rule__MultiplicativeExpression__OperatorAlternatives_1_1_0 ) ) ; - public final void rule__MultiplicativeExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__Term__OperatorAssignment_1_1" + // InternalBehaviorAnnexParser.g:16018:1: rule__Term__OperatorAssignment_1_1 : ( ruleMultiplyingOperator ) ; + public final void rule__Term__OperatorAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15900:1: ( ( ( rule__MultiplicativeExpression__OperatorAlternatives_1_1_0 ) ) ) - // InternalBehaviorAnnexParser.g:15901:2: ( ( rule__MultiplicativeExpression__OperatorAlternatives_1_1_0 ) ) + // InternalBehaviorAnnexParser.g:16022:1: ( ( ruleMultiplyingOperator ) ) + // InternalBehaviorAnnexParser.g:16023:2: ( ruleMultiplyingOperator ) { - // InternalBehaviorAnnexParser.g:15901:2: ( ( rule__MultiplicativeExpression__OperatorAlternatives_1_1_0 ) ) - // InternalBehaviorAnnexParser.g:15902:3: ( rule__MultiplicativeExpression__OperatorAlternatives_1_1_0 ) + // InternalBehaviorAnnexParser.g:16023:2: ( ruleMultiplyingOperator ) + // InternalBehaviorAnnexParser.g:16024:3: ruleMultiplyingOperator { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAlternatives_1_1_0()); + before(grammarAccess.getTermAccess().getOperatorMultiplyingOperatorParserRuleCall_1_1_0()); } - // InternalBehaviorAnnexParser.g:15903:3: ( rule__MultiplicativeExpression__OperatorAlternatives_1_1_0 ) - // InternalBehaviorAnnexParser.g:15903:4: rule__MultiplicativeExpression__OperatorAlternatives_1_1_0 - { pushFollow(FollowSets000.FOLLOW_2); - rule__MultiplicativeExpression__OperatorAlternatives_1_1_0(); + ruleMultiplyingOperator(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAlternatives_1_1_0()); + after(grammarAccess.getTermAccess().getOperatorMultiplyingOperatorParserRuleCall_1_1_0()); } } @@ -51857,32 +52297,32 @@ public final void rule__MultiplicativeExpression__OperatorAssignment_1_1() throw } return ; } - // $ANTLR end "rule__MultiplicativeExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__Term__OperatorAssignment_1_1" - // $ANTLR start "rule__MultiplicativeExpression__RightAssignment_1_2" - // InternalBehaviorAnnexParser.g:15911:1: rule__MultiplicativeExpression__RightAssignment_1_2 : ( rulePowerExpression ) ; - public final void rule__MultiplicativeExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__Term__RightAssignment_1_2" + // InternalBehaviorAnnexParser.g:16033:1: rule__Term__RightAssignment_1_2 : ( ruleFactor ) ; + public final void rule__Term__RightAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15915:1: ( ( rulePowerExpression ) ) - // InternalBehaviorAnnexParser.g:15916:2: ( rulePowerExpression ) + // InternalBehaviorAnnexParser.g:16037:1: ( ( ruleFactor ) ) + // InternalBehaviorAnnexParser.g:16038:2: ( ruleFactor ) { - // InternalBehaviorAnnexParser.g:15916:2: ( rulePowerExpression ) - // InternalBehaviorAnnexParser.g:15917:3: rulePowerExpression + // InternalBehaviorAnnexParser.g:16038:2: ( ruleFactor ) + // InternalBehaviorAnnexParser.g:16039:3: ruleFactor { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); + before(grammarAccess.getTermAccess().getRightFactorParserRuleCall_1_2_0()); } pushFollow(FollowSets000.FOLLOW_2); - rulePowerExpression(); + ruleFactor(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); + after(grammarAccess.getTermAccess().getRightFactorParserRuleCall_1_2_0()); } } @@ -51902,40 +52342,77 @@ public final void rule__MultiplicativeExpression__RightAssignment_1_2() throws R } return ; } - // $ANTLR end "rule__MultiplicativeExpression__RightAssignment_1_2" + // $ANTLR end "rule__Term__RightAssignment_1_2" - // $ANTLR start "rule__PowerExpression__OperatorAssignment_1_1" - // InternalBehaviorAnnexParser.g:15926:1: rule__PowerExpression__OperatorAssignment_1_1 : ( ( AsteriskAsterisk ) ) ; - public final void rule__PowerExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__Factor__OperatorAssignment_0_1_1" + // InternalBehaviorAnnexParser.g:16048: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:15930:1: ( ( ( AsteriskAsterisk ) ) ) - // InternalBehaviorAnnexParser.g:15931:2: ( ( AsteriskAsterisk ) ) + // InternalBehaviorAnnexParser.g:16052:1: ( ( ruleBinaryNumericOperator ) ) + // InternalBehaviorAnnexParser.g:16053:2: ( ruleBinaryNumericOperator ) { - // InternalBehaviorAnnexParser.g:15931:2: ( ( AsteriskAsterisk ) ) - // InternalBehaviorAnnexParser.g:15932:3: ( AsteriskAsterisk ) + // InternalBehaviorAnnexParser.g:16053:2: ( ruleBinaryNumericOperator ) + // InternalBehaviorAnnexParser.g:16054:3: ruleBinaryNumericOperator { if ( state.backtracking==0 ) { - before(grammarAccess.getPowerExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_0()); + before(grammarAccess.getFactorAccess().getOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0()); } - // InternalBehaviorAnnexParser.g:15933:3: ( AsteriskAsterisk ) - // InternalBehaviorAnnexParser.g:15934:4: AsteriskAsterisk - { + pushFollow(FollowSets000.FOLLOW_2); + ruleBinaryNumericOperator(); + + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - before(grammarAccess.getPowerExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_0()); + after(grammarAccess.getFactorAccess().getOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0()); } - match(input,AsteriskAsterisk,FollowSets000.FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPowerExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_0()); + } + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Factor__OperatorAssignment_0_1_1" + + + // $ANTLR start "rule__Factor__RightAssignment_0_1_2" + // InternalBehaviorAnnexParser.g:16063: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:16068:2: ( ruleValue ) + // InternalBehaviorAnnexParser.g:16069:3: ruleValue + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFactorAccess().getRightValueParserRuleCall_0_1_2_0()); } + pushFollow(FollowSets000.FOLLOW_2); + ruleValue(); + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getPowerExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_0()); + after(grammarAccess.getFactorAccess().getRightValueParserRuleCall_0_1_2_0()); } } @@ -51955,32 +52432,32 @@ public final void rule__PowerExpression__OperatorAssignment_1_1() throws Recogni } return ; } - // $ANTLR end "rule__PowerExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__Factor__RightAssignment_0_1_2" - // $ANTLR start "rule__PowerExpression__RightAssignment_1_2" - // InternalBehaviorAnnexParser.g:15945:1: rule__PowerExpression__RightAssignment_1_2 : ( rulePowerExpression ) ; - public final void rule__PowerExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__Factor__OperatorAssignment_1_1" + // InternalBehaviorAnnexParser.g:16078:1: rule__Factor__OperatorAssignment_1_1 : ( ruleUnaryValueOperator ) ; + public final void rule__Factor__OperatorAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15949:1: ( ( rulePowerExpression ) ) - // InternalBehaviorAnnexParser.g:15950:2: ( rulePowerExpression ) + // InternalBehaviorAnnexParser.g:16082:1: ( ( ruleUnaryValueOperator ) ) + // InternalBehaviorAnnexParser.g:16083:2: ( ruleUnaryValueOperator ) { - // InternalBehaviorAnnexParser.g:15950:2: ( rulePowerExpression ) - // InternalBehaviorAnnexParser.g:15951:3: rulePowerExpression + // InternalBehaviorAnnexParser.g:16083:2: ( ruleUnaryValueOperator ) + // InternalBehaviorAnnexParser.g:16084:3: ruleUnaryValueOperator { if ( state.backtracking==0 ) { - before(grammarAccess.getPowerExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); + before(grammarAccess.getFactorAccess().getOperatorUnaryValueOperatorParserRuleCall_1_1_0()); } pushFollow(FollowSets000.FOLLOW_2); - rulePowerExpression(); + ruleUnaryValueOperator(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getPowerExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); + after(grammarAccess.getFactorAccess().getOperatorUnaryValueOperatorParserRuleCall_1_1_0()); } } @@ -52000,38 +52477,32 @@ public final void rule__PowerExpression__RightAssignment_1_2() throws Recognitio } return ; } - // $ANTLR end "rule__PowerExpression__RightAssignment_1_2" + // $ANTLR end "rule__Factor__OperatorAssignment_1_1" - // $ANTLR start "rule__UnaryExpression__OperatorAssignment_0_1" - // InternalBehaviorAnnexParser.g:15960:1: rule__UnaryExpression__OperatorAssignment_0_1 : ( ( rule__UnaryExpression__OperatorAlternatives_0_1_0 ) ) ; - public final void rule__UnaryExpression__OperatorAssignment_0_1() throws RecognitionException { + // $ANTLR start "rule__Factor__OperandAssignment_1_2" + // InternalBehaviorAnnexParser.g:16093:1: rule__Factor__OperandAssignment_1_2 : ( ruleValue ) ; + public final void rule__Factor__OperandAssignment_1_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15964:1: ( ( ( rule__UnaryExpression__OperatorAlternatives_0_1_0 ) ) ) - // InternalBehaviorAnnexParser.g:15965:2: ( ( rule__UnaryExpression__OperatorAlternatives_0_1_0 ) ) + // InternalBehaviorAnnexParser.g:16097:1: ( ( ruleValue ) ) + // InternalBehaviorAnnexParser.g:16098:2: ( ruleValue ) { - // InternalBehaviorAnnexParser.g:15965:2: ( ( rule__UnaryExpression__OperatorAlternatives_0_1_0 ) ) - // InternalBehaviorAnnexParser.g:15966:3: ( rule__UnaryExpression__OperatorAlternatives_0_1_0 ) + // InternalBehaviorAnnexParser.g:16098:2: ( ruleValue ) + // InternalBehaviorAnnexParser.g:16099:3: ruleValue { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getOperatorAlternatives_0_1_0()); + before(grammarAccess.getFactorAccess().getOperandValueParserRuleCall_1_2_0()); } - // InternalBehaviorAnnexParser.g:15967:3: ( rule__UnaryExpression__OperatorAlternatives_0_1_0 ) - // InternalBehaviorAnnexParser.g:15967:4: rule__UnaryExpression__OperatorAlternatives_0_1_0 - { pushFollow(FollowSets000.FOLLOW_2); - rule__UnaryExpression__OperatorAlternatives_0_1_0(); + ruleValue(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getOperatorAlternatives_0_1_0()); + after(grammarAccess.getFactorAccess().getOperandValueParserRuleCall_1_2_0()); } } @@ -52051,32 +52522,32 @@ public final void rule__UnaryExpression__OperatorAssignment_0_1() throws Recogni } return ; } - // $ANTLR end "rule__UnaryExpression__OperatorAssignment_0_1" + // $ANTLR end "rule__Factor__OperandAssignment_1_2" - // $ANTLR start "rule__UnaryExpression__OperandAssignment_0_2" - // InternalBehaviorAnnexParser.g:15975:1: rule__UnaryExpression__OperandAssignment_0_2 : ( ruleUnaryExpression ) ; - public final void rule__UnaryExpression__OperandAssignment_0_2() throws RecognitionException { + // $ANTLR start "rule__ParenthesizedExpression__ExpressionAssignment_1" + // InternalBehaviorAnnexParser.g:16108:1: rule__ParenthesizedExpression__ExpressionAssignment_1 : ( ruleValueExpression ) ; + public final void rule__ParenthesizedExpression__ExpressionAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15979:1: ( ( ruleUnaryExpression ) ) - // InternalBehaviorAnnexParser.g:15980:2: ( ruleUnaryExpression ) + // InternalBehaviorAnnexParser.g:16112:1: ( ( ruleValueExpression ) ) + // InternalBehaviorAnnexParser.g:16113:2: ( ruleValueExpression ) { - // InternalBehaviorAnnexParser.g:15980:2: ( ruleUnaryExpression ) - // InternalBehaviorAnnexParser.g:15981:3: ruleUnaryExpression + // InternalBehaviorAnnexParser.g:16113:2: ( ruleValueExpression ) + // InternalBehaviorAnnexParser.g:16114:3: ruleValueExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getOperandUnaryExpressionParserRuleCall_0_2_0()); + before(grammarAccess.getParenthesizedExpressionAccess().getExpressionValueExpressionParserRuleCall_1_0()); } pushFollow(FollowSets000.FOLLOW_2); - ruleUnaryExpression(); + ruleValueExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getOperandUnaryExpressionParserRuleCall_0_2_0()); + after(grammarAccess.getParenthesizedExpressionAccess().getExpressionValueExpressionParserRuleCall_1_0()); } } @@ -52096,21 +52567,21 @@ public final void rule__UnaryExpression__OperandAssignment_0_2() throws Recognit } return ; } - // $ANTLR end "rule__UnaryExpression__OperandAssignment_0_2" + // $ANTLR end "rule__ParenthesizedExpression__ExpressionAssignment_1" // $ANTLR start "rule__BehaviorIntegerLiteral__ValueAssignment" - // InternalBehaviorAnnexParser.g:15990:1: rule__BehaviorIntegerLiteral__ValueAssignment : ( RULE_INTEGER_LIT ) ; + // InternalBehaviorAnnexParser.g:16123:1: rule__BehaviorIntegerLiteral__ValueAssignment : ( RULE_INTEGER_LIT ) ; public final void rule__BehaviorIntegerLiteral__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:15994:1: ( ( RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:15995:2: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:16127:1: ( ( RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:16128:2: ( RULE_INTEGER_LIT ) { - // InternalBehaviorAnnexParser.g:15995:2: ( RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:15996:3: RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:16128:2: ( RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:16129:3: RULE_INTEGER_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorIntegerLiteralAccess().getValueINTEGER_LITTerminalRuleCall_0()); @@ -52141,17 +52612,17 @@ public final void rule__BehaviorIntegerLiteral__ValueAssignment() throws Recogni // $ANTLR start "rule__BehaviorRealLiteral__ValueAssignment" - // InternalBehaviorAnnexParser.g:16005:1: rule__BehaviorRealLiteral__ValueAssignment : ( RULE_REAL_LIT ) ; + // InternalBehaviorAnnexParser.g:16138:1: rule__BehaviorRealLiteral__ValueAssignment : ( RULE_REAL_LIT ) ; public final void rule__BehaviorRealLiteral__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16009:1: ( ( RULE_REAL_LIT ) ) - // InternalBehaviorAnnexParser.g:16010:2: ( RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:16142:1: ( ( RULE_REAL_LIT ) ) + // InternalBehaviorAnnexParser.g:16143:2: ( RULE_REAL_LIT ) { - // InternalBehaviorAnnexParser.g:16010:2: ( RULE_REAL_LIT ) - // InternalBehaviorAnnexParser.g:16011:3: RULE_REAL_LIT + // InternalBehaviorAnnexParser.g:16143:2: ( RULE_REAL_LIT ) + // InternalBehaviorAnnexParser.g:16144:3: RULE_REAL_LIT { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorRealLiteralAccess().getValueREAL_LITTerminalRuleCall_0()); @@ -52182,17 +52653,17 @@ public final void rule__BehaviorRealLiteral__ValueAssignment() throws Recognitio // $ANTLR start "rule__BehaviorStringLiteral__ValueAssignment" - // InternalBehaviorAnnexParser.g:16020:1: rule__BehaviorStringLiteral__ValueAssignment : ( RULE_STRING ) ; + // InternalBehaviorAnnexParser.g:16153:1: rule__BehaviorStringLiteral__ValueAssignment : ( RULE_STRING ) ; public final void rule__BehaviorStringLiteral__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16024:1: ( ( RULE_STRING ) ) - // InternalBehaviorAnnexParser.g:16025:2: ( RULE_STRING ) + // InternalBehaviorAnnexParser.g:16157:1: ( ( RULE_STRING ) ) + // InternalBehaviorAnnexParser.g:16158:2: ( RULE_STRING ) { - // InternalBehaviorAnnexParser.g:16025:2: ( RULE_STRING ) - // InternalBehaviorAnnexParser.g:16026:3: RULE_STRING + // InternalBehaviorAnnexParser.g:16158:2: ( RULE_STRING ) + // InternalBehaviorAnnexParser.g:16159:3: RULE_STRING { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); @@ -52223,23 +52694,23 @@ public final void rule__BehaviorStringLiteral__ValueAssignment() throws Recognit // $ANTLR start "rule__BehaviorBooleanLiteral__ValueAssignment_1_0" - // InternalBehaviorAnnexParser.g:16035:1: rule__BehaviorBooleanLiteral__ValueAssignment_1_0 : ( ( True ) ) ; + // InternalBehaviorAnnexParser.g:16168:1: rule__BehaviorBooleanLiteral__ValueAssignment_1_0 : ( ( True ) ) ; public final void rule__BehaviorBooleanLiteral__ValueAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16039:1: ( ( ( True ) ) ) - // InternalBehaviorAnnexParser.g:16040:2: ( ( True ) ) + // InternalBehaviorAnnexParser.g:16172:1: ( ( ( True ) ) ) + // InternalBehaviorAnnexParser.g:16173:2: ( ( True ) ) { - // InternalBehaviorAnnexParser.g:16040:2: ( ( True ) ) - // InternalBehaviorAnnexParser.g:16041:3: ( True ) + // InternalBehaviorAnnexParser.g:16173:2: ( ( True ) ) + // InternalBehaviorAnnexParser.g:16174:3: ( True ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getValueTrueKeyword_1_0_0()); } - // InternalBehaviorAnnexParser.g:16042:3: ( True ) - // InternalBehaviorAnnexParser.g:16043:4: True + // InternalBehaviorAnnexParser.g:16175:3: ( True ) + // InternalBehaviorAnnexParser.g:16176:4: True { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorBooleanLiteralAccess().getValueTrueKeyword_1_0_0()); @@ -52276,17 +52747,17 @@ public final void rule__BehaviorBooleanLiteral__ValueAssignment_1_0() throws Rec // $ANTLR start "rule__ReferenceExpression__ReferenceAssignment_0" - // InternalBehaviorAnnexParser.g:16054:1: rule__ReferenceExpression__ReferenceAssignment_0 : ( ruleReference ) ; + // InternalBehaviorAnnexParser.g:16187:1: rule__ReferenceExpression__ReferenceAssignment_0 : ( ruleReference ) ; public final void rule__ReferenceExpression__ReferenceAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16058:1: ( ( ruleReference ) ) - // InternalBehaviorAnnexParser.g:16059:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:16191:1: ( ( ruleReference ) ) + // InternalBehaviorAnnexParser.g:16192:2: ( ruleReference ) { - // InternalBehaviorAnnexParser.g:16059:2: ( ruleReference ) - // InternalBehaviorAnnexParser.g:16060:3: ruleReference + // InternalBehaviorAnnexParser.g:16192:2: ( ruleReference ) + // InternalBehaviorAnnexParser.g:16193:3: ruleReference { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getReferenceReferenceParserRuleCall_0_0()); @@ -52321,17 +52792,17 @@ public final void rule__ReferenceExpression__ReferenceAssignment_0() throws Reco // $ANTLR start "rule__ReferenceExpression__PropertyAssignment_1_0" - // InternalBehaviorAnnexParser.g:16069:1: rule__ReferenceExpression__PropertyAssignment_1_0 : ( rulePropertyReferenceTail ) ; + // InternalBehaviorAnnexParser.g:16202:1: rule__ReferenceExpression__PropertyAssignment_1_0 : ( rulePropertyReferenceTail ) ; public final void rule__ReferenceExpression__PropertyAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16073:1: ( ( rulePropertyReferenceTail ) ) - // InternalBehaviorAnnexParser.g:16074:2: ( rulePropertyReferenceTail ) + // InternalBehaviorAnnexParser.g:16206:1: ( ( rulePropertyReferenceTail ) ) + // InternalBehaviorAnnexParser.g:16207:2: ( rulePropertyReferenceTail ) { - // InternalBehaviorAnnexParser.g:16074:2: ( rulePropertyReferenceTail ) - // InternalBehaviorAnnexParser.g:16075:3: rulePropertyReferenceTail + // InternalBehaviorAnnexParser.g:16207:2: ( rulePropertyReferenceTail ) + // InternalBehaviorAnnexParser.g:16208:3: rulePropertyReferenceTail { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getPropertyPropertyReferenceTailParserRuleCall_1_0_0()); @@ -52366,23 +52837,23 @@ public final void rule__ReferenceExpression__PropertyAssignment_1_0() throws Rec // $ANTLR start "rule__ReferenceExpression__DequeueAssignment_1_1" - // InternalBehaviorAnnexParser.g:16084:1: rule__ReferenceExpression__DequeueAssignment_1_1 : ( ( QuestionMark ) ) ; + // InternalBehaviorAnnexParser.g:16217:1: rule__ReferenceExpression__DequeueAssignment_1_1 : ( ( QuestionMark ) ) ; public final void rule__ReferenceExpression__DequeueAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16088:1: ( ( ( QuestionMark ) ) ) - // InternalBehaviorAnnexParser.g:16089:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:16221:1: ( ( ( QuestionMark ) ) ) + // InternalBehaviorAnnexParser.g:16222:2: ( ( QuestionMark ) ) { - // InternalBehaviorAnnexParser.g:16089:2: ( ( QuestionMark ) ) - // InternalBehaviorAnnexParser.g:16090:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:16222:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:16223:3: ( QuestionMark ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getDequeueQuestionMarkKeyword_1_1_0()); } - // InternalBehaviorAnnexParser.g:16091:3: ( QuestionMark ) - // InternalBehaviorAnnexParser.g:16092:4: QuestionMark + // InternalBehaviorAnnexParser.g:16224:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:16225:4: QuestionMark { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getDequeueQuestionMarkKeyword_1_1_0()); @@ -52419,23 +52890,23 @@ public final void rule__ReferenceExpression__DequeueAssignment_1_1() throws Reco // $ANTLR start "rule__ReferenceExpression__CountAssignment_1_2_1_0" - // InternalBehaviorAnnexParser.g:16103:1: rule__ReferenceExpression__CountAssignment_1_2_1_0 : ( ( Count ) ) ; + // InternalBehaviorAnnexParser.g:16236: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:16107:1: ( ( ( Count ) ) ) - // InternalBehaviorAnnexParser.g:16108:2: ( ( Count ) ) + // InternalBehaviorAnnexParser.g:16240:1: ( ( ( Count ) ) ) + // InternalBehaviorAnnexParser.g:16241:2: ( ( Count ) ) { - // InternalBehaviorAnnexParser.g:16108:2: ( ( Count ) ) - // InternalBehaviorAnnexParser.g:16109:3: ( Count ) + // InternalBehaviorAnnexParser.g:16241:2: ( ( Count ) ) + // InternalBehaviorAnnexParser.g:16242:3: ( Count ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getCountCountKeyword_1_2_1_0_0()); } - // InternalBehaviorAnnexParser.g:16110:3: ( Count ) - // InternalBehaviorAnnexParser.g:16111:4: Count + // InternalBehaviorAnnexParser.g:16243:3: ( Count ) + // InternalBehaviorAnnexParser.g:16244:4: Count { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getCountCountKeyword_1_2_1_0_0()); @@ -52472,23 +52943,23 @@ public final void rule__ReferenceExpression__CountAssignment_1_2_1_0() throws Re // $ANTLR start "rule__ReferenceExpression__FreshAssignment_1_2_1_1" - // InternalBehaviorAnnexParser.g:16122:1: rule__ReferenceExpression__FreshAssignment_1_2_1_1 : ( ( Fresh ) ) ; + // InternalBehaviorAnnexParser.g:16255: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:16126:1: ( ( ( Fresh ) ) ) - // InternalBehaviorAnnexParser.g:16127:2: ( ( Fresh ) ) + // InternalBehaviorAnnexParser.g:16259:1: ( ( ( Fresh ) ) ) + // InternalBehaviorAnnexParser.g:16260:2: ( ( Fresh ) ) { - // InternalBehaviorAnnexParser.g:16127:2: ( ( Fresh ) ) - // InternalBehaviorAnnexParser.g:16128:3: ( Fresh ) + // InternalBehaviorAnnexParser.g:16260:2: ( ( Fresh ) ) + // InternalBehaviorAnnexParser.g:16261:3: ( Fresh ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getFreshFreshKeyword_1_2_1_1_0()); } - // InternalBehaviorAnnexParser.g:16129:3: ( Fresh ) - // InternalBehaviorAnnexParser.g:16130:4: Fresh + // InternalBehaviorAnnexParser.g:16262:3: ( Fresh ) + // InternalBehaviorAnnexParser.g:16263:4: Fresh { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getFreshFreshKeyword_1_2_1_1_0()); @@ -52525,23 +52996,23 @@ public final void rule__ReferenceExpression__FreshAssignment_1_2_1_1() throws Re // $ANTLR start "rule__ReferenceExpression__UpdatedAssignment_1_2_1_2" - // InternalBehaviorAnnexParser.g:16141:1: rule__ReferenceExpression__UpdatedAssignment_1_2_1_2 : ( ( Updated ) ) ; + // InternalBehaviorAnnexParser.g:16274: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:16145:1: ( ( ( Updated ) ) ) - // InternalBehaviorAnnexParser.g:16146:2: ( ( Updated ) ) + // InternalBehaviorAnnexParser.g:16278:1: ( ( ( Updated ) ) ) + // InternalBehaviorAnnexParser.g:16279:2: ( ( Updated ) ) { - // InternalBehaviorAnnexParser.g:16146:2: ( ( Updated ) ) - // InternalBehaviorAnnexParser.g:16147:3: ( Updated ) + // InternalBehaviorAnnexParser.g:16279:2: ( ( Updated ) ) + // InternalBehaviorAnnexParser.g:16280:3: ( Updated ) { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getUpdatedUpdatedKeyword_1_2_1_2_0()); } - // InternalBehaviorAnnexParser.g:16148:3: ( Updated ) - // InternalBehaviorAnnexParser.g:16149:4: Updated + // InternalBehaviorAnnexParser.g:16281:3: ( Updated ) + // InternalBehaviorAnnexParser.g:16282:4: Updated { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceExpressionAccess().getUpdatedUpdatedKeyword_1_2_1_2_0()); @@ -52578,17 +53049,17 @@ public final void rule__ReferenceExpression__UpdatedAssignment_1_2_1_2() throws // $ANTLR start "rule__HashPropertyReference__PropertyAssignment_1" - // InternalBehaviorAnnexParser.g:16160:1: rule__HashPropertyReference__PropertyAssignment_1 : ( ruleQualifiedName ) ; + // InternalBehaviorAnnexParser.g:16293:1: rule__HashPropertyReference__PropertyAssignment_1 : ( ruleQualifiedName ) ; public final void rule__HashPropertyReference__PropertyAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16164:1: ( ( ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:16165:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16297:1: ( ( ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:16298:2: ( ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:16165:2: ( ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:16166:3: ruleQualifiedName + // InternalBehaviorAnnexParser.g:16298:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16299:3: ruleQualifiedName { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getPropertyQualifiedNameParserRuleCall_1_0()); @@ -52623,17 +53094,17 @@ public final void rule__HashPropertyReference__PropertyAssignment_1() throws Rec // $ANTLR start "rule__HashPropertyReference__IndexesAssignment_2" - // InternalBehaviorAnnexParser.g:16175:1: rule__HashPropertyReference__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; + // InternalBehaviorAnnexParser.g:16308:1: rule__HashPropertyReference__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; public final void rule__HashPropertyReference__IndexesAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16179:1: ( ( rulePropertyArrayIndex ) ) - // InternalBehaviorAnnexParser.g:16180:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16312:1: ( ( rulePropertyArrayIndex ) ) + // InternalBehaviorAnnexParser.g:16313:2: ( rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:16180:2: ( rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:16181:3: rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:16313:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16314:3: rulePropertyArrayIndex { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getIndexesPropertyArrayIndexParserRuleCall_2_0()); @@ -52668,17 +53139,17 @@ public final void rule__HashPropertyReference__IndexesAssignment_2() throws Reco // $ANTLR start "rule__HashPropertyReference__FieldsAssignment_3" - // InternalBehaviorAnnexParser.g:16190:1: rule__HashPropertyReference__FieldsAssignment_3 : ( ruleNamedPropertyField ) ; + // InternalBehaviorAnnexParser.g:16323:1: rule__HashPropertyReference__FieldsAssignment_3 : ( ruleNamedPropertyField ) ; public final void rule__HashPropertyReference__FieldsAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16194:1: ( ( ruleNamedPropertyField ) ) - // InternalBehaviorAnnexParser.g:16195:2: ( ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:16327:1: ( ( ruleNamedPropertyField ) ) + // InternalBehaviorAnnexParser.g:16328:2: ( ruleNamedPropertyField ) { - // InternalBehaviorAnnexParser.g:16195:2: ( ruleNamedPropertyField ) - // InternalBehaviorAnnexParser.g:16196:3: ruleNamedPropertyField + // InternalBehaviorAnnexParser.g:16328:2: ( ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:16329:3: ruleNamedPropertyField { if ( state.backtracking==0 ) { before(grammarAccess.getHashPropertyReferenceAccess().getFieldsNamedPropertyFieldParserRuleCall_3_0()); @@ -52713,17 +53184,17 @@ public final void rule__HashPropertyReference__FieldsAssignment_3() throws Recog // $ANTLR start "rule__PropertyReferenceTail__PropertyAssignment_1" - // InternalBehaviorAnnexParser.g:16205:1: rule__PropertyReferenceTail__PropertyAssignment_1 : ( ruleQualifiedName ) ; + // InternalBehaviorAnnexParser.g:16338:1: rule__PropertyReferenceTail__PropertyAssignment_1 : ( ruleQualifiedName ) ; public final void rule__PropertyReferenceTail__PropertyAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16209:1: ( ( ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:16210:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16342:1: ( ( ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:16343:2: ( ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:16210:2: ( ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:16211:3: ruleQualifiedName + // InternalBehaviorAnnexParser.g:16343:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16344:3: ruleQualifiedName { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getPropertyQualifiedNameParserRuleCall_1_0()); @@ -52758,17 +53229,17 @@ public final void rule__PropertyReferenceTail__PropertyAssignment_1() throws Rec // $ANTLR start "rule__PropertyReferenceTail__IndexesAssignment_2" - // InternalBehaviorAnnexParser.g:16220:1: rule__PropertyReferenceTail__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; + // InternalBehaviorAnnexParser.g:16353:1: rule__PropertyReferenceTail__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; public final void rule__PropertyReferenceTail__IndexesAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16224:1: ( ( rulePropertyArrayIndex ) ) - // InternalBehaviorAnnexParser.g:16225:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16357:1: ( ( rulePropertyArrayIndex ) ) + // InternalBehaviorAnnexParser.g:16358:2: ( rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:16225:2: ( rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:16226:3: rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:16358:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16359:3: rulePropertyArrayIndex { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getIndexesPropertyArrayIndexParserRuleCall_2_0()); @@ -52803,17 +53274,17 @@ public final void rule__PropertyReferenceTail__IndexesAssignment_2() throws Reco // $ANTLR start "rule__PropertyReferenceTail__FieldsAssignment_3" - // InternalBehaviorAnnexParser.g:16235:1: rule__PropertyReferenceTail__FieldsAssignment_3 : ( ruleNamedPropertyField ) ; + // InternalBehaviorAnnexParser.g:16368:1: rule__PropertyReferenceTail__FieldsAssignment_3 : ( ruleNamedPropertyField ) ; public final void rule__PropertyReferenceTail__FieldsAssignment_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16239:1: ( ( ruleNamedPropertyField ) ) - // InternalBehaviorAnnexParser.g:16240:2: ( ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:16372:1: ( ( ruleNamedPropertyField ) ) + // InternalBehaviorAnnexParser.g:16373:2: ( ruleNamedPropertyField ) { - // InternalBehaviorAnnexParser.g:16240:2: ( ruleNamedPropertyField ) - // InternalBehaviorAnnexParser.g:16241:3: ruleNamedPropertyField + // InternalBehaviorAnnexParser.g:16373:2: ( ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:16374:3: ruleNamedPropertyField { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyReferenceTailAccess().getFieldsNamedPropertyFieldParserRuleCall_3_0()); @@ -52848,17 +53319,17 @@ public final void rule__PropertyReferenceTail__FieldsAssignment_3() throws Recog // $ANTLR start "rule__NamedPropertyField__NameAssignment_1" - // InternalBehaviorAnnexParser.g:16250:1: rule__NamedPropertyField__NameAssignment_1 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:16383:1: rule__NamedPropertyField__NameAssignment_1 : ( RULE_ID ) ; public final void rule__NamedPropertyField__NameAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16254:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16255:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16387:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16388:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:16255:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16256:3: RULE_ID + // InternalBehaviorAnnexParser.g:16388:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16389:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getNameIDTerminalRuleCall_1_0()); @@ -52889,17 +53360,17 @@ public final void rule__NamedPropertyField__NameAssignment_1() throws Recognitio // $ANTLR start "rule__NamedPropertyField__IndexesAssignment_2" - // InternalBehaviorAnnexParser.g:16265:1: rule__NamedPropertyField__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; + // InternalBehaviorAnnexParser.g:16398:1: rule__NamedPropertyField__IndexesAssignment_2 : ( rulePropertyArrayIndex ) ; public final void rule__NamedPropertyField__IndexesAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16269:1: ( ( rulePropertyArrayIndex ) ) - // InternalBehaviorAnnexParser.g:16270:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16402:1: ( ( rulePropertyArrayIndex ) ) + // InternalBehaviorAnnexParser.g:16403:2: ( rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:16270:2: ( rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:16271:3: rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:16403:2: ( rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:16404:3: rulePropertyArrayIndex { if ( state.backtracking==0 ) { before(grammarAccess.getNamedPropertyFieldAccess().getIndexesPropertyArrayIndexParserRuleCall_2_0()); @@ -52934,17 +53405,17 @@ public final void rule__NamedPropertyField__IndexesAssignment_2() throws Recogni // $ANTLR start "rule__PropertyArrayIndex__ValueAssignment_1" - // InternalBehaviorAnnexParser.g:16280:1: rule__PropertyArrayIndex__ValueAssignment_1 : ( rulePropertyIndexValue ) ; + // InternalBehaviorAnnexParser.g:16413:1: rule__PropertyArrayIndex__ValueAssignment_1 : ( rulePropertyIndexValue ) ; public final void rule__PropertyArrayIndex__ValueAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16284:1: ( ( rulePropertyIndexValue ) ) - // InternalBehaviorAnnexParser.g:16285:2: ( rulePropertyIndexValue ) + // InternalBehaviorAnnexParser.g:16417:1: ( ( rulePropertyIndexValue ) ) + // InternalBehaviorAnnexParser.g:16418:2: ( rulePropertyIndexValue ) { - // InternalBehaviorAnnexParser.g:16285:2: ( rulePropertyIndexValue ) - // InternalBehaviorAnnexParser.g:16286:3: rulePropertyIndexValue + // InternalBehaviorAnnexParser.g:16418:2: ( rulePropertyIndexValue ) + // InternalBehaviorAnnexParser.g:16419:3: rulePropertyIndexValue { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyArrayIndexAccess().getValuePropertyIndexValueParserRuleCall_1_0()); @@ -52979,17 +53450,17 @@ public final void rule__PropertyArrayIndex__ValueAssignment_1() throws Recogniti // $ANTLR start "rule__PropertyIndexPropertyReference__PropertyAssignment_1" - // InternalBehaviorAnnexParser.g:16295:1: rule__PropertyIndexPropertyReference__PropertyAssignment_1 : ( ruleQualifiedName ) ; + // InternalBehaviorAnnexParser.g:16428:1: rule__PropertyIndexPropertyReference__PropertyAssignment_1 : ( ruleQualifiedName ) ; public final void rule__PropertyIndexPropertyReference__PropertyAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16299:1: ( ( ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:16300:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16432:1: ( ( ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:16433:2: ( ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:16300:2: ( ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:16301:3: ruleQualifiedName + // InternalBehaviorAnnexParser.g:16433:2: ( ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:16434:3: ruleQualifiedName { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyIndexPropertyReferenceAccess().getPropertyQualifiedNameParserRuleCall_1_0()); @@ -53024,17 +53495,17 @@ public final void rule__PropertyIndexPropertyReference__PropertyAssignment_1() t // $ANTLR start "rule__UnindexedReferenceExpression__ReferenceAssignment_0" - // InternalBehaviorAnnexParser.g:16310:1: rule__UnindexedReferenceExpression__ReferenceAssignment_0 : ( ruleUnindexedReference ) ; + // InternalBehaviorAnnexParser.g:16443:1: rule__UnindexedReferenceExpression__ReferenceAssignment_0 : ( ruleUnindexedReference ) ; public final void rule__UnindexedReferenceExpression__ReferenceAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16314:1: ( ( ruleUnindexedReference ) ) - // InternalBehaviorAnnexParser.g:16315:2: ( ruleUnindexedReference ) + // InternalBehaviorAnnexParser.g:16447:1: ( ( ruleUnindexedReference ) ) + // InternalBehaviorAnnexParser.g:16448:2: ( ruleUnindexedReference ) { - // InternalBehaviorAnnexParser.g:16315:2: ( ruleUnindexedReference ) - // InternalBehaviorAnnexParser.g:16316:3: ruleUnindexedReference + // InternalBehaviorAnnexParser.g:16448:2: ( ruleUnindexedReference ) + // InternalBehaviorAnnexParser.g:16449:3: ruleUnindexedReference { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getReferenceUnindexedReferenceParserRuleCall_0_0()); @@ -53069,23 +53540,23 @@ public final void rule__UnindexedReferenceExpression__ReferenceAssignment_0() th // $ANTLR start "rule__UnindexedReferenceExpression__DequeueAssignment_1_0" - // InternalBehaviorAnnexParser.g:16325:1: rule__UnindexedReferenceExpression__DequeueAssignment_1_0 : ( ( QuestionMark ) ) ; + // InternalBehaviorAnnexParser.g:16458:1: rule__UnindexedReferenceExpression__DequeueAssignment_1_0 : ( ( QuestionMark ) ) ; public final void rule__UnindexedReferenceExpression__DequeueAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16329:1: ( ( ( QuestionMark ) ) ) - // InternalBehaviorAnnexParser.g:16330:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:16462:1: ( ( ( QuestionMark ) ) ) + // InternalBehaviorAnnexParser.g:16463:2: ( ( QuestionMark ) ) { - // InternalBehaviorAnnexParser.g:16330:2: ( ( QuestionMark ) ) - // InternalBehaviorAnnexParser.g:16331:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:16463:2: ( ( QuestionMark ) ) + // InternalBehaviorAnnexParser.g:16464:3: ( QuestionMark ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getDequeueQuestionMarkKeyword_1_0_0()); } - // InternalBehaviorAnnexParser.g:16332:3: ( QuestionMark ) - // InternalBehaviorAnnexParser.g:16333:4: QuestionMark + // InternalBehaviorAnnexParser.g:16465:3: ( QuestionMark ) + // InternalBehaviorAnnexParser.g:16466:4: QuestionMark { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getDequeueQuestionMarkKeyword_1_0_0()); @@ -53122,23 +53593,23 @@ public final void rule__UnindexedReferenceExpression__DequeueAssignment_1_0() th // $ANTLR start "rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0" - // InternalBehaviorAnnexParser.g:16344:1: rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0 : ( ( Count ) ) ; + // InternalBehaviorAnnexParser.g:16477: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:16348:1: ( ( ( Count ) ) ) - // InternalBehaviorAnnexParser.g:16349:2: ( ( Count ) ) + // InternalBehaviorAnnexParser.g:16481:1: ( ( ( Count ) ) ) + // InternalBehaviorAnnexParser.g:16482:2: ( ( Count ) ) { - // InternalBehaviorAnnexParser.g:16349:2: ( ( Count ) ) - // InternalBehaviorAnnexParser.g:16350:3: ( Count ) + // InternalBehaviorAnnexParser.g:16482:2: ( ( Count ) ) + // InternalBehaviorAnnexParser.g:16483:3: ( Count ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getCountCountKeyword_1_1_1_0_0()); } - // InternalBehaviorAnnexParser.g:16351:3: ( Count ) - // InternalBehaviorAnnexParser.g:16352:4: Count + // InternalBehaviorAnnexParser.g:16484:3: ( Count ) + // InternalBehaviorAnnexParser.g:16485:4: Count { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getCountCountKeyword_1_1_1_0_0()); @@ -53175,23 +53646,23 @@ public final void rule__UnindexedReferenceExpression__CountAssignment_1_1_1_0() // $ANTLR start "rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1" - // InternalBehaviorAnnexParser.g:16363:1: rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1 : ( ( Fresh ) ) ; + // InternalBehaviorAnnexParser.g:16496: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:16367:1: ( ( ( Fresh ) ) ) - // InternalBehaviorAnnexParser.g:16368:2: ( ( Fresh ) ) + // InternalBehaviorAnnexParser.g:16500:1: ( ( ( Fresh ) ) ) + // InternalBehaviorAnnexParser.g:16501:2: ( ( Fresh ) ) { - // InternalBehaviorAnnexParser.g:16368:2: ( ( Fresh ) ) - // InternalBehaviorAnnexParser.g:16369:3: ( Fresh ) + // InternalBehaviorAnnexParser.g:16501:2: ( ( Fresh ) ) + // InternalBehaviorAnnexParser.g:16502:3: ( Fresh ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getFreshFreshKeyword_1_1_1_1_0()); } - // InternalBehaviorAnnexParser.g:16370:3: ( Fresh ) - // InternalBehaviorAnnexParser.g:16371:4: Fresh + // InternalBehaviorAnnexParser.g:16503:3: ( Fresh ) + // InternalBehaviorAnnexParser.g:16504:4: Fresh { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getFreshFreshKeyword_1_1_1_1_0()); @@ -53228,23 +53699,23 @@ public final void rule__UnindexedReferenceExpression__FreshAssignment_1_1_1_1() // $ANTLR start "rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2" - // InternalBehaviorAnnexParser.g:16382:1: rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2 : ( ( Updated ) ) ; + // InternalBehaviorAnnexParser.g:16515: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:16386:1: ( ( ( Updated ) ) ) - // InternalBehaviorAnnexParser.g:16387:2: ( ( Updated ) ) + // InternalBehaviorAnnexParser.g:16519:1: ( ( ( Updated ) ) ) + // InternalBehaviorAnnexParser.g:16520:2: ( ( Updated ) ) { - // InternalBehaviorAnnexParser.g:16387:2: ( ( Updated ) ) - // InternalBehaviorAnnexParser.g:16388:3: ( Updated ) + // InternalBehaviorAnnexParser.g:16520:2: ( ( Updated ) ) + // InternalBehaviorAnnexParser.g:16521:3: ( Updated ) { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getUpdatedUpdatedKeyword_1_1_1_2_0()); } - // InternalBehaviorAnnexParser.g:16389:3: ( Updated ) - // InternalBehaviorAnnexParser.g:16390:4: Updated + // InternalBehaviorAnnexParser.g:16522:3: ( Updated ) + // InternalBehaviorAnnexParser.g:16523:4: Updated { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceExpressionAccess().getUpdatedUpdatedKeyword_1_1_1_2_0()); @@ -53281,17 +53752,17 @@ public final void rule__UnindexedReferenceExpression__UpdatedAssignment_1_1_1_2( // $ANTLR start "rule__UnindexedReference__SegmentsAssignment_0" - // InternalBehaviorAnnexParser.g:16401:1: rule__UnindexedReference__SegmentsAssignment_0 : ( ruleUnindexedReferenceSegment ) ; + // InternalBehaviorAnnexParser.g:16534:1: rule__UnindexedReference__SegmentsAssignment_0 : ( ruleUnindexedReferenceSegment ) ; public final void rule__UnindexedReference__SegmentsAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16405:1: ( ( ruleUnindexedReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:16406:2: ( ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:16538:1: ( ( ruleUnindexedReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:16539:2: ( ruleUnindexedReferenceSegment ) { - // InternalBehaviorAnnexParser.g:16406:2: ( ruleUnindexedReferenceSegment ) - // InternalBehaviorAnnexParser.g:16407:3: ruleUnindexedReferenceSegment + // InternalBehaviorAnnexParser.g:16539:2: ( ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:16540:3: ruleUnindexedReferenceSegment { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceAccess().getSegmentsUnindexedReferenceSegmentParserRuleCall_0_0()); @@ -53326,17 +53797,17 @@ public final void rule__UnindexedReference__SegmentsAssignment_0() throws Recogn // $ANTLR start "rule__UnindexedReference__TailsAssignment_1" - // InternalBehaviorAnnexParser.g:16416:1: rule__UnindexedReference__TailsAssignment_1 : ( ruleUnindexedReferenceTail ) ; + // InternalBehaviorAnnexParser.g:16549:1: rule__UnindexedReference__TailsAssignment_1 : ( ruleUnindexedReferenceTail ) ; public final void rule__UnindexedReference__TailsAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16420:1: ( ( ruleUnindexedReferenceTail ) ) - // InternalBehaviorAnnexParser.g:16421:2: ( ruleUnindexedReferenceTail ) + // InternalBehaviorAnnexParser.g:16553:1: ( ( ruleUnindexedReferenceTail ) ) + // InternalBehaviorAnnexParser.g:16554:2: ( ruleUnindexedReferenceTail ) { - // InternalBehaviorAnnexParser.g:16421:2: ( ruleUnindexedReferenceTail ) - // InternalBehaviorAnnexParser.g:16422:3: ruleUnindexedReferenceTail + // InternalBehaviorAnnexParser.g:16554:2: ( ruleUnindexedReferenceTail ) + // InternalBehaviorAnnexParser.g:16555:3: ruleUnindexedReferenceTail { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceAccess().getTailsUnindexedReferenceTailParserRuleCall_1_0()); @@ -53371,17 +53842,17 @@ public final void rule__UnindexedReference__TailsAssignment_1() throws Recogniti // $ANTLR start "rule__UnindexedReferenceTail__SeparatorAssignment_0" - // InternalBehaviorAnnexParser.g:16431:1: rule__UnindexedReferenceTail__SeparatorAssignment_0 : ( ruleReferenceSeparator ) ; + // InternalBehaviorAnnexParser.g:16564:1: rule__UnindexedReferenceTail__SeparatorAssignment_0 : ( ruleReferenceSeparator ) ; public final void rule__UnindexedReferenceTail__SeparatorAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16435:1: ( ( ruleReferenceSeparator ) ) - // InternalBehaviorAnnexParser.g:16436:2: ( ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:16568:1: ( ( ruleReferenceSeparator ) ) + // InternalBehaviorAnnexParser.g:16569:2: ( ruleReferenceSeparator ) { - // InternalBehaviorAnnexParser.g:16436:2: ( ruleReferenceSeparator ) - // InternalBehaviorAnnexParser.g:16437:3: ruleReferenceSeparator + // InternalBehaviorAnnexParser.g:16569:2: ( ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:16570:3: ruleReferenceSeparator { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceTailAccess().getSeparatorReferenceSeparatorParserRuleCall_0_0()); @@ -53416,17 +53887,17 @@ public final void rule__UnindexedReferenceTail__SeparatorAssignment_0() throws R // $ANTLR start "rule__UnindexedReferenceTail__SegmentAssignment_1" - // InternalBehaviorAnnexParser.g:16446:1: rule__UnindexedReferenceTail__SegmentAssignment_1 : ( ruleUnindexedReferenceSegment ) ; + // InternalBehaviorAnnexParser.g:16579:1: rule__UnindexedReferenceTail__SegmentAssignment_1 : ( ruleUnindexedReferenceSegment ) ; public final void rule__UnindexedReferenceTail__SegmentAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16450:1: ( ( ruleUnindexedReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:16451:2: ( ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:16583:1: ( ( ruleUnindexedReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:16584:2: ( ruleUnindexedReferenceSegment ) { - // InternalBehaviorAnnexParser.g:16451:2: ( ruleUnindexedReferenceSegment ) - // InternalBehaviorAnnexParser.g:16452:3: ruleUnindexedReferenceSegment + // InternalBehaviorAnnexParser.g:16584:2: ( ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:16585:3: ruleUnindexedReferenceSegment { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceTailAccess().getSegmentUnindexedReferenceSegmentParserRuleCall_1_0()); @@ -53461,17 +53932,17 @@ public final void rule__UnindexedReferenceTail__SegmentAssignment_1() throws Rec // $ANTLR start "rule__UnindexedReferenceSegment__NameAssignment" - // InternalBehaviorAnnexParser.g:16461:1: rule__UnindexedReferenceSegment__NameAssignment : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:16594:1: rule__UnindexedReferenceSegment__NameAssignment : ( RULE_ID ) ; public final void rule__UnindexedReferenceSegment__NameAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16465:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16466:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16598:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16599:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:16466:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16467:3: RULE_ID + // InternalBehaviorAnnexParser.g:16599:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16600:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getUnindexedReferenceSegmentAccess().getNameIDTerminalRuleCall_0()); @@ -53502,17 +53973,17 @@ public final void rule__UnindexedReferenceSegment__NameAssignment() throws Recog // $ANTLR start "rule__Reference__SegmentsAssignment_0" - // InternalBehaviorAnnexParser.g:16476:1: rule__Reference__SegmentsAssignment_0 : ( ruleReferenceSegment ) ; + // InternalBehaviorAnnexParser.g:16609:1: rule__Reference__SegmentsAssignment_0 : ( ruleReferenceSegment ) ; public final void rule__Reference__SegmentsAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16480:1: ( ( ruleReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:16481:2: ( ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:16613:1: ( ( ruleReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:16614:2: ( ruleReferenceSegment ) { - // InternalBehaviorAnnexParser.g:16481:2: ( ruleReferenceSegment ) - // InternalBehaviorAnnexParser.g:16482:3: ruleReferenceSegment + // InternalBehaviorAnnexParser.g:16614:2: ( ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:16615:3: ruleReferenceSegment { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceAccess().getSegmentsReferenceSegmentParserRuleCall_0_0()); @@ -53547,17 +54018,17 @@ public final void rule__Reference__SegmentsAssignment_0() throws RecognitionExce // $ANTLR start "rule__Reference__TailsAssignment_1" - // InternalBehaviorAnnexParser.g:16491:1: rule__Reference__TailsAssignment_1 : ( ruleReferenceTail ) ; + // InternalBehaviorAnnexParser.g:16624:1: rule__Reference__TailsAssignment_1 : ( ruleReferenceTail ) ; public final void rule__Reference__TailsAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16495:1: ( ( ruleReferenceTail ) ) - // InternalBehaviorAnnexParser.g:16496:2: ( ruleReferenceTail ) + // InternalBehaviorAnnexParser.g:16628:1: ( ( ruleReferenceTail ) ) + // InternalBehaviorAnnexParser.g:16629:2: ( ruleReferenceTail ) { - // InternalBehaviorAnnexParser.g:16496:2: ( ruleReferenceTail ) - // InternalBehaviorAnnexParser.g:16497:3: ruleReferenceTail + // InternalBehaviorAnnexParser.g:16629:2: ( ruleReferenceTail ) + // InternalBehaviorAnnexParser.g:16630:3: ruleReferenceTail { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceAccess().getTailsReferenceTailParserRuleCall_1_0()); @@ -53592,17 +54063,17 @@ public final void rule__Reference__TailsAssignment_1() throws RecognitionExcepti // $ANTLR start "rule__ReferenceTail__SeparatorAssignment_0" - // InternalBehaviorAnnexParser.g:16506:1: rule__ReferenceTail__SeparatorAssignment_0 : ( ruleReferenceSeparator ) ; + // InternalBehaviorAnnexParser.g:16639:1: rule__ReferenceTail__SeparatorAssignment_0 : ( ruleReferenceSeparator ) ; public final void rule__ReferenceTail__SeparatorAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16510:1: ( ( ruleReferenceSeparator ) ) - // InternalBehaviorAnnexParser.g:16511:2: ( ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:16643:1: ( ( ruleReferenceSeparator ) ) + // InternalBehaviorAnnexParser.g:16644:2: ( ruleReferenceSeparator ) { - // InternalBehaviorAnnexParser.g:16511:2: ( ruleReferenceSeparator ) - // InternalBehaviorAnnexParser.g:16512:3: ruleReferenceSeparator + // InternalBehaviorAnnexParser.g:16644:2: ( ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:16645:3: ruleReferenceSeparator { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTailAccess().getSeparatorReferenceSeparatorParserRuleCall_0_0()); @@ -53637,17 +54108,17 @@ public final void rule__ReferenceTail__SeparatorAssignment_0() throws Recognitio // $ANTLR start "rule__ReferenceTail__SegmentAssignment_1" - // InternalBehaviorAnnexParser.g:16521:1: rule__ReferenceTail__SegmentAssignment_1 : ( ruleReferenceSegment ) ; + // InternalBehaviorAnnexParser.g:16654:1: rule__ReferenceTail__SegmentAssignment_1 : ( ruleReferenceSegment ) ; public final void rule__ReferenceTail__SegmentAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16525:1: ( ( ruleReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:16526:2: ( ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:16658:1: ( ( ruleReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:16659:2: ( ruleReferenceSegment ) { - // InternalBehaviorAnnexParser.g:16526:2: ( ruleReferenceSegment ) - // InternalBehaviorAnnexParser.g:16527:3: ruleReferenceSegment + // InternalBehaviorAnnexParser.g:16659:2: ( ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:16660:3: ruleReferenceSegment { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTailAccess().getSegmentReferenceSegmentParserRuleCall_1_0()); @@ -53682,17 +54153,17 @@ public final void rule__ReferenceTail__SegmentAssignment_1() throws RecognitionE // $ANTLR start "rule__ReferenceSegment__NameAssignment_0" - // InternalBehaviorAnnexParser.g:16536:1: rule__ReferenceSegment__NameAssignment_0 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:16669:1: rule__ReferenceSegment__NameAssignment_0 : ( RULE_ID ) ; public final void rule__ReferenceSegment__NameAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16540:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16541:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16673:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16674:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:16541:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16542:3: RULE_ID + // InternalBehaviorAnnexParser.g:16674:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16675:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSegmentAccess().getNameIDTerminalRuleCall_0_0()); @@ -53723,17 +54194,17 @@ public final void rule__ReferenceSegment__NameAssignment_0() throws RecognitionE // $ANTLR start "rule__ReferenceSegment__IndexesAssignment_1" - // InternalBehaviorAnnexParser.g:16551:1: rule__ReferenceSegment__IndexesAssignment_1 : ( ruleArrayIndex ) ; + // InternalBehaviorAnnexParser.g:16684:1: rule__ReferenceSegment__IndexesAssignment_1 : ( ruleArrayIndex ) ; public final void rule__ReferenceSegment__IndexesAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16555:1: ( ( ruleArrayIndex ) ) - // InternalBehaviorAnnexParser.g:16556:2: ( ruleArrayIndex ) + // InternalBehaviorAnnexParser.g:16688:1: ( ( ruleArrayIndex ) ) + // InternalBehaviorAnnexParser.g:16689:2: ( ruleArrayIndex ) { - // InternalBehaviorAnnexParser.g:16556:2: ( ruleArrayIndex ) - // InternalBehaviorAnnexParser.g:16557:3: ruleArrayIndex + // InternalBehaviorAnnexParser.g:16689:2: ( ruleArrayIndex ) + // InternalBehaviorAnnexParser.g:16690:3: ruleArrayIndex { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceSegmentAccess().getIndexesArrayIndexParserRuleCall_1_0()); @@ -53768,17 +54239,17 @@ public final void rule__ReferenceSegment__IndexesAssignment_1() throws Recogniti // $ANTLR start "rule__ArrayIndex__ValueAssignment_1" - // InternalBehaviorAnnexParser.g:16566:1: rule__ArrayIndex__ValueAssignment_1 : ( ruleIntegerValue ) ; + // InternalBehaviorAnnexParser.g:16699:1: rule__ArrayIndex__ValueAssignment_1 : ( ruleIntegerValue ) ; public final void rule__ArrayIndex__ValueAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16570:1: ( ( ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:16571:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:16703:1: ( ( ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:16704:2: ( ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:16571:2: ( ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:16572:3: ruleIntegerValue + // InternalBehaviorAnnexParser.g:16704:2: ( ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:16705:3: ruleIntegerValue { if ( state.backtracking==0 ) { before(grammarAccess.getArrayIndexAccess().getValueIntegerValueParserRuleCall_1_0()); @@ -53813,23 +54284,23 @@ public final void rule__ArrayIndex__ValueAssignment_1() throws RecognitionExcept // $ANTLR start "rule__ContainedPropertyAssociation__PropertyAssignment_0" - // InternalBehaviorAnnexParser.g:16581:1: rule__ContainedPropertyAssociation__PropertyAssignment_0 : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:16714:1: rule__ContainedPropertyAssociation__PropertyAssignment_0 : ( ( ruleQPREF ) ) ; public final void rule__ContainedPropertyAssociation__PropertyAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16585:1: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:16586:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:16718:1: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:16719:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:16586:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:16587:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:16719:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:16720:3: ( ruleQPREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getPropertyPropertyCrossReference_0_0()); } - // InternalBehaviorAnnexParser.g:16588:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:16589:4: ruleQPREF + // InternalBehaviorAnnexParser.g:16721:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:16722:4: ruleQPREF { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getPropertyPropertyQPREFParserRuleCall_0_0_1()); @@ -53870,23 +54341,23 @@ public final void rule__ContainedPropertyAssociation__PropertyAssignment_0() thr // $ANTLR start "rule__ContainedPropertyAssociation__AppendAssignment_1_1" - // InternalBehaviorAnnexParser.g:16600:1: rule__ContainedPropertyAssociation__AppendAssignment_1_1 : ( ( PlusSignEqualsSignGreaterThanSign ) ) ; + // InternalBehaviorAnnexParser.g:16733:1: rule__ContainedPropertyAssociation__AppendAssignment_1_1 : ( ( PlusSignEqualsSignGreaterThanSign ) ) ; public final void rule__ContainedPropertyAssociation__AppendAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16604:1: ( ( ( PlusSignEqualsSignGreaterThanSign ) ) ) - // InternalBehaviorAnnexParser.g:16605:2: ( ( PlusSignEqualsSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:16737:1: ( ( ( PlusSignEqualsSignGreaterThanSign ) ) ) + // InternalBehaviorAnnexParser.g:16738:2: ( ( PlusSignEqualsSignGreaterThanSign ) ) { - // InternalBehaviorAnnexParser.g:16605:2: ( ( PlusSignEqualsSignGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:16606:3: ( PlusSignEqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:16738:2: ( ( PlusSignEqualsSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:16739:3: ( PlusSignEqualsSignGreaterThanSign ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppendPlusSignEqualsSignGreaterThanSignKeyword_1_1_0()); } - // InternalBehaviorAnnexParser.g:16607:3: ( PlusSignEqualsSignGreaterThanSign ) - // InternalBehaviorAnnexParser.g:16608:4: PlusSignEqualsSignGreaterThanSign + // InternalBehaviorAnnexParser.g:16740:3: ( PlusSignEqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:16741:4: PlusSignEqualsSignGreaterThanSign { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppendPlusSignEqualsSignGreaterThanSignKeyword_1_1_0()); @@ -53923,23 +54394,23 @@ public final void rule__ContainedPropertyAssociation__AppendAssignment_1_1() thr // $ANTLR start "rule__ContainedPropertyAssociation__ConstantAssignment_2" - // InternalBehaviorAnnexParser.g:16619:1: rule__ContainedPropertyAssociation__ConstantAssignment_2 : ( ( Constant ) ) ; + // InternalBehaviorAnnexParser.g:16752:1: rule__ContainedPropertyAssociation__ConstantAssignment_2 : ( ( Constant ) ) ; public final void rule__ContainedPropertyAssociation__ConstantAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16623:1: ( ( ( Constant ) ) ) - // InternalBehaviorAnnexParser.g:16624:2: ( ( Constant ) ) + // InternalBehaviorAnnexParser.g:16756:1: ( ( ( Constant ) ) ) + // InternalBehaviorAnnexParser.g:16757:2: ( ( Constant ) ) { - // InternalBehaviorAnnexParser.g:16624:2: ( ( Constant ) ) - // InternalBehaviorAnnexParser.g:16625:3: ( Constant ) + // InternalBehaviorAnnexParser.g:16757:2: ( ( Constant ) ) + // InternalBehaviorAnnexParser.g:16758:3: ( Constant ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getConstantConstantKeyword_2_0()); } - // InternalBehaviorAnnexParser.g:16626:3: ( Constant ) - // InternalBehaviorAnnexParser.g:16627:4: Constant + // InternalBehaviorAnnexParser.g:16759:3: ( Constant ) + // InternalBehaviorAnnexParser.g:16760:4: Constant { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getConstantConstantKeyword_2_0()); @@ -53976,17 +54447,17 @@ public final void rule__ContainedPropertyAssociation__ConstantAssignment_2() thr // $ANTLR start "rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0" - // InternalBehaviorAnnexParser.g:16638:1: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 : ( ruleOptionalModalPropertyValue ) ; + // InternalBehaviorAnnexParser.g:16771:1: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0 : ( ruleOptionalModalPropertyValue ) ; public final void rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16642:1: ( ( ruleOptionalModalPropertyValue ) ) - // InternalBehaviorAnnexParser.g:16643:2: ( ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:16775:1: ( ( ruleOptionalModalPropertyValue ) ) + // InternalBehaviorAnnexParser.g:16776:2: ( ruleOptionalModalPropertyValue ) { - // InternalBehaviorAnnexParser.g:16643:2: ( ruleOptionalModalPropertyValue ) - // InternalBehaviorAnnexParser.g:16644:3: ruleOptionalModalPropertyValue + // InternalBehaviorAnnexParser.g:16776:2: ( ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:16777:3: ruleOptionalModalPropertyValue { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueOptionalModalPropertyValueParserRuleCall_3_0_0()); @@ -54021,17 +54492,17 @@ public final void rule__ContainedPropertyAssociation__OwnedValueAssignment_3_0() // $ANTLR start "rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1" - // InternalBehaviorAnnexParser.g:16653:1: rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 : ( ruleOptionalModalPropertyValue ) ; + // InternalBehaviorAnnexParser.g:16786: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:16657:1: ( ( ruleOptionalModalPropertyValue ) ) - // InternalBehaviorAnnexParser.g:16658:2: ( ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:16790:1: ( ( ruleOptionalModalPropertyValue ) ) + // InternalBehaviorAnnexParser.g:16791:2: ( ruleOptionalModalPropertyValue ) { - // InternalBehaviorAnnexParser.g:16658:2: ( ruleOptionalModalPropertyValue ) - // InternalBehaviorAnnexParser.g:16659:3: ruleOptionalModalPropertyValue + // InternalBehaviorAnnexParser.g:16791:2: ( ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:16792:3: ruleOptionalModalPropertyValue { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueOptionalModalPropertyValueParserRuleCall_3_1_1_0()); @@ -54066,17 +54537,17 @@ public final void rule__ContainedPropertyAssociation__OwnedValueAssignment_3_1_1 // $ANTLR start "rule__ContainedPropertyAssociation__AppliesToAssignment_4_2" - // InternalBehaviorAnnexParser.g:16668:1: rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 : ( ruleContainmentPath ) ; + // InternalBehaviorAnnexParser.g:16801:1: rule__ContainedPropertyAssociation__AppliesToAssignment_4_2 : ( ruleContainmentPath ) ; public final void rule__ContainedPropertyAssociation__AppliesToAssignment_4_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16672:1: ( ( ruleContainmentPath ) ) - // InternalBehaviorAnnexParser.g:16673:2: ( ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:16805:1: ( ( ruleContainmentPath ) ) + // InternalBehaviorAnnexParser.g:16806:2: ( ruleContainmentPath ) { - // InternalBehaviorAnnexParser.g:16673:2: ( ruleContainmentPath ) - // InternalBehaviorAnnexParser.g:16674:3: ruleContainmentPath + // InternalBehaviorAnnexParser.g:16806:2: ( ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:16807:3: ruleContainmentPath { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToContainmentPathParserRuleCall_4_2_0()); @@ -54111,17 +54582,17 @@ public final void rule__ContainedPropertyAssociation__AppliesToAssignment_4_2() // $ANTLR start "rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1" - // InternalBehaviorAnnexParser.g:16683:1: rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1 : ( ruleContainmentPath ) ; + // InternalBehaviorAnnexParser.g:16816: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:16687:1: ( ( ruleContainmentPath ) ) - // InternalBehaviorAnnexParser.g:16688:2: ( ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:16820:1: ( ( ruleContainmentPath ) ) + // InternalBehaviorAnnexParser.g:16821:2: ( ruleContainmentPath ) { - // InternalBehaviorAnnexParser.g:16688:2: ( ruleContainmentPath ) - // InternalBehaviorAnnexParser.g:16689:3: ruleContainmentPath + // InternalBehaviorAnnexParser.g:16821:2: ( ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:16822:3: ruleContainmentPath { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToContainmentPathParserRuleCall_4_3_1_0()); @@ -54156,23 +54627,23 @@ public final void rule__ContainedPropertyAssociation__AppliesToAssignment_4_3_1( // $ANTLR start "rule__ContainedPropertyAssociation__InBindingAssignment_5_3" - // InternalBehaviorAnnexParser.g:16698:1: rule__ContainedPropertyAssociation__InBindingAssignment_5_3 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:16831:1: rule__ContainedPropertyAssociation__InBindingAssignment_5_3 : ( ( ruleQCREF ) ) ; public final void rule__ContainedPropertyAssociation__InBindingAssignment_5_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16702:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:16703:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:16835:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:16836:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:16703:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:16704:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:16836:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:16837:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getInBindingClassifierCrossReference_5_3_0()); } - // InternalBehaviorAnnexParser.g:16705:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:16706:4: ruleQCREF + // InternalBehaviorAnnexParser.g:16838:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:16839:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getContainedPropertyAssociationAccess().getInBindingClassifierQCREFParserRuleCall_5_3_0_1()); @@ -54213,17 +54684,17 @@ public final void rule__ContainedPropertyAssociation__InBindingAssignment_5_3() // $ANTLR start "rule__ContainmentPath__PathAssignment" - // InternalBehaviorAnnexParser.g:16717:1: rule__ContainmentPath__PathAssignment : ( ruleContainmentPathElement ) ; + // InternalBehaviorAnnexParser.g:16850:1: rule__ContainmentPath__PathAssignment : ( ruleContainmentPathElement ) ; public final void rule__ContainmentPath__PathAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16721:1: ( ( ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:16722:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:16854:1: ( ( ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:16855:2: ( ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:16722:2: ( ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:16723:3: ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:16855:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:16856:3: ruleContainmentPathElement { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathAccess().getPathContainmentPathElementParserRuleCall_0()); @@ -54258,17 +54729,17 @@ public final void rule__ContainmentPath__PathAssignment() throws RecognitionExce // $ANTLR start "rule__OptionalModalPropertyValue__OwnedValueAssignment_0" - // InternalBehaviorAnnexParser.g:16732:1: rule__OptionalModalPropertyValue__OwnedValueAssignment_0 : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:16865:1: rule__OptionalModalPropertyValue__OwnedValueAssignment_0 : ( rulePropertyExpression ) ; public final void rule__OptionalModalPropertyValue__OwnedValueAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16736:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:16737:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:16869:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:16870:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:16737:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:16738:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:16870:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:16871:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getOwnedValuePropertyExpressionParserRuleCall_0_0()); @@ -54303,23 +54774,23 @@ public final void rule__OptionalModalPropertyValue__OwnedValueAssignment_0() thr // $ANTLR start "rule__OptionalModalPropertyValue__InModeAssignment_1_3" - // InternalBehaviorAnnexParser.g:16747:1: rule__OptionalModalPropertyValue__InModeAssignment_1_3 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:16880:1: rule__OptionalModalPropertyValue__InModeAssignment_1_3 : ( ( RULE_ID ) ) ; public final void rule__OptionalModalPropertyValue__InModeAssignment_1_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16751:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:16752:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16884:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:16885:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:16752:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16753:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16885:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16886:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeModeCrossReference_1_3_0()); } - // InternalBehaviorAnnexParser.g:16754:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16755:4: RULE_ID + // InternalBehaviorAnnexParser.g:16887:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16888:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeModeIDTerminalRuleCall_1_3_0_1()); @@ -54356,23 +54827,23 @@ public final void rule__OptionalModalPropertyValue__InModeAssignment_1_3() throw // $ANTLR start "rule__OptionalModalPropertyValue__InModeAssignment_1_4_1" - // InternalBehaviorAnnexParser.g:16766:1: rule__OptionalModalPropertyValue__InModeAssignment_1_4_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:16899: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:16770:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:16771:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16903:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:16904:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:16771:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16772:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16904:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:16905:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeModeCrossReference_1_4_1_0()); } - // InternalBehaviorAnnexParser.g:16773:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16774:4: RULE_ID + // InternalBehaviorAnnexParser.g:16906:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:16907:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getOptionalModalPropertyValueAccess().getInModeModeIDTerminalRuleCall_1_4_1_0_1()); @@ -54409,17 +54880,17 @@ public final void rule__OptionalModalPropertyValue__InModeAssignment_1_4_1() thr // $ANTLR start "rule__PropertyValue__OwnedValueAssignment" - // InternalBehaviorAnnexParser.g:16785:1: rule__PropertyValue__OwnedValueAssignment : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:16918:1: rule__PropertyValue__OwnedValueAssignment : ( rulePropertyExpression ) ; public final void rule__PropertyValue__OwnedValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16789:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:16790:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:16922:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:16923:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:16790:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:16791:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:16923:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:16924:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getPropertyValueAccess().getOwnedValuePropertyExpressionParserRuleCall_0()); @@ -54454,23 +54925,23 @@ public final void rule__PropertyValue__OwnedValueAssignment() throws Recognition // $ANTLR start "rule__LiteralorReferenceTerm__NamedValueAssignment" - // InternalBehaviorAnnexParser.g:16800:1: rule__LiteralorReferenceTerm__NamedValueAssignment : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:16933:1: rule__LiteralorReferenceTerm__NamedValueAssignment : ( ( ruleQPREF ) ) ; public final void rule__LiteralorReferenceTerm__NamedValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16804:1: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:16805:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:16937:1: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:16938:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:16805:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:16806:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:16938:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:16939:3: ( ruleQPREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getLiteralorReferenceTermAccess().getNamedValueAbstractNamedValueCrossReference_0()); } - // InternalBehaviorAnnexParser.g:16807:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:16808:4: ruleQPREF + // InternalBehaviorAnnexParser.g:16940:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:16941:4: ruleQPREF { if ( state.backtracking==0 ) { before(grammarAccess.getLiteralorReferenceTermAccess().getNamedValueAbstractNamedValueQPREFParserRuleCall_0_1()); @@ -54511,23 +54982,23 @@ public final void rule__LiteralorReferenceTerm__NamedValueAssignment() throws Re // $ANTLR start "rule__BooleanLiteral__ValueAssignment_1_0" - // InternalBehaviorAnnexParser.g:16819:1: rule__BooleanLiteral__ValueAssignment_1_0 : ( ( True ) ) ; + // InternalBehaviorAnnexParser.g:16952:1: rule__BooleanLiteral__ValueAssignment_1_0 : ( ( True ) ) ; public final void rule__BooleanLiteral__ValueAssignment_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16823:1: ( ( ( True ) ) ) - // InternalBehaviorAnnexParser.g:16824:2: ( ( True ) ) + // InternalBehaviorAnnexParser.g:16956:1: ( ( ( True ) ) ) + // InternalBehaviorAnnexParser.g:16957:2: ( ( True ) ) { - // InternalBehaviorAnnexParser.g:16824:2: ( ( True ) ) - // InternalBehaviorAnnexParser.g:16825:3: ( True ) + // InternalBehaviorAnnexParser.g:16957:2: ( ( True ) ) + // InternalBehaviorAnnexParser.g:16958:3: ( True ) { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getValueTrueKeyword_1_0_0()); } - // InternalBehaviorAnnexParser.g:16826:3: ( True ) - // InternalBehaviorAnnexParser.g:16827:4: True + // InternalBehaviorAnnexParser.g:16959:3: ( True ) + // InternalBehaviorAnnexParser.g:16960:4: True { if ( state.backtracking==0 ) { before(grammarAccess.getBooleanLiteralAccess().getValueTrueKeyword_1_0_0()); @@ -54564,23 +55035,23 @@ public final void rule__BooleanLiteral__ValueAssignment_1_0() throws Recognition // $ANTLR start "rule__ConstantValue__NamedValueAssignment" - // InternalBehaviorAnnexParser.g:16838:1: rule__ConstantValue__NamedValueAssignment : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:16971:1: rule__ConstantValue__NamedValueAssignment : ( ( ruleQPREF ) ) ; public final void rule__ConstantValue__NamedValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16842:1: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:16843:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:16975:1: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:16976:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:16843:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:16844:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:16976:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:16977:3: ( ruleQPREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getConstantValueAccess().getNamedValuePropertyConstantCrossReference_0()); } - // InternalBehaviorAnnexParser.g:16845:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:16846:4: ruleQPREF + // InternalBehaviorAnnexParser.g:16978:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:16979:4: ruleQPREF { if ( state.backtracking==0 ) { before(grammarAccess.getConstantValueAccess().getNamedValuePropertyConstantQPREFParserRuleCall_0_1()); @@ -54621,17 +55092,17 @@ public final void rule__ConstantValue__NamedValueAssignment() throws Recognition // $ANTLR start "rule__ReferenceTerm__PathAssignment_2" - // InternalBehaviorAnnexParser.g:16857:1: rule__ReferenceTerm__PathAssignment_2 : ( ruleContainmentPathElement ) ; + // InternalBehaviorAnnexParser.g:16990:1: rule__ReferenceTerm__PathAssignment_2 : ( ruleContainmentPathElement ) ; public final void rule__ReferenceTerm__PathAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16861:1: ( ( ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:16862:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:16994:1: ( ( ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:16995:2: ( ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:16862:2: ( ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:16863:3: ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:16995:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:16996:3: ruleContainmentPathElement { if ( state.backtracking==0 ) { before(grammarAccess.getReferenceTermAccess().getPathContainmentPathElementParserRuleCall_2_0()); @@ -54666,17 +55137,17 @@ public final void rule__ReferenceTerm__PathAssignment_2() throws RecognitionExce // $ANTLR start "rule__RecordTerm__OwnedFieldValueAssignment_1" - // InternalBehaviorAnnexParser.g:16872:1: rule__RecordTerm__OwnedFieldValueAssignment_1 : ( ruleFieldPropertyAssociation ) ; + // InternalBehaviorAnnexParser.g:17005:1: rule__RecordTerm__OwnedFieldValueAssignment_1 : ( ruleFieldPropertyAssociation ) ; public final void rule__RecordTerm__OwnedFieldValueAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16876:1: ( ( ruleFieldPropertyAssociation ) ) - // InternalBehaviorAnnexParser.g:16877:2: ( ruleFieldPropertyAssociation ) + // InternalBehaviorAnnexParser.g:17009:1: ( ( ruleFieldPropertyAssociation ) ) + // InternalBehaviorAnnexParser.g:17010:2: ( ruleFieldPropertyAssociation ) { - // InternalBehaviorAnnexParser.g:16877:2: ( ruleFieldPropertyAssociation ) - // InternalBehaviorAnnexParser.g:16878:3: ruleFieldPropertyAssociation + // InternalBehaviorAnnexParser.g:17010:2: ( ruleFieldPropertyAssociation ) + // InternalBehaviorAnnexParser.g:17011:3: ruleFieldPropertyAssociation { if ( state.backtracking==0 ) { before(grammarAccess.getRecordTermAccess().getOwnedFieldValueFieldPropertyAssociationParserRuleCall_1_0()); @@ -54711,17 +55182,17 @@ public final void rule__RecordTerm__OwnedFieldValueAssignment_1() throws Recogni // $ANTLR start "rule__ComputedTerm__FunctionAssignment_2" - // InternalBehaviorAnnexParser.g:16887:1: rule__ComputedTerm__FunctionAssignment_2 : ( RULE_ID ) ; + // InternalBehaviorAnnexParser.g:17020:1: rule__ComputedTerm__FunctionAssignment_2 : ( RULE_ID ) ; public final void rule__ComputedTerm__FunctionAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16891:1: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16892:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17024:1: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17025:2: ( RULE_ID ) { - // InternalBehaviorAnnexParser.g:16892:2: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16893:3: RULE_ID + // InternalBehaviorAnnexParser.g:17025:2: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17026:3: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getComputedTermAccess().getFunctionIDTerminalRuleCall_2_0()); @@ -54752,23 +55223,23 @@ public final void rule__ComputedTerm__FunctionAssignment_2() throws RecognitionE // $ANTLR start "rule__ComponentClassifierTerm__ClassifierAssignment_2" - // InternalBehaviorAnnexParser.g:16902:1: rule__ComponentClassifierTerm__ClassifierAssignment_2 : ( ( ruleQCREF ) ) ; + // InternalBehaviorAnnexParser.g:17035:1: rule__ComponentClassifierTerm__ClassifierAssignment_2 : ( ( ruleQCREF ) ) ; public final void rule__ComponentClassifierTerm__ClassifierAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16906:1: ( ( ( ruleQCREF ) ) ) - // InternalBehaviorAnnexParser.g:16907:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:17039:1: ( ( ( ruleQCREF ) ) ) + // InternalBehaviorAnnexParser.g:17040:2: ( ( ruleQCREF ) ) { - // InternalBehaviorAnnexParser.g:16907:2: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:16908:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:17040:2: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:17041:3: ( ruleQCREF ) { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getClassifierComponentClassifierCrossReference_2_0()); } - // InternalBehaviorAnnexParser.g:16909:3: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:16910:4: ruleQCREF + // InternalBehaviorAnnexParser.g:17042:3: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:17043:4: ruleQCREF { if ( state.backtracking==0 ) { before(grammarAccess.getComponentClassifierTermAccess().getClassifierComponentClassifierQCREFParserRuleCall_2_0_1()); @@ -54809,17 +55280,17 @@ public final void rule__ComponentClassifierTerm__ClassifierAssignment_2() throws // $ANTLR start "rule__ListTerm__OwnedListElementAssignment_2_0" - // InternalBehaviorAnnexParser.g:16921:1: rule__ListTerm__OwnedListElementAssignment_2_0 : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:17054:1: rule__ListTerm__OwnedListElementAssignment_2_0 : ( rulePropertyExpression ) ; public final void rule__ListTerm__OwnedListElementAssignment_2_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16925:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:16926:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17058:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:17059:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:16926:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:16927:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:17059:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17060:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getOwnedListElementPropertyExpressionParserRuleCall_2_0_0()); @@ -54854,17 +55325,17 @@ public final void rule__ListTerm__OwnedListElementAssignment_2_0() throws Recogn // $ANTLR start "rule__ListTerm__OwnedListElementAssignment_2_1_1" - // InternalBehaviorAnnexParser.g:16936:1: rule__ListTerm__OwnedListElementAssignment_2_1_1 : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:17069: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:16940:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:16941:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17073:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:17074:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:16941:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:16942:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:17074:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17075:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getListTermAccess().getOwnedListElementPropertyExpressionParserRuleCall_2_1_1_0()); @@ -54899,23 +55370,23 @@ public final void rule__ListTerm__OwnedListElementAssignment_2_1_1() throws Reco // $ANTLR start "rule__FieldPropertyAssociation__PropertyAssignment_0" - // InternalBehaviorAnnexParser.g:16951:1: rule__FieldPropertyAssociation__PropertyAssignment_0 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:17084:1: rule__FieldPropertyAssociation__PropertyAssignment_0 : ( ( RULE_ID ) ) ; public final void rule__FieldPropertyAssociation__PropertyAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16955:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:16956:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17088:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:17089:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:16956:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16957:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17089:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17090:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getPropertyBasicPropertyCrossReference_0_0()); } - // InternalBehaviorAnnexParser.g:16958:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16959:4: RULE_ID + // InternalBehaviorAnnexParser.g:17091:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17092:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getPropertyBasicPropertyIDTerminalRuleCall_0_0_1()); @@ -54952,17 +55423,17 @@ public final void rule__FieldPropertyAssociation__PropertyAssignment_0() throws // $ANTLR start "rule__FieldPropertyAssociation__OwnedValueAssignment_2" - // InternalBehaviorAnnexParser.g:16970:1: rule__FieldPropertyAssociation__OwnedValueAssignment_2 : ( rulePropertyExpression ) ; + // InternalBehaviorAnnexParser.g:17103:1: rule__FieldPropertyAssociation__OwnedValueAssignment_2 : ( rulePropertyExpression ) ; public final void rule__FieldPropertyAssociation__OwnedValueAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16974:1: ( ( rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:16975:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17107:1: ( ( rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:17108:2: ( rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:16975:2: ( rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:16976:3: rulePropertyExpression + // InternalBehaviorAnnexParser.g:17108:2: ( rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:17109:3: rulePropertyExpression { if ( state.backtracking==0 ) { before(grammarAccess.getFieldPropertyAssociationAccess().getOwnedValuePropertyExpressionParserRuleCall_2_0()); @@ -54997,23 +55468,23 @@ public final void rule__FieldPropertyAssociation__OwnedValueAssignment_2() throw // $ANTLR start "rule__ContainmentPathElement__NamedElementAssignment_0_0" - // InternalBehaviorAnnexParser.g:16985:1: rule__ContainmentPathElement__NamedElementAssignment_0_0 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:17118:1: rule__ContainmentPathElement__NamedElementAssignment_0_0 : ( ( RULE_ID ) ) ; public final void rule__ContainmentPathElement__NamedElementAssignment_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:16989:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:16990:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17122:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:17123:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:16990:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:16991:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17123:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17124:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getNamedElementNamedElementCrossReference_0_0_0()); } - // InternalBehaviorAnnexParser.g:16992:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:16993:4: RULE_ID + // InternalBehaviorAnnexParser.g:17125:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17126:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getNamedElementNamedElementIDTerminalRuleCall_0_0_0_1()); @@ -55050,17 +55521,17 @@ public final void rule__ContainmentPathElement__NamedElementAssignment_0_0() thr // $ANTLR start "rule__ContainmentPathElement__ArrayRangeAssignment_0_1" - // InternalBehaviorAnnexParser.g:17004:1: rule__ContainmentPathElement__ArrayRangeAssignment_0_1 : ( ruleArrayRange ) ; + // InternalBehaviorAnnexParser.g:17137:1: rule__ContainmentPathElement__ArrayRangeAssignment_0_1 : ( ruleArrayRange ) ; public final void rule__ContainmentPathElement__ArrayRangeAssignment_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17008:1: ( ( ruleArrayRange ) ) - // InternalBehaviorAnnexParser.g:17009:2: ( ruleArrayRange ) + // InternalBehaviorAnnexParser.g:17141:1: ( ( ruleArrayRange ) ) + // InternalBehaviorAnnexParser.g:17142:2: ( ruleArrayRange ) { - // InternalBehaviorAnnexParser.g:17009:2: ( ruleArrayRange ) - // InternalBehaviorAnnexParser.g:17010:3: ruleArrayRange + // InternalBehaviorAnnexParser.g:17142:2: ( ruleArrayRange ) + // InternalBehaviorAnnexParser.g:17143:3: ruleArrayRange { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getArrayRangeArrayRangeParserRuleCall_0_1_0()); @@ -55095,17 +55566,17 @@ public final void rule__ContainmentPathElement__ArrayRangeAssignment_0_1() throw // $ANTLR start "rule__ContainmentPathElement__PathAssignment_1_1" - // InternalBehaviorAnnexParser.g:17019:1: rule__ContainmentPathElement__PathAssignment_1_1 : ( ruleContainmentPathElement ) ; + // InternalBehaviorAnnexParser.g:17152:1: rule__ContainmentPathElement__PathAssignment_1_1 : ( ruleContainmentPathElement ) ; public final void rule__ContainmentPathElement__PathAssignment_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17023:1: ( ( ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:17024:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:17156:1: ( ( ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:17157:2: ( ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:17024:2: ( ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:17025:3: ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:17157:2: ( ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:17158:3: ruleContainmentPathElement { if ( state.backtracking==0 ) { before(grammarAccess.getContainmentPathElementAccess().getPathContainmentPathElementParserRuleCall_1_1_0()); @@ -55140,17 +55611,17 @@ public final void rule__ContainmentPathElement__PathAssignment_1_1() throws Reco // $ANTLR start "rule__StringTerm__ValueAssignment" - // InternalBehaviorAnnexParser.g:17034:1: rule__StringTerm__ValueAssignment : ( ruleNoQuoteString ) ; + // InternalBehaviorAnnexParser.g:17167:1: rule__StringTerm__ValueAssignment : ( ruleNoQuoteString ) ; public final void rule__StringTerm__ValueAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17038:1: ( ( ruleNoQuoteString ) ) - // InternalBehaviorAnnexParser.g:17039:2: ( ruleNoQuoteString ) + // InternalBehaviorAnnexParser.g:17171:1: ( ( ruleNoQuoteString ) ) + // InternalBehaviorAnnexParser.g:17172:2: ( ruleNoQuoteString ) { - // InternalBehaviorAnnexParser.g:17039:2: ( ruleNoQuoteString ) - // InternalBehaviorAnnexParser.g:17040:3: ruleNoQuoteString + // InternalBehaviorAnnexParser.g:17172:2: ( ruleNoQuoteString ) + // InternalBehaviorAnnexParser.g:17173:3: ruleNoQuoteString { if ( state.backtracking==0 ) { before(grammarAccess.getStringTermAccess().getValueNoQuoteStringParserRuleCall_0()); @@ -55185,17 +55656,17 @@ public final void rule__StringTerm__ValueAssignment() throws RecognitionExceptio // $ANTLR start "rule__ArrayRange__LowerBoundAssignment_2" - // InternalBehaviorAnnexParser.g:17049:1: rule__ArrayRange__LowerBoundAssignment_2 : ( ruleINTVALUE ) ; + // InternalBehaviorAnnexParser.g:17182:1: rule__ArrayRange__LowerBoundAssignment_2 : ( ruleINTVALUE ) ; public final void rule__ArrayRange__LowerBoundAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17053:1: ( ( ruleINTVALUE ) ) - // InternalBehaviorAnnexParser.g:17054:2: ( ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:17186:1: ( ( ruleINTVALUE ) ) + // InternalBehaviorAnnexParser.g:17187:2: ( ruleINTVALUE ) { - // InternalBehaviorAnnexParser.g:17054:2: ( ruleINTVALUE ) - // InternalBehaviorAnnexParser.g:17055:3: ruleINTVALUE + // InternalBehaviorAnnexParser.g:17187:2: ( ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:17188:3: ruleINTVALUE { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getLowerBoundINTVALUEParserRuleCall_2_0()); @@ -55230,17 +55701,17 @@ public final void rule__ArrayRange__LowerBoundAssignment_2() throws RecognitionE // $ANTLR start "rule__ArrayRange__UpperBoundAssignment_3_1" - // InternalBehaviorAnnexParser.g:17064:1: rule__ArrayRange__UpperBoundAssignment_3_1 : ( ruleINTVALUE ) ; + // InternalBehaviorAnnexParser.g:17197:1: rule__ArrayRange__UpperBoundAssignment_3_1 : ( ruleINTVALUE ) ; public final void rule__ArrayRange__UpperBoundAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17068:1: ( ( ruleINTVALUE ) ) - // InternalBehaviorAnnexParser.g:17069:2: ( ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:17201:1: ( ( ruleINTVALUE ) ) + // InternalBehaviorAnnexParser.g:17202:2: ( ruleINTVALUE ) { - // InternalBehaviorAnnexParser.g:17069:2: ( ruleINTVALUE ) - // InternalBehaviorAnnexParser.g:17070:3: ruleINTVALUE + // InternalBehaviorAnnexParser.g:17202:2: ( ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:17203:3: ruleINTVALUE { if ( state.backtracking==0 ) { before(grammarAccess.getArrayRangeAccess().getUpperBoundINTVALUEParserRuleCall_3_1_0()); @@ -55275,17 +55746,17 @@ public final void rule__ArrayRange__UpperBoundAssignment_3_1() throws Recognitio // $ANTLR start "rule__SignedConstant__OpAssignment_0" - // InternalBehaviorAnnexParser.g:17079:1: rule__SignedConstant__OpAssignment_0 : ( rulePlusMinus ) ; + // InternalBehaviorAnnexParser.g:17212:1: rule__SignedConstant__OpAssignment_0 : ( rulePlusMinus ) ; public final void rule__SignedConstant__OpAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17083:1: ( ( rulePlusMinus ) ) - // InternalBehaviorAnnexParser.g:17084:2: ( rulePlusMinus ) + // InternalBehaviorAnnexParser.g:17216:1: ( ( rulePlusMinus ) ) + // InternalBehaviorAnnexParser.g:17217:2: ( rulePlusMinus ) { - // InternalBehaviorAnnexParser.g:17084:2: ( rulePlusMinus ) - // InternalBehaviorAnnexParser.g:17085:3: rulePlusMinus + // InternalBehaviorAnnexParser.g:17217:2: ( rulePlusMinus ) + // InternalBehaviorAnnexParser.g:17218:3: rulePlusMinus { if ( state.backtracking==0 ) { before(grammarAccess.getSignedConstantAccess().getOpPlusMinusParserRuleCall_0_0()); @@ -55320,17 +55791,17 @@ public final void rule__SignedConstant__OpAssignment_0() throws RecognitionExcep // $ANTLR start "rule__SignedConstant__OwnedPropertyExpressionAssignment_1" - // InternalBehaviorAnnexParser.g:17094:1: rule__SignedConstant__OwnedPropertyExpressionAssignment_1 : ( ruleConstantValue ) ; + // InternalBehaviorAnnexParser.g:17227:1: rule__SignedConstant__OwnedPropertyExpressionAssignment_1 : ( ruleConstantValue ) ; public final void rule__SignedConstant__OwnedPropertyExpressionAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17098:1: ( ( ruleConstantValue ) ) - // InternalBehaviorAnnexParser.g:17099:2: ( ruleConstantValue ) + // InternalBehaviorAnnexParser.g:17231:1: ( ( ruleConstantValue ) ) + // InternalBehaviorAnnexParser.g:17232:2: ( ruleConstantValue ) { - // InternalBehaviorAnnexParser.g:17099:2: ( ruleConstantValue ) - // InternalBehaviorAnnexParser.g:17100:3: ruleConstantValue + // InternalBehaviorAnnexParser.g:17232:2: ( ruleConstantValue ) + // InternalBehaviorAnnexParser.g:17233:3: ruleConstantValue { if ( state.backtracking==0 ) { before(grammarAccess.getSignedConstantAccess().getOwnedPropertyExpressionConstantValueParserRuleCall_1_0()); @@ -55365,17 +55836,17 @@ public final void rule__SignedConstant__OwnedPropertyExpressionAssignment_1() th // $ANTLR start "rule__IntegerTerm__ValueAssignment_0" - // InternalBehaviorAnnexParser.g:17109:1: rule__IntegerTerm__ValueAssignment_0 : ( ruleSignedInt ) ; + // InternalBehaviorAnnexParser.g:17242:1: rule__IntegerTerm__ValueAssignment_0 : ( ruleSignedInt ) ; public final void rule__IntegerTerm__ValueAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17113:1: ( ( ruleSignedInt ) ) - // InternalBehaviorAnnexParser.g:17114:2: ( ruleSignedInt ) + // InternalBehaviorAnnexParser.g:17246:1: ( ( ruleSignedInt ) ) + // InternalBehaviorAnnexParser.g:17247:2: ( ruleSignedInt ) { - // InternalBehaviorAnnexParser.g:17114:2: ( ruleSignedInt ) - // InternalBehaviorAnnexParser.g:17115:3: ruleSignedInt + // InternalBehaviorAnnexParser.g:17247:2: ( ruleSignedInt ) + // InternalBehaviorAnnexParser.g:17248:3: ruleSignedInt { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getValueSignedIntParserRuleCall_0_0()); @@ -55410,23 +55881,23 @@ public final void rule__IntegerTerm__ValueAssignment_0() throws RecognitionExcep // $ANTLR start "rule__IntegerTerm__UnitAssignment_1" - // InternalBehaviorAnnexParser.g:17124:1: rule__IntegerTerm__UnitAssignment_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:17257:1: rule__IntegerTerm__UnitAssignment_1 : ( ( RULE_ID ) ) ; public final void rule__IntegerTerm__UnitAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17128:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:17129:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17261:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:17262:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:17129:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:17130:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17262:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17263:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getUnitUnitLiteralCrossReference_1_0()); } - // InternalBehaviorAnnexParser.g:17131:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:17132:4: RULE_ID + // InternalBehaviorAnnexParser.g:17264:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17265:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getIntegerTermAccess().getUnitUnitLiteralIDTerminalRuleCall_1_0_1()); @@ -55463,17 +55934,17 @@ public final void rule__IntegerTerm__UnitAssignment_1() throws RecognitionExcept // $ANTLR start "rule__RealTerm__ValueAssignment_0" - // InternalBehaviorAnnexParser.g:17143:1: rule__RealTerm__ValueAssignment_0 : ( ruleSignedReal ) ; + // InternalBehaviorAnnexParser.g:17276:1: rule__RealTerm__ValueAssignment_0 : ( ruleSignedReal ) ; public final void rule__RealTerm__ValueAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17147:1: ( ( ruleSignedReal ) ) - // InternalBehaviorAnnexParser.g:17148:2: ( ruleSignedReal ) + // InternalBehaviorAnnexParser.g:17280:1: ( ( ruleSignedReal ) ) + // InternalBehaviorAnnexParser.g:17281:2: ( ruleSignedReal ) { - // InternalBehaviorAnnexParser.g:17148:2: ( ruleSignedReal ) - // InternalBehaviorAnnexParser.g:17149:3: ruleSignedReal + // InternalBehaviorAnnexParser.g:17281:2: ( ruleSignedReal ) + // InternalBehaviorAnnexParser.g:17282:3: ruleSignedReal { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getValueSignedRealParserRuleCall_0_0()); @@ -55508,23 +55979,23 @@ public final void rule__RealTerm__ValueAssignment_0() throws RecognitionExceptio // $ANTLR start "rule__RealTerm__UnitAssignment_1" - // InternalBehaviorAnnexParser.g:17158:1: rule__RealTerm__UnitAssignment_1 : ( ( RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:17291:1: rule__RealTerm__UnitAssignment_1 : ( ( RULE_ID ) ) ; public final void rule__RealTerm__UnitAssignment_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17162:1: ( ( ( RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:17163:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17295:1: ( ( ( RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:17296:2: ( ( RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:17163:2: ( ( RULE_ID ) ) - // InternalBehaviorAnnexParser.g:17164:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17296:2: ( ( RULE_ID ) ) + // InternalBehaviorAnnexParser.g:17297:3: ( RULE_ID ) { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getUnitUnitLiteralCrossReference_1_0()); } - // InternalBehaviorAnnexParser.g:17165:3: ( RULE_ID ) - // InternalBehaviorAnnexParser.g:17166:4: RULE_ID + // InternalBehaviorAnnexParser.g:17298:3: ( RULE_ID ) + // InternalBehaviorAnnexParser.g:17299:4: RULE_ID { if ( state.backtracking==0 ) { before(grammarAccess.getRealTermAccess().getUnitUnitLiteralIDTerminalRuleCall_1_0_1()); @@ -55561,17 +56032,17 @@ public final void rule__RealTerm__UnitAssignment_1() throws RecognitionException // $ANTLR start "rule__NumericRangeTerm__MinimumAssignment_0" - // InternalBehaviorAnnexParser.g:17177:1: rule__NumericRangeTerm__MinimumAssignment_0 : ( ruleNumAlt ) ; + // InternalBehaviorAnnexParser.g:17310:1: rule__NumericRangeTerm__MinimumAssignment_0 : ( ruleNumAlt ) ; public final void rule__NumericRangeTerm__MinimumAssignment_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17181:1: ( ( ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:17182:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17314:1: ( ( ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:17315:2: ( ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:17182:2: ( ruleNumAlt ) - // InternalBehaviorAnnexParser.g:17183:3: ruleNumAlt + // InternalBehaviorAnnexParser.g:17315:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17316:3: ruleNumAlt { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getMinimumNumAltParserRuleCall_0_0()); @@ -55606,17 +56077,17 @@ public final void rule__NumericRangeTerm__MinimumAssignment_0() throws Recogniti // $ANTLR start "rule__NumericRangeTerm__MaximumAssignment_2" - // InternalBehaviorAnnexParser.g:17192:1: rule__NumericRangeTerm__MaximumAssignment_2 : ( ruleNumAlt ) ; + // InternalBehaviorAnnexParser.g:17325:1: rule__NumericRangeTerm__MaximumAssignment_2 : ( ruleNumAlt ) ; public final void rule__NumericRangeTerm__MaximumAssignment_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17196:1: ( ( ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:17197:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17329:1: ( ( ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:17330:2: ( ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:17197:2: ( ruleNumAlt ) - // InternalBehaviorAnnexParser.g:17198:3: ruleNumAlt + // InternalBehaviorAnnexParser.g:17330:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17331:3: ruleNumAlt { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getMaximumNumAltParserRuleCall_2_0()); @@ -55651,17 +56122,17 @@ public final void rule__NumericRangeTerm__MaximumAssignment_2() throws Recogniti // $ANTLR start "rule__NumericRangeTerm__DeltaAssignment_3_1" - // InternalBehaviorAnnexParser.g:17207:1: rule__NumericRangeTerm__DeltaAssignment_3_1 : ( ruleNumAlt ) ; + // InternalBehaviorAnnexParser.g:17340:1: rule__NumericRangeTerm__DeltaAssignment_3_1 : ( ruleNumAlt ) ; public final void rule__NumericRangeTerm__DeltaAssignment_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalBehaviorAnnexParser.g:17211:1: ( ( ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:17212:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17344:1: ( ( ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:17345:2: ( ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:17212:2: ( ruleNumAlt ) - // InternalBehaviorAnnexParser.g:17213:3: ruleNumAlt + // InternalBehaviorAnnexParser.g:17345:2: ( ruleNumAlt ) + // InternalBehaviorAnnexParser.g:17346:3: ruleNumAlt { if ( state.backtracking==0 ) { before(grammarAccess.getNumericRangeTermAccess().getDeltaNumAltParserRuleCall_3_1_0()); @@ -55696,17 +56167,17 @@ public final void rule__NumericRangeTerm__DeltaAssignment_3_1() throws Recogniti // $ANTLR start synpred10_InternalBehaviorAnnexParser public final void synpred10_InternalBehaviorAnnexParser_fragment() throws RecognitionException { - // InternalBehaviorAnnexParser.g:2708:2: ( ( ( ruleAssignmentAction ) ) ) - // InternalBehaviorAnnexParser.g:2708:2: ( ( ruleAssignmentAction ) ) + // InternalBehaviorAnnexParser.g:2833:2: ( ( ( ruleAssignmentAction ) ) ) + // InternalBehaviorAnnexParser.g:2833:2: ( ( ruleAssignmentAction ) ) { - // InternalBehaviorAnnexParser.g:2708:2: ( ( ruleAssignmentAction ) ) - // InternalBehaviorAnnexParser.g:2709:3: ( ruleAssignmentAction ) + // InternalBehaviorAnnexParser.g:2833:2: ( ( ruleAssignmentAction ) ) + // InternalBehaviorAnnexParser.g:2834:3: ( ruleAssignmentAction ) { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionAccess().getAssignmentActionParserRuleCall_0()); } - // InternalBehaviorAnnexParser.g:2710:3: ( ruleAssignmentAction ) - // InternalBehaviorAnnexParser.g:2710:4: ruleAssignmentAction + // InternalBehaviorAnnexParser.g:2835:3: ( ruleAssignmentAction ) + // InternalBehaviorAnnexParser.g:2835:4: ruleAssignmentAction { pushFollow(FollowSets000.FOLLOW_2); ruleAssignmentAction(); @@ -55726,11 +56197,11 @@ public final void synpred10_InternalBehaviorAnnexParser_fragment() throws Recogn // $ANTLR start synpred11_InternalBehaviorAnnexParser public final void synpred11_InternalBehaviorAnnexParser_fragment() throws RecognitionException { - // InternalBehaviorAnnexParser.g:2714:2: ( ( ruleCommunicationAction ) ) - // InternalBehaviorAnnexParser.g:2714:2: ( ruleCommunicationAction ) + // InternalBehaviorAnnexParser.g:2839:2: ( ( ruleCommunicationAction ) ) + // InternalBehaviorAnnexParser.g:2839:2: ( ruleCommunicationAction ) { - // InternalBehaviorAnnexParser.g:2714:2: ( ruleCommunicationAction ) - // InternalBehaviorAnnexParser.g:2715:3: ruleCommunicationAction + // InternalBehaviorAnnexParser.g:2839:2: ( ruleCommunicationAction ) + // InternalBehaviorAnnexParser.g:2840:3: ruleCommunicationAction { if ( state.backtracking==0 ) { before(grammarAccess.getBehaviorActionAccess().getCommunicationActionParserRuleCall_1()); @@ -55781,7 +56252,7 @@ public final boolean synpred10_InternalBehaviorAnnexParser() { protected DFA7 dfa7 = new DFA7(this); - protected DFA30 dfa30 = new DFA30(this); + protected DFA33 dfa33 = new DFA33(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"; @@ -55822,7 +56293,7 @@ public DFA7(BaseRecognizer recognizer) { this.transition = dfa_6; } public String getDescription() { - return "2703:1: rule__BehaviorAction__Alternatives : ( ( ( ruleAssignmentAction ) ) | ( ruleCommunicationAction ) | ( ruleTimedAction ) | ( ruleIfStatement ) | ( ruleForStatement ) | ( ruleWhileStatement ) | ( ruleDoUntilStatement ) | ( ruleBehaviorActionBlock ) );"; + return "2828:1: rule__BehaviorAction__Alternatives : ( ( ( ruleAssignmentAction ) ) | ( ruleCommunicationAction ) | ( ruleTimedAction ) | ( ruleIfStatement ) | ( ruleForStatement ) | ( ruleWhileStatement ) | ( ruleDoUntilStatement ) | ( ruleBehaviorActionBlock ) );"; } public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { TokenStream input = (TokenStream)_input; @@ -55889,11 +56360,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 DFA30 extends DFA { + class DFA33 extends DFA { - public DFA30(BaseRecognizer recognizer) { + public DFA33(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 30; + this.decisionNumber = 33; this.eot = dfa_7; this.eof = dfa_8; this.min = dfa_9; @@ -55903,7 +56374,7 @@ public DFA30(BaseRecognizer recognizer) { this.transition = dfa_13; } public String getDescription() { - return "3342:1: rule__PropertyExpression__Alternatives : ( ( ruleRecordTerm ) | ( ruleReferenceTerm ) | ( ruleComponentClassifierTerm ) | ( ruleComputedTerm ) | ( ruleStringTerm ) | ( ruleNumericRangeTerm ) | ( ruleRealTerm ) | ( ruleIntegerTerm ) | ( ruleListTerm ) | ( ruleBooleanLiteral ) | ( ruleLiteralorReferenceTerm ) );"; + return "3518:1: rule__PropertyExpression__Alternatives : ( ( ruleRecordTerm ) | ( ruleReferenceTerm ) | ( ruleComponentClassifierTerm ) | ( ruleComputedTerm ) | ( ruleStringTerm ) | ( ruleNumericRangeTerm ) | ( ruleRealTerm ) | ( ruleIntegerTerm ) | ( ruleListTerm ) | ( ruleBooleanLiteral ) | ( ruleLiteralorReferenceTerm ) );"; } } @@ -55968,39 +56439,40 @@ private static class FollowSets000 { 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}); - public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000200000000L}); - public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000800000000L}); - public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0502000000000000L,0x0000000000070000L}); - public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000A00L}); - public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000A00L}); - public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000500000000000L,0x0000000000002100L}); - public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000500000000002L,0x0000000000002100L}); - public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0008000000000000L}); - public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000208000000000L,0x0000000000000A00L}); - public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000001004000000L}); - public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080028L}); - public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000010880000L}); - public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000000000L,0x0000000000101000L}); - public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001000L}); - public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000000L,0x0000000240000008L}); - public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080020L}); - public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0040000000000000L,0x0000000000001000L}); - public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0040000000000002L,0x0000000000001000L}); - public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0040000000000000L}); - 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,0x0000000000008000L}); - public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); - public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); - public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000000020000000L}); - public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000001004010140L,0x0000000350100AC0L}); - public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); - 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,0x0000000040000A00L}); - public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000A00L}); - public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000000001000000L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000810000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000810000000002L,0x0000000000000001L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000200000000L}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000800000000L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0502000000000000L,0x0000000000070000L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000A00L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000A00L}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000500000000000L,0x0000000000002100L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000500000000002L,0x0000000000002100L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0008000000000000L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000001004000000L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080028L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000010880000L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000000L,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[]{0x0000000000000000L,0x0000000000080020L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0040000000000000L,0x0000000000001000L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0040000000000002L,0x0000000000001000L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0040000000000000L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0040000000000002L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0200002000000000L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000001004010940L,0x0000000350100A40L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x4000000000004000L,0x0000000000008000L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000020000000L}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000001004010140L,0x0000000350100AC0L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0020000000000000L,0x0000000000200000L}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000000000L,0x0000000250000A00L}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000A00L}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000A00L}); + public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0000000001000000L}); } diff --git a/ba/org.osate.xtext.aadl2.ba.ui/src-gen/org/osate/xtext/aadl2/ba/ui/contentassist/AbstractBehaviorAnnexProposalProvider.java b/ba/org.osate.xtext.aadl2.ba.ui/src-gen/org/osate/xtext/aadl2/ba/ui/contentassist/AbstractBehaviorAnnexProposalProvider.java index 8cbc4e937d..8c0aac6456 100644 --- a/ba/org.osate.xtext.aadl2.ba.ui/src-gen/org/osate/xtext/aadl2/ba/ui/contentassist/AbstractBehaviorAnnexProposalProvider.java +++ b/ba/org.osate.xtext.aadl2.ba.ui/src-gen/org/osate/xtext/aadl2/ba/ui/contentassist/AbstractBehaviorAnnexProposalProvider.java @@ -296,58 +296,43 @@ public void completeBehaviorTime_Value(EObject model, Assignment assignment, Con public void completeBehaviorTime_Unit(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); } - public void completeLogicalOrExpression_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeValueExpression_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeLogicalOrExpression_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeValueExpression_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeLogicalAndExpression_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeRelation_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeLogicalAndExpression_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeRelation_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeRelationalExpression_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { - // subclasses may override - // subclasses may override - // subclasses may override - // subclasses may override - // subclasses may override - // subclasses may override - } - public void completeRelationalExpression_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeSimpleExpression_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeAdditiveExpression_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { - // subclasses may override - // subclasses may override + public void completeSimpleExpression_Operand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeAdditiveExpression_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeSimpleExpression_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeMultiplicativeExpression_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { - // subclasses may override - // subclasses may override - // subclasses may override - // subclasses may override + public void completeTerm_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeMultiplicativeExpression_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeTerm_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completePowerExpression_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { - // subclasses may override + public void completeFactor_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completePowerExpression_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeFactor_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeUnaryExpression_Operator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { - // subclasses may override - // subclasses may override - // subclasses may override - // subclasses may override + public void completeFactor_Operand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } - public void completeUnaryExpression_Operand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void completeParenthesizedExpression_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } public void completeBehaviorIntegerLiteral_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { @@ -564,34 +549,49 @@ public void complete_IntegerValue(EObject model, RuleCall ruleCall, ContentAssis public void complete_ValueExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_LogicalOrExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_LogicalOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } public void complete_LogicalOrOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_LogicalAndExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_LogicalAndOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_LogicalAndOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_Relation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_RelationalOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_SimpleExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_UnaryAddingOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_BinaryAddingOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_Term(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_RelationalExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_MultiplyingOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_AdditiveExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_Factor(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_MultiplicativeExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_BinaryNumericOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_PowerExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_UnaryValueOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_UnaryExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_Value(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } - public void complete_PrimaryExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + public void complete_ParenthesizedExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { // subclasses may override } public void complete_ValueConstant(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { diff --git a/ba/org.osate.xtext.aadl2.ba/model/generated/BehaviorAnnex.ecore b/ba/org.osate.xtext.aadl2.ba/model/generated/BehaviorAnnex.ecore index 89b10a7a6e..41c2f3a9d8 100644 --- a/ba/org.osate.xtext.aadl2.ba/model/generated/BehaviorAnnex.ecore +++ b/ba/org.osate.xtext.aadl2.ba/model/generated/BehaviorAnnex.ecore @@ -206,6 +206,10 @@ + + + diff --git a/ba/org.osate.xtext.aadl2.ba/model/generated/BehaviorAnnex.genmodel b/ba/org.osate.xtext.aadl2.ba/model/generated/BehaviorAnnex.genmodel index 9f80a61562..356d17f822 100644 --- a/ba/org.osate.xtext.aadl2.ba/model/generated/BehaviorAnnex.genmodel +++ b/ba/org.osate.xtext.aadl2.ba/model/generated/BehaviorAnnex.genmodel @@ -155,6 +155,9 @@ + + + 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 6bc05bb469..f938dcbaf2 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/behaviorAnnex/BehaviorAnnexFactory.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/BehaviorAnnexFactory.java index 5002becffa..e5347204a5 100644 --- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/BehaviorAnnexFactory.java +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/BehaviorAnnexFactory.java @@ -340,6 +340,15 @@ public interface BehaviorAnnexFactory extends EFactory */ ValueExpression createValueExpression(); + /** + * Returns a new object of class 'Parenthesized Expression'. + * + * + * @return a new object of class 'Parenthesized Expression'. + * @generated + */ + ParenthesizedExpression createParenthesizedExpression(); + /** * Returns a new object of class 'Value Constant'. * diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/BehaviorAnnexPackage.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/BehaviorAnnexPackage.java index 539476c36f..79930b7ff3 100644 --- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/BehaviorAnnexPackage.java +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/BehaviorAnnexPackage.java @@ -1525,6 +1525,34 @@ public interface BehaviorAnnexPackage extends EPackage */ int VALUE_EXPRESSION_FEATURE_COUNT = 0; + /** + * The meta object id for the '{@link org.osate.xtext.aadl2.ba.behaviorAnnex.impl.ParenthesizedExpressionImpl Parenthesized Expression}' class. + * + * + * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.ParenthesizedExpressionImpl + * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getParenthesizedExpression() + * @generated + */ + int PARENTHESIZED_EXPRESSION = 33; + + /** + * The feature id for the 'Expression' containment reference. + * + * + * @generated + * @ordered + */ + int PARENTHESIZED_EXPRESSION__EXPRESSION = VALUE_EXPRESSION_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Parenthesized Expression' class. + * + * + * @generated + * @ordered + */ + int PARENTHESIZED_EXPRESSION_FEATURE_COUNT = VALUE_EXPRESSION_FEATURE_COUNT + 1; + /** * The meta object id for the '{@link org.osate.xtext.aadl2.ba.behaviorAnnex.impl.ValueConstantImpl Value Constant}' class. * @@ -1533,7 +1561,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getValueConstant() * @generated */ - int VALUE_CONSTANT = 33; + int VALUE_CONSTANT = 34; /** * The number of structural features of the 'Value Constant' class. @@ -1552,7 +1580,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getBehaviorIntegerLiteral() * @generated */ - int BEHAVIOR_INTEGER_LITERAL = 34; + int BEHAVIOR_INTEGER_LITERAL = 35; /** * The feature id for the 'Value' attribute. @@ -1580,7 +1608,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getBehaviorRealLiteral() * @generated */ - int BEHAVIOR_REAL_LITERAL = 35; + int BEHAVIOR_REAL_LITERAL = 36; /** * The feature id for the 'Value' attribute. @@ -1608,7 +1636,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getBehaviorStringLiteral() * @generated */ - int BEHAVIOR_STRING_LITERAL = 36; + int BEHAVIOR_STRING_LITERAL = 37; /** * The feature id for the 'Value' attribute. @@ -1636,7 +1664,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getBehaviorBooleanLiteral() * @generated */ - int BEHAVIOR_BOOLEAN_LITERAL = 37; + int BEHAVIOR_BOOLEAN_LITERAL = 38; /** * The feature id for the 'Value' attribute. @@ -1664,7 +1692,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getReferenceExpression() * @generated */ - int REFERENCE_EXPRESSION = 38; + int REFERENCE_EXPRESSION = 39; /** * The feature id for the 'Reference' containment reference. @@ -1737,7 +1765,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getHashPropertyReference() * @generated */ - int HASH_PROPERTY_REFERENCE = 39; + int HASH_PROPERTY_REFERENCE = 40; /** * The feature id for the 'Property' attribute. @@ -1783,7 +1811,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getPropertyReferenceTail() * @generated */ - int PROPERTY_REFERENCE_TAIL = 40; + int PROPERTY_REFERENCE_TAIL = 41; /** * The feature id for the 'Property' attribute. @@ -1829,7 +1857,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getNamedPropertyField() * @generated */ - int NAMED_PROPERTY_FIELD = 41; + int NAMED_PROPERTY_FIELD = 42; /** * The feature id for the 'Name' attribute. @@ -1866,7 +1894,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getPropertyArrayIndex() * @generated */ - int PROPERTY_ARRAY_INDEX = 42; + int PROPERTY_ARRAY_INDEX = 43; /** * The feature id for the 'Value' containment reference. @@ -1894,7 +1922,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getPropertyIndexValue() * @generated */ - int PROPERTY_INDEX_VALUE = 43; + int PROPERTY_INDEX_VALUE = 44; /** * The number of structural features of the 'Property Index Value' class. @@ -1913,7 +1941,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getPropertyIndexPropertyReference() * @generated */ - int PROPERTY_INDEX_PROPERTY_REFERENCE = 44; + int PROPERTY_INDEX_PROPERTY_REFERENCE = 45; /** * The feature id for the 'Property' attribute. @@ -1941,7 +1969,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getUnindexedReferenceExpression() * @generated */ - int UNINDEXED_REFERENCE_EXPRESSION = 45; + int UNINDEXED_REFERENCE_EXPRESSION = 46; /** * The feature id for the 'Reference' containment reference. @@ -2005,7 +2033,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getUnindexedReference() * @generated */ - int UNINDEXED_REFERENCE = 46; + int UNINDEXED_REFERENCE = 47; /** * The feature id for the 'Segments' containment reference list. @@ -2042,7 +2070,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getUnindexedReferenceTail() * @generated */ - int UNINDEXED_REFERENCE_TAIL = 47; + int UNINDEXED_REFERENCE_TAIL = 48; /** * The feature id for the 'Separator' attribute. @@ -2079,7 +2107,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getUnindexedReferenceSegment() * @generated */ - int UNINDEXED_REFERENCE_SEGMENT = 48; + int UNINDEXED_REFERENCE_SEGMENT = 49; /** * The feature id for the 'Name' attribute. @@ -2107,7 +2135,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getReference() * @generated */ - int REFERENCE = 49; + int REFERENCE = 50; /** * The feature id for the 'Segments' containment reference list. @@ -2144,7 +2172,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getReferenceTail() * @generated */ - int REFERENCE_TAIL = 50; + int REFERENCE_TAIL = 51; /** * The feature id for the 'Separator' attribute. @@ -2181,7 +2209,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getReferenceSegment() * @generated */ - int REFERENCE_SEGMENT = 51; + int REFERENCE_SEGMENT = 52; /** * The feature id for the 'Name' attribute. @@ -2218,7 +2246,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getArrayIndex() * @generated */ - int ARRAY_INDEX = 52; + int ARRAY_INDEX = 53; /** * The feature id for the 'Value' containment reference. @@ -2246,7 +2274,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getBehaviorActionSequence() * @generated */ - int BEHAVIOR_ACTION_SEQUENCE = 53; + int BEHAVIOR_ACTION_SEQUENCE = 54; /** * The feature id for the 'Actions' containment reference list. @@ -2274,7 +2302,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getBehaviorActionSet() * @generated */ - int BEHAVIOR_ACTION_SET = 54; + int BEHAVIOR_ACTION_SET = 55; /** * The feature id for the 'Actions' containment reference list. @@ -2302,7 +2330,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getBinaryExpression() * @generated */ - int BINARY_EXPRESSION = 55; + int BINARY_EXPRESSION = 56; /** * The feature id for the 'Left' containment reference. @@ -2348,7 +2376,7 @@ public interface BehaviorAnnexPackage extends EPackage * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getUnaryExpression() * @generated */ - int UNARY_EXPRESSION = 56; + int UNARY_EXPRESSION = 57; /** * The feature id for the 'Operator' attribute. @@ -3643,6 +3671,27 @@ public interface BehaviorAnnexPackage extends EPackage */ EClass getValueExpression(); + /** + * Returns the meta object for class '{@link org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression Parenthesized Expression}'. + * + * + * @return the meta object for class 'Parenthesized Expression'. + * @see org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression + * @generated + */ + EClass getParenthesizedExpression(); + + /** + * Returns the meta object for the containment reference '{@link org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression#getExpression Expression}'. + * + * + * @return the meta object for the containment reference 'Expression'. + * @see org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression#getExpression() + * @see #getParenthesizedExpression() + * @generated + */ + EReference getParenthesizedExpression_Expression(); + /** * Returns the meta object for class '{@link org.osate.xtext.aadl2.ba.behaviorAnnex.ValueConstant Value Constant}'. * @@ -5400,6 +5449,24 @@ interface Literals */ EClass VALUE_EXPRESSION = eINSTANCE.getValueExpression(); + /** + * The meta object literal for the '{@link org.osate.xtext.aadl2.ba.behaviorAnnex.impl.ParenthesizedExpressionImpl Parenthesized Expression}' class. + * + * + * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.ParenthesizedExpressionImpl + * @see org.osate.xtext.aadl2.ba.behaviorAnnex.impl.BehaviorAnnexPackageImpl#getParenthesizedExpression() + * @generated + */ + EClass PARENTHESIZED_EXPRESSION = eINSTANCE.getParenthesizedExpression(); + + /** + * The meta object literal for the 'Expression' containment reference feature. + * + * + * @generated + */ + EReference PARENTHESIZED_EXPRESSION__EXPRESSION = eINSTANCE.getParenthesizedExpression_Expression(); + /** * The meta object literal for the '{@link org.osate.xtext.aadl2.ba.behaviorAnnex.impl.ValueConstantImpl Value Constant}' class. * diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/ParenthesizedExpression.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/ParenthesizedExpression.java new file mode 100644 index 0000000000..b103f746a8 --- /dev/null +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/ParenthesizedExpression.java @@ -0,0 +1,67 @@ +/** + * 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.xtext.aadl2.ba.behaviorAnnex; + + +/** + * + * A representation of the model object 'Parenthesized Expression'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression#getExpression Expression}
    • + *
+ * + * @see org.osate.xtext.aadl2.ba.behaviorAnnex.BehaviorAnnexPackage#getParenthesizedExpression() + * @model + * @generated + */ +public interface ParenthesizedExpression extends ValueExpression +{ + /** + * Returns the value of the 'Expression' containment reference. + * + * + * @return the value of the 'Expression' containment reference. + * @see #setExpression(ValueExpression) + * @see org.osate.xtext.aadl2.ba.behaviorAnnex.BehaviorAnnexPackage#getParenthesizedExpression_Expression() + * @model containment="true" + * @generated + */ + ValueExpression getExpression(); + + /** + * Sets the value of the '{@link org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression#getExpression Expression}' containment reference. + * + * + * @param value the new value of the 'Expression' containment reference. + * @see #getExpression() + * @generated + */ + void setExpression(ValueExpression value); + +} // ParenthesizedExpression diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/BehaviorAnnexFactoryImpl.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/BehaviorAnnexFactoryImpl.java index 4cf72dbfba..453afba491 100644 --- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/BehaviorAnnexFactoryImpl.java +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/BehaviorAnnexFactoryImpl.java @@ -118,6 +118,7 @@ public EObject create(EClass eClass) case BehaviorAnnexPackage.BEHAVIOR_TIME: return createBehaviorTime(); case BehaviorAnnexPackage.INTEGER_VALUE: return createIntegerValue(); case BehaviorAnnexPackage.VALUE_EXPRESSION: return createValueExpression(); + case BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION: return createParenthesizedExpression(); case BehaviorAnnexPackage.VALUE_CONSTANT: return createValueConstant(); case BehaviorAnnexPackage.BEHAVIOR_INTEGER_LITERAL: return createBehaviorIntegerLiteral(); case BehaviorAnnexPackage.BEHAVIOR_REAL_LITERAL: return createBehaviorRealLiteral(); @@ -543,6 +544,18 @@ public ValueExpression createValueExpression() return valueExpression; } + /** + * + * + * @generated + */ + @Override + public ParenthesizedExpression createParenthesizedExpression() + { + ParenthesizedExpressionImpl parenthesizedExpression = new ParenthesizedExpressionImpl(); + return parenthesizedExpression; + } + /** * * diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/BehaviorAnnexPackageImpl.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/BehaviorAnnexPackageImpl.java index 4c298d38b9..f933191098 100644 --- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/BehaviorAnnexPackageImpl.java +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/BehaviorAnnexPackageImpl.java @@ -75,6 +75,7 @@ import org.osate.xtext.aadl2.ba.behaviorAnnex.ModeSwitchConjunction; import org.osate.xtext.aadl2.ba.behaviorAnnex.ModeSwitchTrigger; import org.osate.xtext.aadl2.ba.behaviorAnnex.NamedPropertyField; +import org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression; import org.osate.xtext.aadl2.ba.behaviorAnnex.PropertyArrayIndex; import org.osate.xtext.aadl2.ba.behaviorAnnex.PropertyIndexPropertyReference; import org.osate.xtext.aadl2.ba.behaviorAnnex.PropertyIndexValue; @@ -332,6 +333,13 @@ public class BehaviorAnnexPackageImpl extends EPackageImpl implements BehaviorAn */ private EClass valueExpressionEClass = null; + /** + * + * + * @generated + */ + private EClass parenthesizedExpressionEClass = null; + /** * * @@ -1864,6 +1872,28 @@ public EClass getValueExpression() return valueExpressionEClass; } + /** + * + * + * @generated + */ + @Override + public EClass getParenthesizedExpression() + { + return parenthesizedExpressionEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getParenthesizedExpression_Expression() + { + return (EReference)parenthesizedExpressionEClass.getEStructuralFeatures().get(0); + } + /** * * @@ -2794,6 +2824,9 @@ public void createPackageContents() valueExpressionEClass = createEClass(VALUE_EXPRESSION); + parenthesizedExpressionEClass = createEClass(PARENTHESIZED_EXPRESSION); + createEReference(parenthesizedExpressionEClass, PARENTHESIZED_EXPRESSION__EXPRESSION); + valueConstantEClass = createEClass(VALUE_CONSTANT); behaviorIntegerLiteralEClass = createEClass(BEHAVIOR_INTEGER_LITERAL); @@ -2930,6 +2963,7 @@ public void initializePackageContents() forStatementEClass.getESuperTypes().add(this.getBehaviorAction()); whileStatementEClass.getESuperTypes().add(this.getBehaviorAction()); doUntilStatementEClass.getESuperTypes().add(this.getBehaviorAction()); + parenthesizedExpressionEClass.getESuperTypes().add(this.getValueExpression()); valueConstantEClass.getESuperTypes().add(this.getValueExpression()); behaviorIntegerLiteralEClass.getESuperTypes().add(this.getIntegerValue()); behaviorIntegerLiteralEClass.getESuperTypes().add(this.getValueConstant()); @@ -3100,6 +3134,9 @@ public void initializePackageContents() initEClass(valueExpressionEClass, ValueExpression.class, "ValueExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEClass(parenthesizedExpressionEClass, ParenthesizedExpression.class, "ParenthesizedExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getParenthesizedExpression_Expression(), this.getValueExpression(), null, "expression", null, 0, 1, ParenthesizedExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEClass(valueConstantEClass, ValueConstant.class, "ValueConstant", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); initEClass(behaviorIntegerLiteralEClass, BehaviorIntegerLiteral.class, "BehaviorIntegerLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/ParenthesizedExpressionImpl.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/ParenthesizedExpressionImpl.java new file mode 100644 index 0000000000..3381d5cd09 --- /dev/null +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/impl/ParenthesizedExpressionImpl.java @@ -0,0 +1,216 @@ +/** + * 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.xtext.aadl2.ba.behaviorAnnex.impl; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.osate.xtext.aadl2.ba.behaviorAnnex.BehaviorAnnexPackage; +import org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression; +import org.osate.xtext.aadl2.ba.behaviorAnnex.ValueExpression; + +/** + * + * An implementation of the model object 'Parenthesized Expression'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.osate.xtext.aadl2.ba.behaviorAnnex.impl.ParenthesizedExpressionImpl#getExpression Expression}
    • + *
+ * + * @generated + */ +public class ParenthesizedExpressionImpl extends ValueExpressionImpl implements ParenthesizedExpression +{ + /** + * The cached value of the '{@link #getExpression() Expression}' containment reference. + * + * + * @see #getExpression() + * @generated + * @ordered + */ + protected ValueExpression expression; + + /** + * + * + * @generated + */ + protected ParenthesizedExpressionImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION; + } + + /** + * + * + * @generated + */ + @Override + public ValueExpression getExpression() + { + return expression; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetExpression(ValueExpression newExpression, NotificationChain msgs) + { + ValueExpression oldExpression = expression; + expression = newExpression; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION__EXPRESSION, oldExpression, newExpression); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setExpression(ValueExpression newExpression) + { + if (newExpression != expression) + { + NotificationChain msgs = null; + if (expression != null) + msgs = ((InternalEObject)expression).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION__EXPRESSION, null, msgs); + if (newExpression != null) + msgs = ((InternalEObject)newExpression).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION__EXPRESSION, null, msgs); + msgs = basicSetExpression(newExpression, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION__EXPRESSION, newExpression, newExpression)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION__EXPRESSION: + return basicSetExpression(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION__EXPRESSION: + return getExpression(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION__EXPRESSION: + setExpression((ValueExpression)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION__EXPRESSION: + setExpression((ValueExpression)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION__EXPRESSION: + return expression != null; + } + return super.eIsSet(featureID); + } + +} //ParenthesizedExpressionImpl diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/util/BehaviorAnnexAdapterFactory.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/util/BehaviorAnnexAdapterFactory.java index 9fda29031b..7b78f80213 100644 --- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/util/BehaviorAnnexAdapterFactory.java +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/util/BehaviorAnnexAdapterFactory.java @@ -266,6 +266,11 @@ public Adapter caseValueExpression(ValueExpression object) return createValueExpressionAdapter(); } @Override + public Adapter caseParenthesizedExpression(ParenthesizedExpression object) + { + return createParenthesizedExpressionAdapter(); + } + @Override public Adapter caseValueConstant(ValueConstant object) { return createValueConstantAdapter(); @@ -922,6 +927,21 @@ public Adapter createValueExpressionAdapter() return null; } + /** + * Creates a new adapter for an object of class '{@link org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression Parenthesized Expression}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression + * @generated + */ + public Adapter createParenthesizedExpressionAdapter() + { + return null; + } + /** * Creates a new adapter for an object of class '{@link org.osate.xtext.aadl2.ba.behaviorAnnex.ValueConstant Value Constant}'. * diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/util/BehaviorAnnexSwitch.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/util/BehaviorAnnexSwitch.java index 05c0633a45..97e95fc448 100644 --- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/util/BehaviorAnnexSwitch.java +++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/behaviorAnnex/util/BehaviorAnnexSwitch.java @@ -350,6 +350,14 @@ protected T doSwitch(int classifierID, EObject theEObject) if (result == null) result = defaultCase(theEObject); return result; } + case BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION: + { + ParenthesizedExpression parenthesizedExpression = (ParenthesizedExpression)theEObject; + T result = caseParenthesizedExpression(parenthesizedExpression); + if (result == null) result = caseValueExpression(parenthesizedExpression); + if (result == null) result = defaultCase(theEObject); + return result; + } case BehaviorAnnexPackage.VALUE_CONSTANT: { ValueConstant valueConstant = (ValueConstant)theEObject; @@ -1072,6 +1080,22 @@ public T caseValueExpression(ValueExpression object) return null; } + /** + * Returns the result of interpreting the object as an instance of 'Parenthesized Expression'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Parenthesized Expression'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseParenthesizedExpression(ParenthesizedExpression object) + { + return null; + } + /** * Returns the result of interpreting the object as an instance of 'Value Constant'. * 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 6e83c8665e..a13ae0dbbe 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 @@ -3088,66 +3088,41 @@ ruleValueExpression returns [EObject current=null] @init { enterRule(); } -@after { - leaveRule(); -}: - { - newCompositeNode(grammarAccess.getValueExpressionAccess().getLogicalOrExpressionParserRuleCall()); - } - this_LogicalOrExpression_0=ruleLogicalOrExpression - { - $current = $this_LogicalOrExpression_0.current; - afterParserOrEnumRuleCall(); - } -; - -// Entry rule entryRuleLogicalOrExpression -entryRuleLogicalOrExpression returns [EObject current=null]: - { newCompositeNode(grammarAccess.getLogicalOrExpressionRule()); } - iv_ruleLogicalOrExpression=ruleLogicalOrExpression - { $current=$iv_ruleLogicalOrExpression.current; } - EOF; - -// Rule LogicalOrExpression -ruleLogicalOrExpression returns [EObject current=null] -@init { - enterRule(); -} @after { leaveRule(); }: ( { - newCompositeNode(grammarAccess.getLogicalOrExpressionAccess().getLogicalAndExpressionParserRuleCall_0()); + newCompositeNode(grammarAccess.getValueExpressionAccess().getRelationParserRuleCall_0()); } - this_LogicalAndExpression_0=ruleLogicalAndExpression + this_Relation_0=ruleRelation { - $current = $this_LogicalAndExpression_0.current; + $current = $this_Relation_0.current; afterParserOrEnumRuleCall(); } ( ( { $current = forceCreateModelElementAndSet( - grammarAccess.getLogicalOrExpressionAccess().getBinaryExpressionLeftAction_1_0(), + grammarAccess.getValueExpressionAccess().getBinaryExpressionLeftAction_1_0(), $current); } ) ( ( { - newCompositeNode(grammarAccess.getLogicalOrExpressionAccess().getOperatorLogicalOrOperatorParserRuleCall_1_1_0()); + newCompositeNode(grammarAccess.getValueExpressionAccess().getOperatorLogicalOperatorParserRuleCall_1_1_0()); } - lv_operator_2_0=ruleLogicalOrOperator + lv_operator_2_0=ruleLogicalOperator { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getLogicalOrExpressionRule()); + $current = createModelElementForParent(grammarAccess.getValueExpressionRule()); } set( $current, "operator", lv_operator_2_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalOrOperator"); + "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalOperator"); afterParserOrEnumRuleCall(); } ) @@ -3155,18 +3130,18 @@ ruleLogicalOrExpression returns [EObject current=null] ( ( { - newCompositeNode(grammarAccess.getLogicalOrExpressionAccess().getRightLogicalAndExpressionParserRuleCall_1_2_0()); + newCompositeNode(grammarAccess.getValueExpressionAccess().getRightRelationParserRuleCall_1_2_0()); } - lv_right_3_0=ruleLogicalAndExpression + lv_right_3_0=ruleRelation { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getLogicalOrExpressionRule()); + $current = createModelElementForParent(grammarAccess.getValueExpressionRule()); } set( $current, "right", lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalAndExpression"); + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Relation"); afterParserOrEnumRuleCall(); } ) @@ -3175,6 +3150,46 @@ ruleLogicalOrExpression returns [EObject current=null] ) ; +// Entry rule entryRuleLogicalOperator +entryRuleLogicalOperator returns [String current=null]: + { newCompositeNode(grammarAccess.getLogicalOperatorRule()); } + iv_ruleLogicalOperator=ruleLogicalOperator + { $current=$iv_ruleLogicalOperator.current.getText(); } + EOF; + +// Rule LogicalOperator +ruleLogicalOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getLogicalOperatorAccess().getLogicalAndOperatorParserRuleCall_0()); + } + this_LogicalAndOperator_0=ruleLogicalAndOperator + { + $current.merge(this_LogicalAndOperator_0); + } + { + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getLogicalOperatorAccess().getLogicalOrOperatorParserRuleCall_1()); + } + this_LogicalOrOperator_1=ruleLogicalOrOperator + { + $current.merge(this_LogicalOrOperator_1); + } + { + afterParserOrEnumRuleCall(); + } + ) +; + // Entry rule entryRuleLogicalOrOperator entryRuleLogicalOrOperator returns [String current=null]: { newCompositeNode(grammarAccess.getLogicalOrOperatorRule()); } @@ -3214,15 +3229,15 @@ ruleLogicalOrOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeR ) ; -// Entry rule entryRuleLogicalAndExpression -entryRuleLogicalAndExpression returns [EObject current=null]: - { newCompositeNode(grammarAccess.getLogicalAndExpressionRule()); } - iv_ruleLogicalAndExpression=ruleLogicalAndExpression - { $current=$iv_ruleLogicalAndExpression.current; } +// Entry rule entryRuleLogicalAndOperator +entryRuleLogicalAndOperator returns [String current=null]: + { newCompositeNode(grammarAccess.getLogicalAndOperatorRule()); } + iv_ruleLogicalAndOperator=ruleLogicalAndOperator + { $current=$iv_ruleLogicalAndOperator.current.getText(); } EOF; -// Rule LogicalAndExpression -ruleLogicalAndExpression returns [EObject current=null] +// Rule LogicalAndOperator +ruleLogicalAndOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] @init { enterRule(); } @@ -3230,37 +3245,68 @@ ruleLogicalAndExpression returns [EObject current=null] leaveRule(); }: ( + kw=And { - newCompositeNode(grammarAccess.getLogicalAndExpressionAccess().getRelationalExpressionParserRuleCall_0()); + $current.merge(kw); + newLeafNode(kw, grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); } - this_RelationalExpression_0=ruleRelationalExpression + ( + kw=Then + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getLogicalAndOperatorAccess().getThenKeyword_1()); + } + )? + ) +; + +// Entry rule entryRuleRelation +entryRuleRelation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getRelationRule()); } + iv_ruleRelation=ruleRelation + { $current=$iv_ruleRelation.current; } + EOF; + +// Rule Relation +ruleRelation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getRelationAccess().getSimpleExpressionParserRuleCall_0()); + } + this_SimpleExpression_0=ruleSimpleExpression { - $current = $this_RelationalExpression_0.current; + $current = $this_SimpleExpression_0.current; afterParserOrEnumRuleCall(); } ( ( { $current = forceCreateModelElementAndSet( - grammarAccess.getLogicalAndExpressionAccess().getBinaryExpressionLeftAction_1_0(), + grammarAccess.getRelationAccess().getBinaryExpressionLeftAction_1_0(), $current); } ) ( ( { - newCompositeNode(grammarAccess.getLogicalAndExpressionAccess().getOperatorLogicalAndOperatorParserRuleCall_1_1_0()); + newCompositeNode(grammarAccess.getRelationAccess().getOperatorRelationalOperatorParserRuleCall_1_1_0()); } - lv_operator_2_0=ruleLogicalAndOperator + lv_operator_2_0=ruleRelationalOperator { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getLogicalAndExpressionRule()); + $current = createModelElementForParent(grammarAccess.getRelationRule()); } set( $current, "operator", lv_operator_2_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalAndOperator"); + "org.osate.xtext.aadl2.ba.BehaviorAnnex.RelationalOperator"); afterParserOrEnumRuleCall(); } ) @@ -3268,35 +3314,35 @@ ruleLogicalAndExpression returns [EObject current=null] ( ( { - newCompositeNode(grammarAccess.getLogicalAndExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); + newCompositeNode(grammarAccess.getRelationAccess().getRightSimpleExpressionParserRuleCall_1_2_0()); } - lv_right_3_0=ruleRelationalExpression + lv_right_3_0=ruleSimpleExpression { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getLogicalAndExpressionRule()); + $current = createModelElementForParent(grammarAccess.getRelationRule()); } set( $current, "right", lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.RelationalExpression"); + "org.osate.xtext.aadl2.ba.BehaviorAnnex.SimpleExpression"); afterParserOrEnumRuleCall(); } ) ) - )* + )? ) ; -// Entry rule entryRuleLogicalAndOperator -entryRuleLogicalAndOperator returns [String current=null]: - { newCompositeNode(grammarAccess.getLogicalAndOperatorRule()); } - iv_ruleLogicalAndOperator=ruleLogicalAndOperator - { $current=$iv_ruleLogicalAndOperator.current.getText(); } +// Entry rule entryRuleRelationalOperator +entryRuleRelationalOperator returns [String current=null]: + { newCompositeNode(grammarAccess.getRelationalOperatorRule()); } + iv_ruleRelationalOperator=ruleRelationalOperator + { $current=$iv_ruleRelationalOperator.current.getText(); } EOF; -// Rule LogicalAndOperator -ruleLogicalAndOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +// Rule RelationalOperator +ruleRelationalOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] @init { enterRule(); } @@ -3304,30 +3350,53 @@ ruleLogicalAndOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatype leaveRule(); }: ( - kw=And + kw=EqualsSign { $current.merge(kw); - newLeafNode(kw, grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getEqualsSignKeyword_0()); + } + | + kw=ExclamationMarkEqualsSign + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getExclamationMarkEqualsSignKeyword_1()); + } + | + kw=LessThanSign + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getLessThanSignKeyword_2()); + } + | + kw=LessThanSignEqualsSign + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getLessThanSignEqualsSignKeyword_3()); + } + | + kw=GreaterThanSign + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getGreaterThanSignKeyword_4()); + } + | + kw=GreaterThanSignEqualsSign + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getGreaterThanSignEqualsSignKeyword_5()); } - ( - kw=Then - { - $current.merge(kw); - newLeafNode(kw, grammarAccess.getLogicalAndOperatorAccess().getThenKeyword_1()); - } - )? ) ; -// Entry rule entryRuleRelationalExpression -entryRuleRelationalExpression returns [EObject current=null]: - { newCompositeNode(grammarAccess.getRelationalExpressionRule()); } - iv_ruleRelationalExpression=ruleRelationalExpression - { $current=$iv_ruleRelationalExpression.current; } +// Entry rule entryRuleSimpleExpression +entryRuleSimpleExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getSimpleExpressionRule()); } + iv_ruleSimpleExpression=ruleSimpleExpression + { $current=$iv_ruleSimpleExpression.current; } EOF; -// Rule RelationalExpression -ruleRelationalExpression returns [EObject current=null] +// Rule SimpleExpression +ruleSimpleExpression returns [EObject current=null] @init { enterRule(); } @@ -3335,125 +3404,123 @@ ruleRelationalExpression returns [EObject current=null] leaveRule(); }: ( - { - newCompositeNode(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); - } - this_AdditiveExpression_0=ruleAdditiveExpression - { - $current = $this_AdditiveExpression_0.current; - afterParserOrEnumRuleCall(); - } ( - ( - { - $current = forceCreateModelElementAndSet( - grammarAccess.getRelationalExpressionAccess().getBinaryExpressionLeftAction_1_0(), - $current); - } - ) ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getSimpleExpressionAccess().getUnaryExpressionAction_0_0_0(), + $current); + } + ) ( ( - lv_operator_2_1=EqualsSign - { - newLeafNode(lv_operator_2_1, grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignKeyword_1_1_0_0()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getRelationalExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_2_1, null); - } - | - lv_operator_2_2=ExclamationMarkEqualsSign - { - newLeafNode(lv_operator_2_2, grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getRelationalExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_2_2, null); - } - | - lv_operator_2_3=LessThanSign - { - newLeafNode(lv_operator_2_3, grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_2()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getRelationalExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_2_3, null); - } - | - lv_operator_2_4=LessThanSignEqualsSign { - newLeafNode(lv_operator_2_4, grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); + newCompositeNode(grammarAccess.getSimpleExpressionAccess().getOperatorUnaryAddingOperatorParserRuleCall_0_0_1_0()); } + lv_operator_1_0=ruleUnaryAddingOperator { if ($current==null) { - $current = createModelElement(grammarAccess.getRelationalExpressionRule()); + $current = createModelElementForParent(grammarAccess.getSimpleExpressionRule()); } - setWithLastConsumed($current, "operator", lv_operator_2_4, null); - } - | - lv_operator_2_5=GreaterThanSign - { - newLeafNode(lv_operator_2_5, grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getRelationalExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_2_5, null); + set( + $current, + "operator", + lv_operator_1_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.UnaryAddingOperator"); + afterParserOrEnumRuleCall(); } - | - lv_operator_2_6=GreaterThanSignEqualsSign + ) + ) + ( + ( { - newLeafNode(lv_operator_2_6, grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_5()); + newCompositeNode(grammarAccess.getSimpleExpressionAccess().getOperandTermParserRuleCall_0_0_2_0()); } + lv_operand_2_0=ruleTerm { if ($current==null) { - $current = createModelElement(grammarAccess.getRelationalExpressionRule()); + $current = createModelElementForParent(grammarAccess.getSimpleExpressionRule()); } - setWithLastConsumed($current, "operator", lv_operator_2_6, null); + set( + $current, + "operand", + lv_operand_2_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Term"); + afterParserOrEnumRuleCall(); } ) ) + ) + | + { + newCompositeNode(grammarAccess.getSimpleExpressionAccess().getTermParserRuleCall_0_1()); + } + this_Term_3=ruleTerm + { + $current = $this_Term_3.current; + afterParserOrEnumRuleCall(); + } + ) + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getSimpleExpressionAccess().getBinaryExpressionLeftAction_1_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getSimpleExpressionAccess().getOperatorBinaryAddingOperatorParserRuleCall_1_1_0()); + } + lv_operator_5_0=ruleBinaryAddingOperator + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getSimpleExpressionRule()); + } + set( + $current, + "operator", + lv_operator_5_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.BinaryAddingOperator"); + afterParserOrEnumRuleCall(); + } + ) ) ( ( { - newCompositeNode(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); + newCompositeNode(grammarAccess.getSimpleExpressionAccess().getRightTermParserRuleCall_1_2_0()); } - lv_right_3_0=ruleAdditiveExpression + lv_right_6_0=ruleTerm { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getRelationalExpressionRule()); + $current = createModelElementForParent(grammarAccess.getSimpleExpressionRule()); } set( $current, "right", - lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.AdditiveExpression"); + lv_right_6_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Term"); afterParserOrEnumRuleCall(); } ) ) - )? + )* ) ; -// Entry rule entryRuleAdditiveExpression -entryRuleAdditiveExpression returns [EObject current=null]: - { newCompositeNode(grammarAccess.getAdditiveExpressionRule()); } - iv_ruleAdditiveExpression=ruleAdditiveExpression - { $current=$iv_ruleAdditiveExpression.current; } +// Entry rule entryRuleUnaryAddingOperator +entryRuleUnaryAddingOperator returns [String current=null]: + { newCompositeNode(grammarAccess.getUnaryAddingOperatorRule()); } + iv_ruleUnaryAddingOperator=ruleUnaryAddingOperator + { $current=$iv_ruleUnaryAddingOperator.current.getText(); } EOF; -// Rule AdditiveExpression -ruleAdditiveExpression returns [EObject current=null] +// Rule UnaryAddingOperator +ruleUnaryAddingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] @init { enterRule(); } @@ -3461,81 +3528,29 @@ ruleAdditiveExpression returns [EObject current=null] leaveRule(); }: ( + kw=HyphenMinus { - newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); + $current.merge(kw); + newLeafNode(kw, grammarAccess.getUnaryAddingOperatorAccess().getHyphenMinusKeyword_0()); } - this_MultiplicativeExpression_0=ruleMultiplicativeExpression + | + kw=PlusSign { - $current = $this_MultiplicativeExpression_0.current; - afterParserOrEnumRuleCall(); + $current.merge(kw); + newLeafNode(kw, grammarAccess.getUnaryAddingOperatorAccess().getPlusSignKeyword_1()); } - ( - ( - { - $current = forceCreateModelElementAndSet( - grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(), - $current); - } - ) - ( - ( - ( - lv_operator_2_1=PlusSign - { - newLeafNode(lv_operator_2_1, grammarAccess.getAdditiveExpressionAccess().getOperatorPlusSignKeyword_1_1_0_0()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getAdditiveExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_2_1, null); - } - | - lv_operator_2_2=HyphenMinus - { - newLeafNode(lv_operator_2_2, grammarAccess.getAdditiveExpressionAccess().getOperatorHyphenMinusKeyword_1_1_0_1()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getAdditiveExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_2_2, null); - } - ) - ) - ) - ( - ( - { - newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); - } - lv_right_3_0=ruleMultiplicativeExpression - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); - } - set( - $current, - "right", - lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.MultiplicativeExpression"); - afterParserOrEnumRuleCall(); - } - ) - ) - )* ) ; -// Entry rule entryRuleMultiplicativeExpression -entryRuleMultiplicativeExpression returns [EObject current=null]: - { newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); } - iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression - { $current=$iv_ruleMultiplicativeExpression.current; } +// Entry rule entryRuleBinaryAddingOperator +entryRuleBinaryAddingOperator returns [String current=null]: + { newCompositeNode(grammarAccess.getBinaryAddingOperatorRule()); } + iv_ruleBinaryAddingOperator=ruleBinaryAddingOperator + { $current=$iv_ruleBinaryAddingOperator.current.getText(); } EOF; -// Rule MultiplicativeExpression -ruleMultiplicativeExpression returns [EObject current=null] +// Rule BinaryAddingOperator +ruleBinaryAddingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] @init { enterRule(); } @@ -3543,103 +3558,29 @@ ruleMultiplicativeExpression returns [EObject current=null] leaveRule(); }: ( + kw=PlusSign { - newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getPowerExpressionParserRuleCall_0()); + $current.merge(kw); + newLeafNode(kw, grammarAccess.getBinaryAddingOperatorAccess().getPlusSignKeyword_0()); } - this_PowerExpression_0=rulePowerExpression + | + kw=HyphenMinus { - $current = $this_PowerExpression_0.current; - afterParserOrEnumRuleCall(); + $current.merge(kw); + newLeafNode(kw, grammarAccess.getBinaryAddingOperatorAccess().getHyphenMinusKeyword_1()); } - ( - ( - { - $current = forceCreateModelElementAndSet( - grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(), - $current); - } - ) - ( - ( - ( - lv_operator_2_1=Asterisk - { - newLeafNode(lv_operator_2_1, grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskKeyword_1_1_0_0()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getMultiplicativeExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_2_1, null); - } - | - lv_operator_2_2=Solidus - { - newLeafNode(lv_operator_2_2, grammarAccess.getMultiplicativeExpressionAccess().getOperatorSolidusKeyword_1_1_0_1()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getMultiplicativeExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_2_2, null); - } - | - lv_operator_2_3=Mod - { - newLeafNode(lv_operator_2_3, grammarAccess.getMultiplicativeExpressionAccess().getOperatorModKeyword_1_1_0_2()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getMultiplicativeExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_2_3, null); - } - | - lv_operator_2_4=Rem - { - newLeafNode(lv_operator_2_4, grammarAccess.getMultiplicativeExpressionAccess().getOperatorRemKeyword_1_1_0_3()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getMultiplicativeExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_2_4, null); - } - ) - ) - ) - ( - ( - { - newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); - } - lv_right_3_0=rulePowerExpression - { - if ($current==null) { - $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); - } - set( - $current, - "right", - lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.PowerExpression"); - afterParserOrEnumRuleCall(); - } - ) - ) - )* ) ; -// Entry rule entryRulePowerExpression -entryRulePowerExpression returns [EObject current=null]: - { newCompositeNode(grammarAccess.getPowerExpressionRule()); } - iv_rulePowerExpression=rulePowerExpression - { $current=$iv_rulePowerExpression.current; } +// Entry rule entryRuleTerm +entryRuleTerm returns [EObject current=null]: + { newCompositeNode(grammarAccess.getTermRule()); } + iv_ruleTerm=ruleTerm + { $current=$iv_ruleTerm.current; } EOF; -// Rule PowerExpression -rulePowerExpression returns [EObject current=null] +// Rule Term +ruleTerm returns [EObject current=null] @init { enterRule(); } @@ -3648,67 +3589,114 @@ rulePowerExpression returns [EObject current=null] }: ( { - newCompositeNode(grammarAccess.getPowerExpressionAccess().getUnaryExpressionParserRuleCall_0()); + newCompositeNode(grammarAccess.getTermAccess().getFactorParserRuleCall_0()); } - this_UnaryExpression_0=ruleUnaryExpression + this_Factor_0=ruleFactor { - $current = $this_UnaryExpression_0.current; + $current = $this_Factor_0.current; afterParserOrEnumRuleCall(); } ( ( { $current = forceCreateModelElementAndSet( - grammarAccess.getPowerExpressionAccess().getBinaryExpressionLeftAction_1_0(), + grammarAccess.getTermAccess().getBinaryExpressionLeftAction_1_0(), $current); } ) ( ( - lv_operator_2_0=AsteriskAsterisk { - newLeafNode(lv_operator_2_0, grammarAccess.getPowerExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_0()); + newCompositeNode(grammarAccess.getTermAccess().getOperatorMultiplyingOperatorParserRuleCall_1_1_0()); } + lv_operator_2_0=ruleMultiplyingOperator { if ($current==null) { - $current = createModelElement(grammarAccess.getPowerExpressionRule()); + $current = createModelElementForParent(grammarAccess.getTermRule()); } - setWithLastConsumed($current, "operator", lv_operator_2_0, "**"); + set( + $current, + "operator", + lv_operator_2_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.MultiplyingOperator"); + afterParserOrEnumRuleCall(); } ) ) ( ( { - newCompositeNode(grammarAccess.getPowerExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); + newCompositeNode(grammarAccess.getTermAccess().getRightFactorParserRuleCall_1_2_0()); } - lv_right_3_0=rulePowerExpression + lv_right_3_0=ruleFactor { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getPowerExpressionRule()); + $current = createModelElementForParent(grammarAccess.getTermRule()); } set( $current, "right", lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.PowerExpression"); + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Factor"); afterParserOrEnumRuleCall(); } ) ) - )? + )* + ) +; + +// Entry rule entryRuleMultiplyingOperator +entryRuleMultiplyingOperator returns [String current=null]: + { newCompositeNode(grammarAccess.getMultiplyingOperatorRule()); } + iv_ruleMultiplyingOperator=ruleMultiplyingOperator + { $current=$iv_ruleMultiplyingOperator.current.getText(); } + EOF; + +// Rule MultiplyingOperator +ruleMultiplyingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw=Asterisk + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getMultiplyingOperatorAccess().getAsteriskKeyword_0()); + } + | + kw=Solidus + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getMultiplyingOperatorAccess().getSolidusKeyword_1()); + } + | + kw=Mod + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getMultiplyingOperatorAccess().getModKeyword_2()); + } + | + kw=Rem + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getMultiplyingOperatorAccess().getRemKeyword_3()); + } ) ; -// Entry rule entryRuleUnaryExpression -entryRuleUnaryExpression returns [EObject current=null]: - { newCompositeNode(grammarAccess.getUnaryExpressionRule()); } - iv_ruleUnaryExpression=ruleUnaryExpression - { $current=$iv_ruleUnaryExpression.current; } +// Entry rule entryRuleFactor +entryRuleFactor returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFactorRule()); } + iv_ruleFactor=ruleFactor + { $current=$iv_ruleFactor.current; } EOF; -// Rule UnaryExpression -ruleUnaryExpression returns [EObject current=null] +// Rule Factor +ruleFactor returns [EObject current=null] @init { enterRule(); } @@ -3717,103 +3705,174 @@ ruleUnaryExpression returns [EObject current=null] }: ( ( - ( - { - $current = forceCreateModelElement( - grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_0_0(), - $current); - } - ) + { + newCompositeNode(grammarAccess.getFactorAccess().getValueParserRuleCall_0_0()); + } + this_Value_0=ruleValue + { + $current = $this_Value_0.current; + afterParserOrEnumRuleCall(); + } ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getFactorAccess().getBinaryExpressionLeftAction_0_1_0(), + $current); + } + ) ( ( - lv_operator_1_1=PlusSign - { - newLeafNode(lv_operator_1_1, grammarAccess.getUnaryExpressionAccess().getOperatorPlusSignKeyword_0_1_0_0()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getUnaryExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_1_1, null); - } - | - lv_operator_1_2=HyphenMinus { - newLeafNode(lv_operator_1_2, grammarAccess.getUnaryExpressionAccess().getOperatorHyphenMinusKeyword_0_1_0_1()); + newCompositeNode(grammarAccess.getFactorAccess().getOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0()); } + lv_operator_2_0=ruleBinaryNumericOperator { if ($current==null) { - $current = createModelElement(grammarAccess.getUnaryExpressionRule()); + $current = createModelElementForParent(grammarAccess.getFactorRule()); } - setWithLastConsumed($current, "operator", lv_operator_1_2, null); - } - | - lv_operator_1_3=Abs - { - newLeafNode(lv_operator_1_3, grammarAccess.getUnaryExpressionAccess().getOperatorAbsKeyword_0_1_0_2()); - } - { - if ($current==null) { - $current = createModelElement(grammarAccess.getUnaryExpressionRule()); - } - setWithLastConsumed($current, "operator", lv_operator_1_3, null); + set( + $current, + "operator", + lv_operator_2_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.BinaryNumericOperator"); + afterParserOrEnumRuleCall(); } - | - lv_operator_1_4=Not + ) + ) + ( + ( { - newLeafNode(lv_operator_1_4, grammarAccess.getUnaryExpressionAccess().getOperatorNotKeyword_0_1_0_3()); + newCompositeNode(grammarAccess.getFactorAccess().getRightValueParserRuleCall_0_1_2_0()); } + lv_right_3_0=ruleValue { if ($current==null) { - $current = createModelElement(grammarAccess.getUnaryExpressionRule()); + $current = createModelElementForParent(grammarAccess.getFactorRule()); } - setWithLastConsumed($current, "operator", lv_operator_1_4, null); + set( + $current, + "right", + lv_right_3_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Value"); + afterParserOrEnumRuleCall(); } ) ) + )? + ) + | + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getFactorAccess().getUnaryExpressionAction_1_0(), + $current); + } ) ( ( { - newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOperandUnaryExpressionParserRuleCall_0_2_0()); + newCompositeNode(grammarAccess.getFactorAccess().getOperatorUnaryValueOperatorParserRuleCall_1_1_0()); } - lv_operand_2_0=ruleUnaryExpression + lv_operator_5_0=ruleUnaryValueOperator { if ($current==null) { - $current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); + $current = createModelElementForParent(grammarAccess.getFactorRule()); + } + set( + $current, + "operator", + lv_operator_5_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.UnaryValueOperator"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getFactorAccess().getOperandValueParserRuleCall_1_2_0()); + } + lv_operand_6_0=ruleValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getFactorRule()); } set( $current, "operand", - lv_operand_2_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.UnaryExpression"); + lv_operand_6_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Value"); afterParserOrEnumRuleCall(); } ) ) ) - | + ) +; + +// Entry rule entryRuleBinaryNumericOperator +entryRuleBinaryNumericOperator returns [String current=null]: + { newCompositeNode(grammarAccess.getBinaryNumericOperatorRule()); } + iv_ruleBinaryNumericOperator=ruleBinaryNumericOperator + { $current=$iv_ruleBinaryNumericOperator.current.getText(); } + EOF; + +// Rule BinaryNumericOperator +ruleBinaryNumericOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw=AsteriskAsterisk + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getBinaryNumericOperatorAccess().getAsteriskAsteriskKeyword()); + } +; + +// Entry rule entryRuleUnaryValueOperator +entryRuleUnaryValueOperator returns [String current=null]: + { newCompositeNode(grammarAccess.getUnaryValueOperatorRule()); } + iv_ruleUnaryValueOperator=ruleUnaryValueOperator + { $current=$iv_ruleUnaryValueOperator.current.getText(); } + EOF; + +// Rule UnaryValueOperator +ruleUnaryValueOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw=Abs { - newCompositeNode(grammarAccess.getUnaryExpressionAccess().getPrimaryExpressionParserRuleCall_1()); + $current.merge(kw); + newLeafNode(kw, grammarAccess.getUnaryValueOperatorAccess().getAbsKeyword_0()); } - this_PrimaryExpression_3=rulePrimaryExpression + | + kw=Not { - $current = $this_PrimaryExpression_3.current; - afterParserOrEnumRuleCall(); + $current.merge(kw); + newLeafNode(kw, grammarAccess.getUnaryValueOperatorAccess().getNotKeyword_1()); } ) ; -// Entry rule entryRulePrimaryExpression -entryRulePrimaryExpression returns [EObject current=null]: - { newCompositeNode(grammarAccess.getPrimaryExpressionRule()); } - iv_rulePrimaryExpression=rulePrimaryExpression - { $current=$iv_rulePrimaryExpression.current; } +// Entry rule entryRuleValue +entryRuleValue returns [EObject current=null]: + { newCompositeNode(grammarAccess.getValueRule()); } + iv_ruleValue=ruleValue + { $current=$iv_ruleValue.current; } EOF; -// Rule PrimaryExpression -rulePrimaryExpression returns [EObject current=null] +// Rule Value +ruleValue returns [EObject current=null] @init { enterRule(); } @@ -3822,7 +3881,7 @@ rulePrimaryExpression returns [EObject current=null] }: ( { - newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getValueConstantParserRuleCall_0()); + newCompositeNode(grammarAccess.getValueAccess().getValueConstantParserRuleCall_0()); } this_ValueConstant_0=ruleValueConstant { @@ -3831,7 +3890,7 @@ rulePrimaryExpression returns [EObject current=null] } | { - newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getReferenceExpressionParserRuleCall_1()); + newCompositeNode(grammarAccess.getValueAccess().getReferenceExpressionParserRuleCall_1()); } this_ReferenceExpression_1=ruleReferenceExpression { @@ -3839,24 +3898,60 @@ rulePrimaryExpression returns [EObject current=null] afterParserOrEnumRuleCall(); } | + { + newCompositeNode(grammarAccess.getValueAccess().getParenthesizedExpressionParserRuleCall_2()); + } + this_ParenthesizedExpression_2=ruleParenthesizedExpression + { + $current = $this_ParenthesizedExpression_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleParenthesizedExpression +entryRuleParenthesizedExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParenthesizedExpressionRule()); } + iv_ruleParenthesizedExpression=ruleParenthesizedExpression + { $current=$iv_ruleParenthesizedExpression.current; } + EOF; + +// Rule ParenthesizedExpression +ruleParenthesizedExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0=LeftParenthesis + { + newLeafNode(otherlv_0, grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } ( - otherlv_2=LeftParenthesis - { - newLeafNode(otherlv_2, grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_2_0()); - } - { - newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getValueExpressionParserRuleCall_2_1()); - } - this_ValueExpression_3=ruleValueExpression - { - $current = $this_ValueExpression_3.current; - afterParserOrEnumRuleCall(); - } - otherlv_4=RightParenthesis - { - newLeafNode(otherlv_4, grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_2_2()); - } + ( + { + newCompositeNode(grammarAccess.getParenthesizedExpressionAccess().getExpressionValueExpressionParserRuleCall_1_0()); + } + lv_expression_1_0=ruleValueExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParenthesizedExpressionRule()); + } + set( + $current, + "expression", + lv_expression_1_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.ValueExpression"); + afterParserOrEnumRuleCall(); + } + ) ) + otherlv_2=RightParenthesis + { + newLeafNode(otherlv_2, grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } ) ; 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 879db7e799..9adb1b8061 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 @@ -8600,103 +8600,11 @@ public final EObject entryRuleValueExpression() throws RecognitionException { // $ANTLR start "ruleValueExpression" - // InternalBehaviorAnnexParser.g:3087:1: ruleValueExpression returns [EObject current=null] : this_LogicalOrExpression_0= ruleLogicalOrExpression ; + // InternalBehaviorAnnexParser.g:3087: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; - EObject this_LogicalOrExpression_0 = null; - - - - enterRule(); - - try { - // InternalBehaviorAnnexParser.g:3093:2: (this_LogicalOrExpression_0= ruleLogicalOrExpression ) - // InternalBehaviorAnnexParser.g:3094:2: this_LogicalOrExpression_0= ruleLogicalOrExpression - { - if ( state.backtracking==0 ) { - - newCompositeNode(grammarAccess.getValueExpressionAccess().getLogicalOrExpressionParserRuleCall()); - - } - pushFollow(FollowSets000.FOLLOW_2); - this_LogicalOrExpression_0=ruleLogicalOrExpression(); - - state._fsp--; - if (state.failed) return current; - if ( state.backtracking==0 ) { - - current = this_LogicalOrExpression_0; - afterParserOrEnumRuleCall(); - - } - - } - - if ( state.backtracking==0 ) { - - leaveRule(); - - } - } - - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "ruleValueExpression" - - - // $ANTLR start "entryRuleLogicalOrExpression" - // InternalBehaviorAnnexParser.g:3105:1: entryRuleLogicalOrExpression returns [EObject current=null] : iv_ruleLogicalOrExpression= ruleLogicalOrExpression EOF ; - public final EObject entryRuleLogicalOrExpression() throws RecognitionException { - EObject current = null; - - EObject iv_ruleLogicalOrExpression = null; - - - try { - // InternalBehaviorAnnexParser.g:3105:60: (iv_ruleLogicalOrExpression= ruleLogicalOrExpression EOF ) - // InternalBehaviorAnnexParser.g:3106:2: iv_ruleLogicalOrExpression= ruleLogicalOrExpression EOF - { - if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getLogicalOrExpressionRule()); - } - pushFollow(FollowSets000.FOLLOW_1); - iv_ruleLogicalOrExpression=ruleLogicalOrExpression(); - - state._fsp--; - if (state.failed) return current; - if ( state.backtracking==0 ) { - current =iv_ruleLogicalOrExpression; - } - match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; - - } - - } - - catch (RecognitionException re) { - recover(input,re); - appendSkippedTokens(); - } - finally { - } - return current; - } - // $ANTLR end "entryRuleLogicalOrExpression" - - - // $ANTLR start "ruleLogicalOrExpression" - // InternalBehaviorAnnexParser.g:3112:1: ruleLogicalOrExpression returns [EObject current=null] : (this_LogicalAndExpression_0= ruleLogicalAndExpression ( () ( (lv_operator_2_0= ruleLogicalOrOperator ) ) ( (lv_right_3_0= ruleLogicalAndExpression ) ) )* ) ; - public final EObject ruleLogicalOrExpression() throws RecognitionException { - EObject current = null; - - EObject this_LogicalAndExpression_0 = null; + EObject this_Relation_0 = null; AntlrDatatypeRuleToken lv_operator_2_0 = null; @@ -8707,82 +8615,82 @@ public final EObject ruleLogicalOrExpression() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3118:2: ( (this_LogicalAndExpression_0= ruleLogicalAndExpression ( () ( (lv_operator_2_0= ruleLogicalOrOperator ) ) ( (lv_right_3_0= ruleLogicalAndExpression ) ) )* ) ) - // InternalBehaviorAnnexParser.g:3119:2: (this_LogicalAndExpression_0= ruleLogicalAndExpression ( () ( (lv_operator_2_0= ruleLogicalOrOperator ) ) ( (lv_right_3_0= ruleLogicalAndExpression ) ) )* ) + // 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:3119:2: (this_LogicalAndExpression_0= ruleLogicalAndExpression ( () ( (lv_operator_2_0= ruleLogicalOrOperator ) ) ( (lv_right_3_0= ruleLogicalAndExpression ) ) )* ) - // InternalBehaviorAnnexParser.g:3120:3: this_LogicalAndExpression_0= ruleLogicalAndExpression ( () ( (lv_operator_2_0= ruleLogicalOrOperator ) ) ( (lv_right_3_0= ruleLogicalAndExpression ) ) )* + // 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 ) ) )* { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getLogicalOrExpressionAccess().getLogicalAndExpressionParserRuleCall_0()); + newCompositeNode(grammarAccess.getValueExpressionAccess().getRelationParserRuleCall_0()); } - pushFollow(FollowSets000.FOLLOW_38); - this_LogicalAndExpression_0=ruleLogicalAndExpression(); + pushFollow(FollowSets000.FOLLOW_62); + this_Relation_0=ruleRelation(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { - current = this_LogicalAndExpression_0; + current = this_Relation_0; afterParserOrEnumRuleCall(); } - // InternalBehaviorAnnexParser.g:3128:3: ( () ( (lv_operator_2_0= ruleLogicalOrOperator ) ) ( (lv_right_3_0= ruleLogicalAndExpression ) ) )* + // InternalBehaviorAnnexParser.g:3103:3: ( () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) )* loop57: do { int alt57=2; int LA57_0 = input.LA(1); - if ( (LA57_0==Xor||LA57_0==Or) ) { + if ( (LA57_0==And||LA57_0==Xor||LA57_0==Or) ) { alt57=1; } switch (alt57) { case 1 : - // InternalBehaviorAnnexParser.g:3129:4: () ( (lv_operator_2_0= ruleLogicalOrOperator ) ) ( (lv_right_3_0= ruleLogicalAndExpression ) ) + // InternalBehaviorAnnexParser.g:3104:4: () ( (lv_operator_2_0= ruleLogicalOperator ) ) ( (lv_right_3_0= ruleRelation ) ) { - // InternalBehaviorAnnexParser.g:3129:4: () - // InternalBehaviorAnnexParser.g:3130:5: + // InternalBehaviorAnnexParser.g:3104:4: () + // InternalBehaviorAnnexParser.g:3105:5: { if ( state.backtracking==0 ) { current = forceCreateModelElementAndSet( - grammarAccess.getLogicalOrExpressionAccess().getBinaryExpressionLeftAction_1_0(), + grammarAccess.getValueExpressionAccess().getBinaryExpressionLeftAction_1_0(), current); } } - // InternalBehaviorAnnexParser.g:3136:4: ( (lv_operator_2_0= ruleLogicalOrOperator ) ) - // InternalBehaviorAnnexParser.g:3137:5: (lv_operator_2_0= ruleLogicalOrOperator ) + // InternalBehaviorAnnexParser.g:3111:4: ( (lv_operator_2_0= ruleLogicalOperator ) ) + // InternalBehaviorAnnexParser.g:3112:5: (lv_operator_2_0= ruleLogicalOperator ) { - // InternalBehaviorAnnexParser.g:3137:5: (lv_operator_2_0= ruleLogicalOrOperator ) - // InternalBehaviorAnnexParser.g:3138:6: lv_operator_2_0= ruleLogicalOrOperator + // InternalBehaviorAnnexParser.g:3112:5: (lv_operator_2_0= ruleLogicalOperator ) + // InternalBehaviorAnnexParser.g:3113:6: lv_operator_2_0= ruleLogicalOperator { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getLogicalOrExpressionAccess().getOperatorLogicalOrOperatorParserRuleCall_1_1_0()); + newCompositeNode(grammarAccess.getValueExpressionAccess().getOperatorLogicalOperatorParserRuleCall_1_1_0()); } pushFollow(FollowSets000.FOLLOW_50); - lv_operator_2_0=ruleLogicalOrOperator(); + lv_operator_2_0=ruleLogicalOperator(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { if (current==null) { - current = createModelElementForParent(grammarAccess.getLogicalOrExpressionRule()); + current = createModelElementForParent(grammarAccess.getValueExpressionRule()); } set( current, "operator", lv_operator_2_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalOrOperator"); + "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalOperator"); afterParserOrEnumRuleCall(); } @@ -8792,32 +8700,32 @@ public final EObject ruleLogicalOrExpression() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:3155:4: ( (lv_right_3_0= ruleLogicalAndExpression ) ) - // InternalBehaviorAnnexParser.g:3156:5: (lv_right_3_0= ruleLogicalAndExpression ) + // InternalBehaviorAnnexParser.g:3130:4: ( (lv_right_3_0= ruleRelation ) ) + // InternalBehaviorAnnexParser.g:3131:5: (lv_right_3_0= ruleRelation ) { - // InternalBehaviorAnnexParser.g:3156:5: (lv_right_3_0= ruleLogicalAndExpression ) - // InternalBehaviorAnnexParser.g:3157:6: lv_right_3_0= ruleLogicalAndExpression + // InternalBehaviorAnnexParser.g:3131:5: (lv_right_3_0= ruleRelation ) + // InternalBehaviorAnnexParser.g:3132:6: lv_right_3_0= ruleRelation { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getLogicalOrExpressionAccess().getRightLogicalAndExpressionParserRuleCall_1_2_0()); + newCompositeNode(grammarAccess.getValueExpressionAccess().getRightRelationParserRuleCall_1_2_0()); } - pushFollow(FollowSets000.FOLLOW_38); - lv_right_3_0=ruleLogicalAndExpression(); + pushFollow(FollowSets000.FOLLOW_62); + lv_right_3_0=ruleRelation(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { if (current==null) { - current = createModelElementForParent(grammarAccess.getLogicalOrExpressionRule()); + current = createModelElementForParent(grammarAccess.getValueExpressionRule()); } set( current, "right", lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalAndExpression"); + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Relation"); afterParserOrEnumRuleCall(); } @@ -8857,11 +8765,162 @@ public final EObject ruleLogicalOrExpression() throws RecognitionException { } return current; } - // $ANTLR end "ruleLogicalOrExpression" + // $ANTLR end "ruleValueExpression" + + + // $ANTLR start "entryRuleLogicalOperator" + // InternalBehaviorAnnexParser.g:3154:1: entryRuleLogicalOperator returns [String current=null] : iv_ruleLogicalOperator= ruleLogicalOperator EOF ; + public final String entryRuleLogicalOperator() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleLogicalOperator = null; + + + try { + // InternalBehaviorAnnexParser.g:3154:55: (iv_ruleLogicalOperator= ruleLogicalOperator EOF ) + // InternalBehaviorAnnexParser.g:3155:2: iv_ruleLogicalOperator= ruleLogicalOperator EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getLogicalOperatorRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + iv_ruleLogicalOperator=ruleLogicalOperator(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleLogicalOperator.getText(); + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleLogicalOperator" + + + // $ANTLR start "ruleLogicalOperator" + // InternalBehaviorAnnexParser.g:3161: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(); + + AntlrDatatypeRuleToken this_LogicalAndOperator_0 = null; + + AntlrDatatypeRuleToken this_LogicalOrOperator_1 = null; + + + + 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:3168:2: (this_LogicalAndOperator_0= ruleLogicalAndOperator | this_LogicalOrOperator_1= ruleLogicalOrOperator ) + int alt58=2; + int LA58_0 = input.LA(1); + + if ( (LA58_0==And) ) { + alt58=1; + } + else if ( (LA58_0==Xor||LA58_0==Or) ) { + alt58=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 58, 0, input); + + throw nvae; + } + switch (alt58) { + case 1 : + // InternalBehaviorAnnexParser.g:3169:3: this_LogicalAndOperator_0= ruleLogicalAndOperator + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getLogicalOperatorAccess().getLogicalAndOperatorParserRuleCall_0()); + + } + pushFollow(FollowSets000.FOLLOW_2); + this_LogicalAndOperator_0=ruleLogicalAndOperator(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_LogicalAndOperator_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalBehaviorAnnexParser.g:3180:3: this_LogicalOrOperator_1= ruleLogicalOrOperator + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getLogicalOperatorAccess().getLogicalOrOperatorParserRuleCall_1()); + + } + pushFollow(FollowSets000.FOLLOW_2); + this_LogicalOrOperator_1=ruleLogicalOrOperator(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_LogicalOrOperator_1); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleLogicalOperator" // $ANTLR start "entryRuleLogicalOrOperator" - // InternalBehaviorAnnexParser.g:3179:1: entryRuleLogicalOrOperator returns [String current=null] : iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF ; + // InternalBehaviorAnnexParser.g:3194:1: entryRuleLogicalOrOperator returns [String current=null] : iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF ; public final String entryRuleLogicalOrOperator() throws RecognitionException { String current = null; @@ -8869,8 +8928,8 @@ public final String entryRuleLogicalOrOperator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3179:57: (iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF ) - // InternalBehaviorAnnexParser.g:3180:2: iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF + // InternalBehaviorAnnexParser.g:3194:57: (iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF ) + // InternalBehaviorAnnexParser.g:3195:2: iv_ruleLogicalOrOperator= ruleLogicalOrOperator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getLogicalOrOperatorRule()); @@ -8901,7 +8960,7 @@ public final String entryRuleLogicalOrOperator() throws RecognitionException { // $ANTLR start "ruleLogicalOrOperator" - // InternalBehaviorAnnexParser.g:3186:1: ruleLogicalOrOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= Or (kw= Else )? ) | kw= Xor ) ; + // InternalBehaviorAnnexParser.g:3201:1: ruleLogicalOrOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= Or (kw= Else )? ) | kw= Xor ) ; public final AntlrDatatypeRuleToken ruleLogicalOrOperator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -8911,50 +8970,50 @@ public final AntlrDatatypeRuleToken ruleLogicalOrOperator() throws RecognitionEx enterRule(); try { - // InternalBehaviorAnnexParser.g:3192:2: ( ( (kw= Or (kw= Else )? ) | kw= Xor ) ) - // InternalBehaviorAnnexParser.g:3193:2: ( (kw= Or (kw= Else )? ) | kw= Xor ) + // InternalBehaviorAnnexParser.g:3207:2: ( ( (kw= Or (kw= Else )? ) | kw= Xor ) ) + // InternalBehaviorAnnexParser.g:3208:2: ( (kw= Or (kw= Else )? ) | kw= Xor ) { - // InternalBehaviorAnnexParser.g:3193:2: ( (kw= Or (kw= Else )? ) | kw= Xor ) - int alt59=2; - int LA59_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3208:2: ( (kw= Or (kw= Else )? ) | kw= Xor ) + int alt60=2; + int LA60_0 = input.LA(1); - if ( (LA59_0==Or) ) { - alt59=1; + if ( (LA60_0==Or) ) { + alt60=1; } - else if ( (LA59_0==Xor) ) { - alt59=2; + else if ( (LA60_0==Xor) ) { + alt60=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 59, 0, input); + new NoViableAltException("", 60, 0, input); throw nvae; } - switch (alt59) { + switch (alt60) { case 1 : - // InternalBehaviorAnnexParser.g:3194:3: (kw= Or (kw= Else )? ) + // InternalBehaviorAnnexParser.g:3209:3: (kw= Or (kw= Else )? ) { - // InternalBehaviorAnnexParser.g:3194:3: (kw= Or (kw= Else )? ) - // InternalBehaviorAnnexParser.g:3195:4: kw= Or (kw= Else )? + // InternalBehaviorAnnexParser.g:3209:3: (kw= Or (kw= Else )? ) + // InternalBehaviorAnnexParser.g:3210:4: kw= Or (kw= Else )? { - kw=(Token)match(input,Or,FollowSets000.FOLLOW_62); if (state.failed) return current; + kw=(Token)match(input,Or,FollowSets000.FOLLOW_63); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(kw); newLeafNode(kw, grammarAccess.getLogicalOrOperatorAccess().getOrKeyword_0_0()); } - // InternalBehaviorAnnexParser.g:3200:4: (kw= Else )? - int alt58=2; - int LA58_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3215:4: (kw= Else )? + int alt59=2; + int LA59_0 = input.LA(1); - if ( (LA58_0==Else) ) { - alt58=1; + if ( (LA59_0==Else) ) { + alt59=1; } - switch (alt58) { + switch (alt59) { case 1 : - // InternalBehaviorAnnexParser.g:3201:5: kw= Else + // InternalBehaviorAnnexParser.g:3216:5: kw= Else { kw=(Token)match(input,Else,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -8976,7 +9035,7 @@ else if ( (LA59_0==Xor) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:3209:3: kw= Xor + // InternalBehaviorAnnexParser.g:3224:3: kw= Xor { kw=(Token)match(input,Xor,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -9012,28 +9071,28 @@ else if ( (LA59_0==Xor) ) { // $ANTLR end "ruleLogicalOrOperator" - // $ANTLR start "entryRuleLogicalAndExpression" - // InternalBehaviorAnnexParser.g:3218:1: entryRuleLogicalAndExpression returns [EObject current=null] : iv_ruleLogicalAndExpression= ruleLogicalAndExpression EOF ; - public final EObject entryRuleLogicalAndExpression() throws RecognitionException { - EObject current = null; + // $ANTLR start "entryRuleLogicalAndOperator" + // InternalBehaviorAnnexParser.g:3233:1: entryRuleLogicalAndOperator returns [String current=null] : iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF ; + public final String entryRuleLogicalAndOperator() throws RecognitionException { + String current = null; - EObject iv_ruleLogicalAndExpression = null; + AntlrDatatypeRuleToken iv_ruleLogicalAndOperator = null; try { - // InternalBehaviorAnnexParser.g:3218:61: (iv_ruleLogicalAndExpression= ruleLogicalAndExpression EOF ) - // InternalBehaviorAnnexParser.g:3219:2: iv_ruleLogicalAndExpression= ruleLogicalAndExpression EOF + // InternalBehaviorAnnexParser.g:3233:58: (iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF ) + // InternalBehaviorAnnexParser.g:3234:2: iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getLogicalAndExpressionRule()); + newCompositeNode(grammarAccess.getLogicalAndOperatorRule()); } pushFollow(FollowSets000.FOLLOW_1); - iv_ruleLogicalAndExpression=ruleLogicalAndExpression(); + iv_ruleLogicalAndOperator=ruleLogicalAndOperator(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { - current =iv_ruleLogicalAndExpression; + current =iv_ruleLogicalAndOperator.getText(); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; @@ -9049,159 +9108,62 @@ public final EObject entryRuleLogicalAndExpression() throws RecognitionException } return current; } - // $ANTLR end "entryRuleLogicalAndExpression" - - - // $ANTLR start "ruleLogicalAndExpression" - // InternalBehaviorAnnexParser.g:3225:1: ruleLogicalAndExpression returns [EObject current=null] : (this_RelationalExpression_0= ruleRelationalExpression ( () ( (lv_operator_2_0= ruleLogicalAndOperator ) ) ( (lv_right_3_0= ruleRelationalExpression ) ) )* ) ; - public final EObject ruleLogicalAndExpression() throws RecognitionException { - EObject current = null; - - EObject this_RelationalExpression_0 = null; + // $ANTLR end "entryRuleLogicalAndOperator" - AntlrDatatypeRuleToken lv_operator_2_0 = null; - EObject lv_right_3_0 = null; + // $ANTLR start "ruleLogicalAndOperator" + // InternalBehaviorAnnexParser.g:3240:1: ruleLogicalAndOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= And (kw= Then )? ) ; + public final AntlrDatatypeRuleToken ruleLogicalAndOperator() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + Token kw=null; enterRule(); try { - // InternalBehaviorAnnexParser.g:3231:2: ( (this_RelationalExpression_0= ruleRelationalExpression ( () ( (lv_operator_2_0= ruleLogicalAndOperator ) ) ( (lv_right_3_0= ruleRelationalExpression ) ) )* ) ) - // InternalBehaviorAnnexParser.g:3232:2: (this_RelationalExpression_0= ruleRelationalExpression ( () ( (lv_operator_2_0= ruleLogicalAndOperator ) ) ( (lv_right_3_0= ruleRelationalExpression ) ) )* ) + // InternalBehaviorAnnexParser.g:3246:2: ( (kw= And (kw= Then )? ) ) + // InternalBehaviorAnnexParser.g:3247:2: (kw= And (kw= Then )? ) { - // InternalBehaviorAnnexParser.g:3232:2: (this_RelationalExpression_0= ruleRelationalExpression ( () ( (lv_operator_2_0= ruleLogicalAndOperator ) ) ( (lv_right_3_0= ruleRelationalExpression ) ) )* ) - // InternalBehaviorAnnexParser.g:3233:3: this_RelationalExpression_0= ruleRelationalExpression ( () ( (lv_operator_2_0= ruleLogicalAndOperator ) ) ( (lv_right_3_0= ruleRelationalExpression ) ) )* + // InternalBehaviorAnnexParser.g:3247:2: (kw= And (kw= Then )? ) + // InternalBehaviorAnnexParser.g:3248:3: kw= And (kw= Then )? { + kw=(Token)match(input,And,FollowSets000.FOLLOW_64); if (state.failed) return current; if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getLogicalAndExpressionAccess().getRelationalExpressionParserRuleCall_0()); + current.merge(kw); + newLeafNode(kw, grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); } - pushFollow(FollowSets000.FOLLOW_37); - this_RelationalExpression_0=ruleRelationalExpression(); - - state._fsp--; - if (state.failed) return current; - if ( state.backtracking==0 ) { + // InternalBehaviorAnnexParser.g:3253:3: (kw= Then )? + int alt61=2; + int LA61_0 = input.LA(1); - current = this_RelationalExpression_0; - afterParserOrEnumRuleCall(); - + if ( (LA61_0==Then) ) { + alt61=1; } - // InternalBehaviorAnnexParser.g:3241:3: ( () ( (lv_operator_2_0= ruleLogicalAndOperator ) ) ( (lv_right_3_0= ruleRelationalExpression ) ) )* - loop60: - do { - int alt60=2; - int LA60_0 = input.LA(1); + switch (alt61) { + case 1 : + // InternalBehaviorAnnexParser.g:3254:4: kw= Then + { + kw=(Token)match(input,Then,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { - if ( (LA60_0==And) ) { - alt60=1; - } + current.merge(kw); + newLeafNode(kw, grammarAccess.getLogicalAndOperatorAccess().getThenKeyword_1()); + + } + } + break; - switch (alt60) { - case 1 : - // InternalBehaviorAnnexParser.g:3242:4: () ( (lv_operator_2_0= ruleLogicalAndOperator ) ) ( (lv_right_3_0= ruleRelationalExpression ) ) - { - // InternalBehaviorAnnexParser.g:3242:4: () - // InternalBehaviorAnnexParser.g:3243:5: - { - if ( state.backtracking==0 ) { + } - current = forceCreateModelElementAndSet( - grammarAccess.getLogicalAndExpressionAccess().getBinaryExpressionLeftAction_1_0(), - current); - - } - } + } - // InternalBehaviorAnnexParser.g:3249:4: ( (lv_operator_2_0= ruleLogicalAndOperator ) ) - // InternalBehaviorAnnexParser.g:3250:5: (lv_operator_2_0= ruleLogicalAndOperator ) - { - // InternalBehaviorAnnexParser.g:3250:5: (lv_operator_2_0= ruleLogicalAndOperator ) - // InternalBehaviorAnnexParser.g:3251:6: lv_operator_2_0= ruleLogicalAndOperator - { - if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getLogicalAndExpressionAccess().getOperatorLogicalAndOperatorParserRuleCall_1_1_0()); - - } - pushFollow(FollowSets000.FOLLOW_50); - lv_operator_2_0=ruleLogicalAndOperator(); - - state._fsp--; - if (state.failed) return current; - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElementForParent(grammarAccess.getLogicalAndExpressionRule()); - } - set( - current, - "operator", - lv_operator_2_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalAndOperator"); - afterParserOrEnumRuleCall(); - - } - - } - - - } - - // InternalBehaviorAnnexParser.g:3268:4: ( (lv_right_3_0= ruleRelationalExpression ) ) - // InternalBehaviorAnnexParser.g:3269:5: (lv_right_3_0= ruleRelationalExpression ) - { - // InternalBehaviorAnnexParser.g:3269:5: (lv_right_3_0= ruleRelationalExpression ) - // InternalBehaviorAnnexParser.g:3270:6: lv_right_3_0= ruleRelationalExpression - { - if ( state.backtracking==0 ) { - - newCompositeNode(grammarAccess.getLogicalAndExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); - - } - pushFollow(FollowSets000.FOLLOW_37); - lv_right_3_0=ruleRelationalExpression(); - - state._fsp--; - if (state.failed) return current; - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElementForParent(grammarAccess.getLogicalAndExpressionRule()); - } - set( - current, - "right", - lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.RelationalExpression"); - afterParserOrEnumRuleCall(); - - } - - } - - - } - - - } - break; - - default : - break loop60; - } - } while (true); - - - } - - - } + } if ( state.backtracking==0 ) { @@ -9218,31 +9180,31 @@ public final EObject ruleLogicalAndExpression() throws RecognitionException { } return current; } - // $ANTLR end "ruleLogicalAndExpression" + // $ANTLR end "ruleLogicalAndOperator" - // $ANTLR start "entryRuleLogicalAndOperator" - // InternalBehaviorAnnexParser.g:3292:1: entryRuleLogicalAndOperator returns [String current=null] : iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF ; - public final String entryRuleLogicalAndOperator() throws RecognitionException { - String current = null; + // $ANTLR start "entryRuleRelation" + // InternalBehaviorAnnexParser.g:3264:1: entryRuleRelation returns [EObject current=null] : iv_ruleRelation= ruleRelation EOF ; + public final EObject entryRuleRelation() throws RecognitionException { + EObject current = null; - AntlrDatatypeRuleToken iv_ruleLogicalAndOperator = null; + EObject iv_ruleRelation = null; try { - // InternalBehaviorAnnexParser.g:3292:58: (iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF ) - // InternalBehaviorAnnexParser.g:3293:2: iv_ruleLogicalAndOperator= ruleLogicalAndOperator EOF + // InternalBehaviorAnnexParser.g:3264:49: (iv_ruleRelation= ruleRelation EOF ) + // InternalBehaviorAnnexParser.g:3265:2: iv_ruleRelation= ruleRelation EOF { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getLogicalAndOperatorRule()); + newCompositeNode(grammarAccess.getRelationRule()); } pushFollow(FollowSets000.FOLLOW_1); - iv_ruleLogicalAndOperator=ruleLogicalAndOperator(); + iv_ruleRelation=ruleRelation(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { - current =iv_ruleLogicalAndOperator.getText(); + current =iv_ruleRelation; } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; @@ -9258,52 +9220,142 @@ public final String entryRuleLogicalAndOperator() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleLogicalAndOperator" + // $ANTLR end "entryRuleRelation" - // $ANTLR start "ruleLogicalAndOperator" - // InternalBehaviorAnnexParser.g:3299:1: ruleLogicalAndOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= And (kw= Then )? ) ; - public final AntlrDatatypeRuleToken ruleLogicalAndOperator() throws RecognitionException { - AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + // $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 ) ) )? ) ; + public final EObject ruleRelation() throws RecognitionException { + EObject current = null; + + EObject this_SimpleExpression_0 = null; + + AntlrDatatypeRuleToken lv_operator_2_0 = null; + + EObject lv_right_3_0 = null; - Token kw=null; enterRule(); try { - // InternalBehaviorAnnexParser.g:3305:2: ( (kw= And (kw= Then )? ) ) - // InternalBehaviorAnnexParser.g:3306:2: (kw= And (kw= Then )? ) + // 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:3306:2: (kw= And (kw= Then )? ) - // InternalBehaviorAnnexParser.g:3307:3: kw= And (kw= Then )? + // 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 ) ) )? { - kw=(Token)match(input,And,FollowSets000.FOLLOW_63); if (state.failed) return current; if ( state.backtracking==0 ) { - current.merge(kw); - newLeafNode(kw, grammarAccess.getLogicalAndOperatorAccess().getAndKeyword_0()); + newCompositeNode(grammarAccess.getRelationAccess().getSimpleExpressionParserRuleCall_0()); } - // InternalBehaviorAnnexParser.g:3312:3: (kw= Then )? - int alt61=2; - int LA61_0 = input.LA(1); + pushFollow(FollowSets000.FOLLOW_65); + this_SimpleExpression_0=ruleSimpleExpression(); - if ( (LA61_0==Then) ) { - alt61=1; + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_SimpleExpression_0; + afterParserOrEnumRuleCall(); + } - switch (alt61) { + // InternalBehaviorAnnexParser.g:3287:3: ( () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) )? + int alt62=2; + int LA62_0 = input.LA(1); + + if ( (LA62_0==ExclamationMarkEqualsSign||LA62_0==LessThanSignEqualsSign||LA62_0==GreaterThanSignEqualsSign||(LA62_0>=LessThanSign && LA62_0<=GreaterThanSign)) ) { + alt62=1; + } + switch (alt62) { case 1 : - // InternalBehaviorAnnexParser.g:3313:4: kw= Then + // InternalBehaviorAnnexParser.g:3288:4: () ( (lv_operator_2_0= ruleRelationalOperator ) ) ( (lv_right_3_0= ruleSimpleExpression ) ) + { + // InternalBehaviorAnnexParser.g:3288:4: () + // InternalBehaviorAnnexParser.g:3289:5: { - kw=(Token)match(input,Then,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { - current.merge(kw); - newLeafNode(kw, grammarAccess.getLogicalAndOperatorAccess().getThenKeyword_1()); - + current = forceCreateModelElementAndSet( + grammarAccess.getRelationAccess().getBinaryExpressionLeftAction_1_0(), + current); + + } + + } + + // InternalBehaviorAnnexParser.g:3295:4: ( (lv_operator_2_0= ruleRelationalOperator ) ) + // InternalBehaviorAnnexParser.g:3296:5: (lv_operator_2_0= ruleRelationalOperator ) + { + // InternalBehaviorAnnexParser.g:3296:5: (lv_operator_2_0= ruleRelationalOperator ) + // InternalBehaviorAnnexParser.g:3297:6: lv_operator_2_0= ruleRelationalOperator + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getRelationAccess().getOperatorRelationalOperatorParserRuleCall_1_1_0()); + + } + pushFollow(FollowSets000.FOLLOW_50); + lv_operator_2_0=ruleRelationalOperator(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getRelationRule()); + } + set( + current, + "operator", + lv_operator_2_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.RelationalOperator"); + afterParserOrEnumRuleCall(); + + } + } + + } + + // InternalBehaviorAnnexParser.g:3314:4: ( (lv_right_3_0= ruleSimpleExpression ) ) + // InternalBehaviorAnnexParser.g:3315:5: (lv_right_3_0= ruleSimpleExpression ) + { + // InternalBehaviorAnnexParser.g:3315:5: (lv_right_3_0= ruleSimpleExpression ) + // InternalBehaviorAnnexParser.g:3316:6: lv_right_3_0= ruleSimpleExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getRelationAccess().getRightSimpleExpressionParserRuleCall_1_2_0()); + + } + pushFollow(FollowSets000.FOLLOW_2); + lv_right_3_0=ruleSimpleExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getRelationRule()); + } + set( + current, + "right", + lv_right_3_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.SimpleExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + } break; @@ -9330,31 +9382,31 @@ public final AntlrDatatypeRuleToken ruleLogicalAndOperator() throws RecognitionE } return current; } - // $ANTLR end "ruleLogicalAndOperator" + // $ANTLR end "ruleRelation" - // $ANTLR start "entryRuleRelationalExpression" - // InternalBehaviorAnnexParser.g:3323:1: entryRuleRelationalExpression returns [EObject current=null] : iv_ruleRelationalExpression= ruleRelationalExpression EOF ; - public final EObject entryRuleRelationalExpression() throws RecognitionException { - EObject current = null; + // $ANTLR start "entryRuleRelationalOperator" + // InternalBehaviorAnnexParser.g:3338:1: entryRuleRelationalOperator returns [String current=null] : iv_ruleRelationalOperator= ruleRelationalOperator EOF ; + public final String entryRuleRelationalOperator() throws RecognitionException { + String current = null; - EObject iv_ruleRelationalExpression = null; + AntlrDatatypeRuleToken iv_ruleRelationalOperator = null; try { - // InternalBehaviorAnnexParser.g:3323:61: (iv_ruleRelationalExpression= ruleRelationalExpression EOF ) - // InternalBehaviorAnnexParser.g:3324:2: iv_ruleRelationalExpression= ruleRelationalExpression EOF + // InternalBehaviorAnnexParser.g:3338:58: (iv_ruleRelationalOperator= ruleRelationalOperator EOF ) + // InternalBehaviorAnnexParser.g:3339:2: iv_ruleRelationalOperator= ruleRelationalOperator EOF { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getRelationalExpressionRule()); + newCompositeNode(grammarAccess.getRelationalOperatorRule()); } pushFollow(FollowSets000.FOLLOW_1); - iv_ruleRelationalExpression=ruleRelationalExpression(); + iv_ruleRelationalOperator=ruleRelationalOperator(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { - current =iv_ruleRelationalExpression; + current =iv_ruleRelationalOperator.getText(); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; @@ -9370,297 +9422,147 @@ public final EObject entryRuleRelationalExpression() throws RecognitionException } return current; } - // $ANTLR end "entryRuleRelationalExpression" - - - // $ANTLR start "ruleRelationalExpression" - // InternalBehaviorAnnexParser.g:3330:1: ruleRelationalExpression returns [EObject current=null] : (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( ( (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ; - public final EObject ruleRelationalExpression() throws RecognitionException { - EObject current = null; + // $ANTLR end "entryRuleRelationalOperator" - Token lv_operator_2_1=null; - Token lv_operator_2_2=null; - Token lv_operator_2_3=null; - Token lv_operator_2_4=null; - Token lv_operator_2_5=null; - Token lv_operator_2_6=null; - EObject this_AdditiveExpression_0 = null; - EObject lv_right_3_0 = null; + // $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 ) ; + public final AntlrDatatypeRuleToken ruleRelationalOperator() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + Token kw=null; enterRule(); try { - // InternalBehaviorAnnexParser.g:3336:2: ( (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( ( (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ) - // InternalBehaviorAnnexParser.g:3337:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( ( (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) + // 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:3337:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( ( (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) - // InternalBehaviorAnnexParser.g:3338:3: this_AdditiveExpression_0= ruleAdditiveExpression ( () ( ( (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? - { - if ( state.backtracking==0 ) { - - newCompositeNode(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); - - } - pushFollow(FollowSets000.FOLLOW_64); - this_AdditiveExpression_0=ruleAdditiveExpression(); - - state._fsp--; - if (state.failed) return current; - if ( state.backtracking==0 ) { + // InternalBehaviorAnnexParser.g:3352:2: (kw= EqualsSign | kw= ExclamationMarkEqualsSign | kw= LessThanSign | kw= LessThanSignEqualsSign | kw= GreaterThanSign | kw= GreaterThanSignEqualsSign ) + int alt63=6; + switch ( input.LA(1) ) { + case EqualsSign: + { + alt63=1; + } + break; + case ExclamationMarkEqualsSign: + { + alt63=2; + } + break; + case LessThanSign: + { + alt63=3; + } + break; + case LessThanSignEqualsSign: + { + alt63=4; + } + break; + case GreaterThanSign: + { + alt63=5; + } + break; + case GreaterThanSignEqualsSign: + { + alt63=6; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 63, 0, input); - current = this_AdditiveExpression_0; - afterParserOrEnumRuleCall(); - + throw nvae; } - // InternalBehaviorAnnexParser.g:3346:3: ( () ( ( (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? - int alt63=2; - int LA63_0 = input.LA(1); - if ( (LA63_0==ExclamationMarkEqualsSign||LA63_0==LessThanSignEqualsSign||LA63_0==GreaterThanSignEqualsSign||(LA63_0>=LessThanSign && LA63_0<=GreaterThanSign)) ) { - alt63=1; - } switch (alt63) { case 1 : - // InternalBehaviorAnnexParser.g:3347:4: () ( ( (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) - { - // InternalBehaviorAnnexParser.g:3347:4: () - // InternalBehaviorAnnexParser.g:3348:5: + // InternalBehaviorAnnexParser.g:3353:3: kw= EqualsSign { + kw=(Token)match(input,EqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { - current = forceCreateModelElementAndSet( - grammarAccess.getRelationalExpressionAccess().getBinaryExpressionLeftAction_1_0(), - current); - + current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getEqualsSignKeyword_0()); + } } - - // InternalBehaviorAnnexParser.g:3354:4: ( ( (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) ) ) - // InternalBehaviorAnnexParser.g:3355:5: ( (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) ) - { - // InternalBehaviorAnnexParser.g:3355:5: ( (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) ) - // InternalBehaviorAnnexParser.g:3356:6: (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) + break; + case 2 : + // InternalBehaviorAnnexParser.g:3359:3: kw= ExclamationMarkEqualsSign { - // InternalBehaviorAnnexParser.g:3356:6: (lv_operator_2_1= EqualsSign | lv_operator_2_2= ExclamationMarkEqualsSign | lv_operator_2_3= LessThanSign | lv_operator_2_4= LessThanSignEqualsSign | lv_operator_2_5= GreaterThanSign | lv_operator_2_6= GreaterThanSignEqualsSign ) - int alt62=6; - switch ( input.LA(1) ) { - case EqualsSign: - { - alt62=1; - } - break; - case ExclamationMarkEqualsSign: - { - alt62=2; - } - break; - case LessThanSign: - { - alt62=3; - } - break; - case LessThanSignEqualsSign: - { - alt62=4; - } - break; - case GreaterThanSign: - { - alt62=5; - } - break; - case GreaterThanSignEqualsSign: - { - alt62=6; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return current;} - NoViableAltException nvae = - new NoViableAltException("", 62, 0, input); + kw=(Token)match(input,ExclamationMarkEqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { - throw nvae; + current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getExclamationMarkEqualsSignKeyword_1()); + } - switch (alt62) { - case 1 : - // InternalBehaviorAnnexParser.g:3357:7: lv_operator_2_1= EqualsSign - { - lv_operator_2_1=(Token)match(input,EqualsSign,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_1, grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignKeyword_1_1_0_0()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getRelationalExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_1, null); - - } - - } - break; - case 2 : - // InternalBehaviorAnnexParser.g:3368:7: lv_operator_2_2= ExclamationMarkEqualsSign - { - lv_operator_2_2=(Token)match(input,ExclamationMarkEqualsSign,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_2, grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getRelationalExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_2, null); - - } - - } - break; - case 3 : - // InternalBehaviorAnnexParser.g:3379:7: lv_operator_2_3= LessThanSign - { - lv_operator_2_3=(Token)match(input,LessThanSign,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_3, grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_2()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getRelationalExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_3, null); - - } - - } - break; - case 4 : - // InternalBehaviorAnnexParser.g:3390:7: lv_operator_2_4= LessThanSignEqualsSign - { - lv_operator_2_4=(Token)match(input,LessThanSignEqualsSign,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_4, grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getRelationalExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_4, null); - - } - - } - break; - case 5 : - // InternalBehaviorAnnexParser.g:3401:7: lv_operator_2_5= GreaterThanSign - { - lv_operator_2_5=(Token)match(input,GreaterThanSign,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_5, grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getRelationalExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_5, null); - - } - - } - break; - case 6 : - // InternalBehaviorAnnexParser.g:3412:7: lv_operator_2_6= GreaterThanSignEqualsSign - { - lv_operator_2_6=(Token)match(input,GreaterThanSignEqualsSign,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_6, grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_5()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getRelationalExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_6, null); - - } - - } - break; - - } + } + break; + case 3 : + // InternalBehaviorAnnexParser.g:3365:3: kw= LessThanSign + { + kw=(Token)match(input,LessThanSign,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getLessThanSignKeyword_2()); + + } } - - - } - - // InternalBehaviorAnnexParser.g:3425:4: ( (lv_right_3_0= ruleAdditiveExpression ) ) - // InternalBehaviorAnnexParser.g:3426:5: (lv_right_3_0= ruleAdditiveExpression ) - { - // InternalBehaviorAnnexParser.g:3426:5: (lv_right_3_0= ruleAdditiveExpression ) - // InternalBehaviorAnnexParser.g:3427:6: lv_right_3_0= ruleAdditiveExpression + break; + case 4 : + // InternalBehaviorAnnexParser.g:3371:3: kw= LessThanSignEqualsSign { + kw=(Token)match(input,LessThanSignEqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); - + current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getLessThanSignEqualsSignKeyword_3()); + } - pushFollow(FollowSets000.FOLLOW_2); - lv_right_3_0=ruleAdditiveExpression(); - state._fsp--; - if (state.failed) return current; + } + break; + case 5 : + // InternalBehaviorAnnexParser.g:3377:3: kw= GreaterThanSign + { + kw=(Token)match(input,GreaterThanSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { - if (current==null) { - current = createModelElementForParent(grammarAccess.getRelationalExpressionRule()); - } - set( - current, - "right", - lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.AdditiveExpression"); - afterParserOrEnumRuleCall(); - + current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getGreaterThanSignKeyword_4()); + } } + break; + case 6 : + // InternalBehaviorAnnexParser.g:3383:3: kw= GreaterThanSignEqualsSign + { + kw=(Token)match(input,GreaterThanSignEqualsSign,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { - + current.merge(kw); + newLeafNode(kw, grammarAccess.getRelationalOperatorAccess().getGreaterThanSignEqualsSignKeyword_5()); + } - } break; } - } - - } if ( state.backtracking==0 ) { @@ -9678,31 +9580,31 @@ public final EObject ruleRelationalExpression() throws RecognitionException { } return current; } - // $ANTLR end "ruleRelationalExpression" + // $ANTLR end "ruleRelationalOperator" - // $ANTLR start "entryRuleAdditiveExpression" - // InternalBehaviorAnnexParser.g:3449:1: entryRuleAdditiveExpression returns [EObject current=null] : iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ; - public final EObject entryRuleAdditiveExpression() throws RecognitionException { + // $ANTLR start "entryRuleSimpleExpression" + // InternalBehaviorAnnexParser.g:3392:1: entryRuleSimpleExpression returns [EObject current=null] : iv_ruleSimpleExpression= ruleSimpleExpression EOF ; + public final EObject entryRuleSimpleExpression() throws RecognitionException { EObject current = null; - EObject iv_ruleAdditiveExpression = null; + EObject iv_ruleSimpleExpression = null; try { - // InternalBehaviorAnnexParser.g:3449:59: (iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ) - // InternalBehaviorAnnexParser.g:3450:2: iv_ruleAdditiveExpression= ruleAdditiveExpression EOF + // InternalBehaviorAnnexParser.g:3392:57: (iv_ruleSimpleExpression= ruleSimpleExpression EOF ) + // InternalBehaviorAnnexParser.g:3393:2: iv_ruleSimpleExpression= ruleSimpleExpression EOF { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getAdditiveExpressionRule()); + newCompositeNode(grammarAccess.getSimpleExpressionRule()); } pushFollow(FollowSets000.FOLLOW_1); - iv_ruleAdditiveExpression=ruleAdditiveExpression(); + iv_ruleSimpleExpression=ruleSimpleExpression(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { - current =iv_ruleAdditiveExpression; + current =iv_ruleSimpleExpression; } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; @@ -9718,48 +9620,174 @@ public final EObject entryRuleAdditiveExpression() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleAdditiveExpression" + // $ANTLR end "entryRuleSimpleExpression" - // $ANTLR start "ruleAdditiveExpression" - // InternalBehaviorAnnexParser.g:3456:1: ruleAdditiveExpression returns [EObject current=null] : (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( ( (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ; - public final EObject ruleAdditiveExpression() 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 ) ) )* ) ; + public final EObject ruleSimpleExpression() throws RecognitionException { EObject current = null; - Token lv_operator_2_1=null; - Token lv_operator_2_2=null; - EObject this_MultiplicativeExpression_0 = null; + AntlrDatatypeRuleToken lv_operator_1_0 = null; - EObject lv_right_3_0 = null; + EObject lv_operand_2_0 = null; + + EObject this_Term_3 = null; + + AntlrDatatypeRuleToken lv_operator_5_0 = null; + + EObject lv_right_6_0 = null; enterRule(); try { - // InternalBehaviorAnnexParser.g:3462:2: ( (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( ( (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ) - // InternalBehaviorAnnexParser.g:3463:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( ( (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) + // 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:3463:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( ( (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) - // InternalBehaviorAnnexParser.g:3464:3: this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( ( (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* + // 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 ) ) )* { - if ( state.backtracking==0 ) { + // 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); - newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); - + if ( (LA64_0==PlusSign||LA64_0==HyphenMinus) ) { + alt64=1; } - pushFollow(FollowSets000.FOLLOW_65); - this_MultiplicativeExpression_0=ruleMultiplicativeExpression(); + 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 (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 64, 0, input); - state._fsp--; - if (state.failed) return current; - if ( state.backtracking==0 ) { + throw nvae; + } + switch (alt64) { + case 1 : + // InternalBehaviorAnnexParser.g:3408: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:3409:5: () + // InternalBehaviorAnnexParser.g:3410:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getSimpleExpressionAccess().getUnaryExpressionAction_0_0_0(), + current); + + } + + } + + // InternalBehaviorAnnexParser.g:3416:5: ( (lv_operator_1_0= ruleUnaryAddingOperator ) ) + // InternalBehaviorAnnexParser.g:3417:6: (lv_operator_1_0= ruleUnaryAddingOperator ) + { + // InternalBehaviorAnnexParser.g:3417:6: (lv_operator_1_0= ruleUnaryAddingOperator ) + // InternalBehaviorAnnexParser.g:3418:7: lv_operator_1_0= ruleUnaryAddingOperator + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getSimpleExpressionAccess().getOperatorUnaryAddingOperatorParserRuleCall_0_0_1_0()); + + } + pushFollow(FollowSets000.FOLLOW_50); + lv_operator_1_0=ruleUnaryAddingOperator(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getSimpleExpressionRule()); + } + set( + current, + "operator", + lv_operator_1_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.UnaryAddingOperator"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalBehaviorAnnexParser.g:3435:5: ( (lv_operand_2_0= ruleTerm ) ) + // InternalBehaviorAnnexParser.g:3436:6: (lv_operand_2_0= ruleTerm ) + { + // InternalBehaviorAnnexParser.g:3436:6: (lv_operand_2_0= ruleTerm ) + // InternalBehaviorAnnexParser.g:3437:7: lv_operand_2_0= ruleTerm + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getSimpleExpressionAccess().getOperandTermParserRuleCall_0_0_2_0()); + + } + pushFollow(FollowSets000.FOLLOW_66); + lv_operand_2_0=ruleTerm(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getSimpleExpressionRule()); + } + set( + current, + "operand", + lv_operand_2_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Term"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalBehaviorAnnexParser.g:3456:4: this_Term_3= ruleTerm + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getSimpleExpressionAccess().getTermParserRuleCall_0_1()); + + } + pushFollow(FollowSets000.FOLLOW_66); + this_Term_3=ruleTerm(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_Term_3; + afterParserOrEnumRuleCall(); + + } + + } + break; - current = this_MultiplicativeExpression_0; - afterParserOrEnumRuleCall(); - } - // InternalBehaviorAnnexParser.g:3472:3: ( () ( ( (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* + + // InternalBehaviorAnnexParser.g:3465:3: ( () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) )* loop65: do { int alt65=2; @@ -9772,120 +9800,82 @@ public final EObject ruleAdditiveExpression() throws RecognitionException { switch (alt65) { case 1 : - // InternalBehaviorAnnexParser.g:3473:4: () ( ( (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) + // InternalBehaviorAnnexParser.g:3466:4: () ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) ( (lv_right_6_0= ruleTerm ) ) { - // InternalBehaviorAnnexParser.g:3473:4: () - // InternalBehaviorAnnexParser.g:3474:5: + // InternalBehaviorAnnexParser.g:3466:4: () + // InternalBehaviorAnnexParser.g:3467:5: { if ( state.backtracking==0 ) { current = forceCreateModelElementAndSet( - grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(), + grammarAccess.getSimpleExpressionAccess().getBinaryExpressionLeftAction_1_0(), current); } } - // InternalBehaviorAnnexParser.g:3480:4: ( ( (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) ) ) - // InternalBehaviorAnnexParser.g:3481:5: ( (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) ) + // InternalBehaviorAnnexParser.g:3473:4: ( (lv_operator_5_0= ruleBinaryAddingOperator ) ) + // InternalBehaviorAnnexParser.g:3474:5: (lv_operator_5_0= ruleBinaryAddingOperator ) { - // InternalBehaviorAnnexParser.g:3481:5: ( (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) ) - // InternalBehaviorAnnexParser.g:3482:6: (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) + // InternalBehaviorAnnexParser.g:3474:5: (lv_operator_5_0= ruleBinaryAddingOperator ) + // InternalBehaviorAnnexParser.g:3475:6: lv_operator_5_0= ruleBinaryAddingOperator { - // InternalBehaviorAnnexParser.g:3482:6: (lv_operator_2_1= PlusSign | lv_operator_2_2= HyphenMinus ) - int alt64=2; - int LA64_0 = input.LA(1); + if ( state.backtracking==0 ) { - if ( (LA64_0==PlusSign) ) { - alt64=1; - } - else if ( (LA64_0==HyphenMinus) ) { - alt64=2; + newCompositeNode(grammarAccess.getSimpleExpressionAccess().getOperatorBinaryAddingOperatorParserRuleCall_1_1_0()); + } - else { - if (state.backtracking>0) {state.failed=true; return current;} - NoViableAltException nvae = - new NoViableAltException("", 64, 0, input); + pushFollow(FollowSets000.FOLLOW_50); + lv_operator_5_0=ruleBinaryAddingOperator(); - throw nvae; - } - switch (alt64) { - case 1 : - // InternalBehaviorAnnexParser.g:3483:7: lv_operator_2_1= PlusSign - { - lv_operator_2_1=(Token)match(input,PlusSign,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_1, grammarAccess.getAdditiveExpressionAccess().getOperatorPlusSignKeyword_1_1_0_0()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getAdditiveExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_1, null); - - } - - } - break; - case 2 : - // InternalBehaviorAnnexParser.g:3494:7: lv_operator_2_2= HyphenMinus - { - lv_operator_2_2=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_2, grammarAccess.getAdditiveExpressionAccess().getOperatorHyphenMinusKeyword_1_1_0_1()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getAdditiveExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_2, null); - - } - - } - break; + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + if (current==null) { + current = createModelElementForParent(grammarAccess.getSimpleExpressionRule()); + } + set( + current, + "operator", + lv_operator_5_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.BinaryAddingOperator"); + afterParserOrEnumRuleCall(); + } - } } - // InternalBehaviorAnnexParser.g:3507:4: ( (lv_right_3_0= ruleMultiplicativeExpression ) ) - // InternalBehaviorAnnexParser.g:3508:5: (lv_right_3_0= ruleMultiplicativeExpression ) + // InternalBehaviorAnnexParser.g:3492:4: ( (lv_right_6_0= ruleTerm ) ) + // InternalBehaviorAnnexParser.g:3493:5: (lv_right_6_0= ruleTerm ) { - // InternalBehaviorAnnexParser.g:3508:5: (lv_right_3_0= ruleMultiplicativeExpression ) - // InternalBehaviorAnnexParser.g:3509:6: lv_right_3_0= ruleMultiplicativeExpression + // InternalBehaviorAnnexParser.g:3493:5: (lv_right_6_0= ruleTerm ) + // InternalBehaviorAnnexParser.g:3494:6: lv_right_6_0= ruleTerm { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); + newCompositeNode(grammarAccess.getSimpleExpressionAccess().getRightTermParserRuleCall_1_2_0()); } - pushFollow(FollowSets000.FOLLOW_65); - lv_right_3_0=ruleMultiplicativeExpression(); + pushFollow(FollowSets000.FOLLOW_66); + lv_right_6_0=ruleTerm(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { if (current==null) { - current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); + current = createModelElementForParent(grammarAccess.getSimpleExpressionRule()); } set( current, "right", - lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.MultiplicativeExpression"); + lv_right_6_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Term"); afterParserOrEnumRuleCall(); } @@ -9925,31 +9915,31 @@ else if ( (LA64_0==HyphenMinus) ) { } return current; } - // $ANTLR end "ruleAdditiveExpression" + // $ANTLR end "ruleSimpleExpression" - // $ANTLR start "entryRuleMultiplicativeExpression" - // InternalBehaviorAnnexParser.g:3531:1: entryRuleMultiplicativeExpression returns [EObject current=null] : iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ; - public final EObject entryRuleMultiplicativeExpression() throws RecognitionException { - EObject current = null; + // $ANTLR start "entryRuleUnaryAddingOperator" + // InternalBehaviorAnnexParser.g:3516:1: entryRuleUnaryAddingOperator returns [String current=null] : iv_ruleUnaryAddingOperator= ruleUnaryAddingOperator EOF ; + public final String entryRuleUnaryAddingOperator() throws RecognitionException { + String current = null; - EObject iv_ruleMultiplicativeExpression = null; + AntlrDatatypeRuleToken iv_ruleUnaryAddingOperator = null; try { - // InternalBehaviorAnnexParser.g:3531:65: (iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ) - // InternalBehaviorAnnexParser.g:3532:2: iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF + // InternalBehaviorAnnexParser.g:3516:59: (iv_ruleUnaryAddingOperator= ruleUnaryAddingOperator EOF ) + // InternalBehaviorAnnexParser.g:3517:2: iv_ruleUnaryAddingOperator= ruleUnaryAddingOperator EOF { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); + newCompositeNode(grammarAccess.getUnaryAddingOperatorRule()); } pushFollow(FollowSets000.FOLLOW_1); - iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression(); + iv_ruleUnaryAddingOperator=ruleUnaryAddingOperator(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { - current =iv_ruleMultiplicativeExpression; + current =iv_ruleUnaryAddingOperator.getText(); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; @@ -9965,230 +9955,380 @@ public final EObject entryRuleMultiplicativeExpression() throws RecognitionExcep } return current; } - // $ANTLR end "entryRuleMultiplicativeExpression" - + // $ANTLR end "entryRuleUnaryAddingOperator" - // $ANTLR start "ruleMultiplicativeExpression" - // InternalBehaviorAnnexParser.g:3538:1: ruleMultiplicativeExpression returns [EObject current=null] : (this_PowerExpression_0= rulePowerExpression ( () ( ( (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) ) ) ( (lv_right_3_0= rulePowerExpression ) ) )* ) ; - public final EObject ruleMultiplicativeExpression() throws RecognitionException { - EObject current = null; - - Token lv_operator_2_1=null; - Token lv_operator_2_2=null; - Token lv_operator_2_3=null; - Token lv_operator_2_4=null; - EObject this_PowerExpression_0 = null; - EObject lv_right_3_0 = null; + // $ANTLR start "ruleUnaryAddingOperator" + // InternalBehaviorAnnexParser.g:3523:1: ruleUnaryAddingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= HyphenMinus | kw= PlusSign ) ; + public final AntlrDatatypeRuleToken ruleUnaryAddingOperator() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + Token kw=null; enterRule(); try { - // InternalBehaviorAnnexParser.g:3544:2: ( (this_PowerExpression_0= rulePowerExpression ( () ( ( (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) ) ) ( (lv_right_3_0= rulePowerExpression ) ) )* ) ) - // InternalBehaviorAnnexParser.g:3545:2: (this_PowerExpression_0= rulePowerExpression ( () ( ( (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) ) ) ( (lv_right_3_0= rulePowerExpression ) ) )* ) - { - // InternalBehaviorAnnexParser.g:3545:2: (this_PowerExpression_0= rulePowerExpression ( () ( ( (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) ) ) ( (lv_right_3_0= rulePowerExpression ) ) )* ) - // InternalBehaviorAnnexParser.g:3546:3: this_PowerExpression_0= rulePowerExpression ( () ( ( (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) ) ) ( (lv_right_3_0= rulePowerExpression ) ) )* + // InternalBehaviorAnnexParser.g:3529:2: ( (kw= HyphenMinus | kw= PlusSign ) ) + // InternalBehaviorAnnexParser.g:3530:2: (kw= HyphenMinus | kw= PlusSign ) { - if ( state.backtracking==0 ) { + // InternalBehaviorAnnexParser.g:3530:2: (kw= HyphenMinus | kw= PlusSign ) + int alt66=2; + int LA66_0 = input.LA(1); - newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getPowerExpressionParserRuleCall_0()); - + if ( (LA66_0==HyphenMinus) ) { + alt66=1; } - pushFollow(FollowSets000.FOLLOW_66); - this_PowerExpression_0=rulePowerExpression(); + else if ( (LA66_0==PlusSign) ) { + alt66=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 66, 0, input); + + throw nvae; + } + switch (alt66) { + case 1 : + // InternalBehaviorAnnexParser.g:3531:3: kw= HyphenMinus + { + kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getUnaryAddingOperatorAccess().getHyphenMinusKeyword_0()); + + } + + } + break; + case 2 : + // InternalBehaviorAnnexParser.g:3537:3: kw= PlusSign + { + kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getUnaryAddingOperatorAccess().getPlusSignKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleUnaryAddingOperator" + + + // $ANTLR start "entryRuleBinaryAddingOperator" + // InternalBehaviorAnnexParser.g:3546:1: entryRuleBinaryAddingOperator returns [String current=null] : iv_ruleBinaryAddingOperator= ruleBinaryAddingOperator EOF ; + public final String entryRuleBinaryAddingOperator() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleBinaryAddingOperator = null; + + + try { + // InternalBehaviorAnnexParser.g:3546:60: (iv_ruleBinaryAddingOperator= ruleBinaryAddingOperator EOF ) + // InternalBehaviorAnnexParser.g:3547:2: iv_ruleBinaryAddingOperator= ruleBinaryAddingOperator EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getBinaryAddingOperatorRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + iv_ruleBinaryAddingOperator=ruleBinaryAddingOperator(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleBinaryAddingOperator.getText(); + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleBinaryAddingOperator" + + + // $ANTLR start "ruleBinaryAddingOperator" + // InternalBehaviorAnnexParser.g:3553:1: ruleBinaryAddingOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= PlusSign | kw= HyphenMinus ) ; + public final AntlrDatatypeRuleToken ruleBinaryAddingOperator() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalBehaviorAnnexParser.g:3559:2: ( (kw= PlusSign | kw= HyphenMinus ) ) + // InternalBehaviorAnnexParser.g:3560:2: (kw= PlusSign | kw= HyphenMinus ) + { + // InternalBehaviorAnnexParser.g:3560:2: (kw= PlusSign | kw= HyphenMinus ) + int alt67=2; + int LA67_0 = input.LA(1); + + if ( (LA67_0==PlusSign) ) { + alt67=1; + } + else if ( (LA67_0==HyphenMinus) ) { + alt67=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 67, 0, input); + + throw nvae; + } + switch (alt67) { + case 1 : + // InternalBehaviorAnnexParser.g:3561:3: kw= PlusSign + { + kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getBinaryAddingOperatorAccess().getPlusSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalBehaviorAnnexParser.g:3567:3: kw= HyphenMinus + { + kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getBinaryAddingOperatorAccess().getHyphenMinusKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleBinaryAddingOperator" + + + // $ANTLR start "entryRuleTerm" + // InternalBehaviorAnnexParser.g:3576:1: entryRuleTerm returns [EObject current=null] : iv_ruleTerm= ruleTerm EOF ; + public final EObject entryRuleTerm() throws RecognitionException { + EObject current = null; + + EObject iv_ruleTerm = null; + + + try { + // InternalBehaviorAnnexParser.g:3576:45: (iv_ruleTerm= ruleTerm EOF ) + // InternalBehaviorAnnexParser.g:3577:2: iv_ruleTerm= ruleTerm EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getTermRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + iv_ruleTerm=ruleTerm(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleTerm; + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleTerm" + + + // $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 ) ) )* ) ; + public final EObject ruleTerm() throws RecognitionException { + EObject current = null; + + EObject this_Factor_0 = null; + + AntlrDatatypeRuleToken lv_operator_2_0 = null; + + EObject lv_right_3_0 = null; + + + + 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: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 ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getTermAccess().getFactorParserRuleCall_0()); + + } + pushFollow(FollowSets000.FOLLOW_67); + this_Factor_0=ruleFactor(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { - current = this_PowerExpression_0; + current = this_Factor_0; afterParserOrEnumRuleCall(); } - // InternalBehaviorAnnexParser.g:3554:3: ( () ( ( (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) ) ) ( (lv_right_3_0= rulePowerExpression ) ) )* - loop67: + // InternalBehaviorAnnexParser.g:3599:3: ( () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) )* + loop68: do { - int alt67=2; - int LA67_0 = input.LA(1); + int alt68=2; + int LA68_0 = input.LA(1); - if ( (LA67_0==Mod||LA67_0==Rem||LA67_0==Asterisk||LA67_0==Solidus) ) { - alt67=1; + if ( (LA68_0==Mod||LA68_0==Rem||LA68_0==Asterisk||LA68_0==Solidus) ) { + alt68=1; } - switch (alt67) { + switch (alt68) { case 1 : - // InternalBehaviorAnnexParser.g:3555:4: () ( ( (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) ) ) ( (lv_right_3_0= rulePowerExpression ) ) + // InternalBehaviorAnnexParser.g:3600:4: () ( (lv_operator_2_0= ruleMultiplyingOperator ) ) ( (lv_right_3_0= ruleFactor ) ) { - // InternalBehaviorAnnexParser.g:3555:4: () - // InternalBehaviorAnnexParser.g:3556:5: + // InternalBehaviorAnnexParser.g:3600:4: () + // InternalBehaviorAnnexParser.g:3601:5: { if ( state.backtracking==0 ) { current = forceCreateModelElementAndSet( - grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(), + grammarAccess.getTermAccess().getBinaryExpressionLeftAction_1_0(), current); } } - // InternalBehaviorAnnexParser.g:3562:4: ( ( (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) ) ) - // InternalBehaviorAnnexParser.g:3563:5: ( (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) ) + // InternalBehaviorAnnexParser.g:3607:4: ( (lv_operator_2_0= ruleMultiplyingOperator ) ) + // InternalBehaviorAnnexParser.g:3608:5: (lv_operator_2_0= ruleMultiplyingOperator ) { - // InternalBehaviorAnnexParser.g:3563:5: ( (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) ) - // InternalBehaviorAnnexParser.g:3564:6: (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) + // InternalBehaviorAnnexParser.g:3608:5: (lv_operator_2_0= ruleMultiplyingOperator ) + // InternalBehaviorAnnexParser.g:3609:6: lv_operator_2_0= ruleMultiplyingOperator { - // InternalBehaviorAnnexParser.g:3564:6: (lv_operator_2_1= Asterisk | lv_operator_2_2= Solidus | lv_operator_2_3= Mod | lv_operator_2_4= Rem ) - int alt66=4; - switch ( input.LA(1) ) { - case Asterisk: - { - alt66=1; - } - break; - case Solidus: - { - alt66=2; - } - break; - case Mod: - { - alt66=3; - } - break; - case Rem: - { - alt66=4; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return current;} - NoViableAltException nvae = - new NoViableAltException("", 66, 0, input); - - throw nvae; + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getTermAccess().getOperatorMultiplyingOperatorParserRuleCall_1_1_0()); + } + pushFollow(FollowSets000.FOLLOW_50); + lv_operator_2_0=ruleMultiplyingOperator(); - switch (alt66) { - case 1 : - // InternalBehaviorAnnexParser.g:3565:7: lv_operator_2_1= Asterisk - { - lv_operator_2_1=(Token)match(input,Asterisk,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_1, grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskKeyword_1_1_0_0()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getMultiplicativeExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_1, null); - - } - - } - break; - case 2 : - // InternalBehaviorAnnexParser.g:3576:7: lv_operator_2_2= Solidus - { - lv_operator_2_2=(Token)match(input,Solidus,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_2, grammarAccess.getMultiplicativeExpressionAccess().getOperatorSolidusKeyword_1_1_0_1()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getMultiplicativeExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_2, null); - - } - - } - break; - case 3 : - // InternalBehaviorAnnexParser.g:3587:7: lv_operator_2_3= Mod - { - lv_operator_2_3=(Token)match(input,Mod,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_3, grammarAccess.getMultiplicativeExpressionAccess().getOperatorModKeyword_1_1_0_2()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getMultiplicativeExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_3, null); - - } - - } - break; - case 4 : - // InternalBehaviorAnnexParser.g:3598:7: lv_operator_2_4= Rem - { - lv_operator_2_4=(Token)match(input,Rem,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_2_4, grammarAccess.getMultiplicativeExpressionAccess().getOperatorRemKeyword_1_1_0_3()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getMultiplicativeExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_2_4, null); - - } - - } - break; + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + if (current==null) { + current = createModelElementForParent(grammarAccess.getTermRule()); + } + set( + current, + "operator", + lv_operator_2_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.MultiplyingOperator"); + afterParserOrEnumRuleCall(); + } - } } - // InternalBehaviorAnnexParser.g:3611:4: ( (lv_right_3_0= rulePowerExpression ) ) - // InternalBehaviorAnnexParser.g:3612:5: (lv_right_3_0= rulePowerExpression ) + // InternalBehaviorAnnexParser.g:3626:4: ( (lv_right_3_0= ruleFactor ) ) + // InternalBehaviorAnnexParser.g:3627:5: (lv_right_3_0= ruleFactor ) { - // InternalBehaviorAnnexParser.g:3612:5: (lv_right_3_0= rulePowerExpression ) - // InternalBehaviorAnnexParser.g:3613:6: lv_right_3_0= rulePowerExpression + // InternalBehaviorAnnexParser.g:3627:5: (lv_right_3_0= ruleFactor ) + // InternalBehaviorAnnexParser.g:3628:6: lv_right_3_0= ruleFactor { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); + newCompositeNode(grammarAccess.getTermAccess().getRightFactorParserRuleCall_1_2_0()); } - pushFollow(FollowSets000.FOLLOW_66); - lv_right_3_0=rulePowerExpression(); + pushFollow(FollowSets000.FOLLOW_67); + lv_right_3_0=ruleFactor(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { if (current==null) { - current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); + current = createModelElementForParent(grammarAccess.getTermRule()); } set( current, "right", lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.PowerExpression"); + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Factor"); afterParserOrEnumRuleCall(); } @@ -10203,7 +10343,7 @@ public final EObject ruleMultiplicativeExpression() throws RecognitionException break; default : - break loop67; + break loop68; } } while (true); @@ -10228,31 +10368,31 @@ public final EObject ruleMultiplicativeExpression() throws RecognitionException } return current; } - // $ANTLR end "ruleMultiplicativeExpression" + // $ANTLR end "ruleTerm" - // $ANTLR start "entryRulePowerExpression" - // InternalBehaviorAnnexParser.g:3635:1: entryRulePowerExpression returns [EObject current=null] : iv_rulePowerExpression= rulePowerExpression EOF ; - public final EObject entryRulePowerExpression() throws RecognitionException { - EObject current = null; + // $ANTLR start "entryRuleMultiplyingOperator" + // InternalBehaviorAnnexParser.g:3650:1: entryRuleMultiplyingOperator returns [String current=null] : iv_ruleMultiplyingOperator= ruleMultiplyingOperator EOF ; + public final String entryRuleMultiplyingOperator() throws RecognitionException { + String current = null; - EObject iv_rulePowerExpression = null; + AntlrDatatypeRuleToken iv_ruleMultiplyingOperator = null; try { - // InternalBehaviorAnnexParser.g:3635:56: (iv_rulePowerExpression= rulePowerExpression EOF ) - // InternalBehaviorAnnexParser.g:3636:2: iv_rulePowerExpression= rulePowerExpression EOF + // InternalBehaviorAnnexParser.g:3650:59: (iv_ruleMultiplyingOperator= ruleMultiplyingOperator EOF ) + // InternalBehaviorAnnexParser.g:3651:2: iv_ruleMultiplyingOperator= ruleMultiplyingOperator EOF { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getPowerExpressionRule()); + newCompositeNode(grammarAccess.getMultiplyingOperatorRule()); } pushFollow(FollowSets000.FOLLOW_1); - iv_rulePowerExpression=rulePowerExpression(); + iv_ruleMultiplyingOperator=ruleMultiplyingOperator(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { - current =iv_rulePowerExpression; + current =iv_ruleMultiplyingOperator.getText(); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; @@ -10268,88 +10408,386 @@ public final EObject entryRulePowerExpression() throws RecognitionException { } return current; } - // $ANTLR end "entryRulePowerExpression" - - - // $ANTLR start "rulePowerExpression" - // InternalBehaviorAnnexParser.g:3642:1: rulePowerExpression returns [EObject current=null] : (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_operator_2_0= AsteriskAsterisk ) ) ( (lv_right_3_0= rulePowerExpression ) ) )? ) ; - public final EObject rulePowerExpression() throws RecognitionException { - EObject current = null; + // $ANTLR end "entryRuleMultiplyingOperator" - Token lv_operator_2_0=null; - EObject this_UnaryExpression_0 = null; - EObject lv_right_3_0 = null; + // $ANTLR start "ruleMultiplyingOperator" + // InternalBehaviorAnnexParser.g:3657: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(); + Token kw=null; enterRule(); try { - // InternalBehaviorAnnexParser.g:3648:2: ( (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_operator_2_0= AsteriskAsterisk ) ) ( (lv_right_3_0= rulePowerExpression ) ) )? ) ) - // InternalBehaviorAnnexParser.g:3649:2: (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_operator_2_0= AsteriskAsterisk ) ) ( (lv_right_3_0= rulePowerExpression ) ) )? ) - { - // InternalBehaviorAnnexParser.g:3649:2: (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_operator_2_0= AsteriskAsterisk ) ) ( (lv_right_3_0= rulePowerExpression ) ) )? ) - // InternalBehaviorAnnexParser.g:3650:3: this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_operator_2_0= AsteriskAsterisk ) ) ( (lv_right_3_0= rulePowerExpression ) ) )? + // 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:3664:2: (kw= Asterisk | kw= Solidus | kw= Mod | kw= Rem ) + int alt69=4; + switch ( input.LA(1) ) { + case Asterisk: + { + alt69=1; + } + break; + case Solidus: + { + alt69=2; + } + break; + case Mod: + { + alt69=3; + } + break; + case Rem: + { + alt69=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 69, 0, input); + + throw nvae; + } + + switch (alt69) { + case 1 : + // InternalBehaviorAnnexParser.g:3665:3: kw= Asterisk + { + kw=(Token)match(input,Asterisk,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getMultiplyingOperatorAccess().getAsteriskKeyword_0()); + + } + + } + break; + case 2 : + // InternalBehaviorAnnexParser.g:3671:3: kw= Solidus + { + kw=(Token)match(input,Solidus,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getMultiplyingOperatorAccess().getSolidusKeyword_1()); + + } + + } + break; + case 3 : + // InternalBehaviorAnnexParser.g:3677:3: kw= Mod + { + kw=(Token)match(input,Mod,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getMultiplyingOperatorAccess().getModKeyword_2()); + + } + + } + break; + case 4 : + // InternalBehaviorAnnexParser.g:3683:3: kw= Rem + { + kw=(Token)match(input,Rem,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getMultiplyingOperatorAccess().getRemKeyword_3()); + + } + + } + break; + + } + + + } + if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getPowerExpressionAccess().getUnaryExpressionParserRuleCall_0()); - + leaveRule(); + } - pushFollow(FollowSets000.FOLLOW_67); - this_UnaryExpression_0=ruleUnaryExpression(); + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMultiplyingOperator" + + + // $ANTLR start "entryRuleFactor" + // InternalBehaviorAnnexParser.g:3692:1: entryRuleFactor returns [EObject current=null] : iv_ruleFactor= ruleFactor EOF ; + public final EObject entryRuleFactor() throws RecognitionException { + EObject current = null; + + EObject iv_ruleFactor = null; + + + try { + // InternalBehaviorAnnexParser.g:3692:47: (iv_ruleFactor= ruleFactor EOF ) + // InternalBehaviorAnnexParser.g:3693:2: iv_ruleFactor= ruleFactor EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getFactorRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + iv_ruleFactor=ruleFactor(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { + current =iv_ruleFactor; + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; - current = this_UnaryExpression_0; - afterParserOrEnumRuleCall(); - } - // InternalBehaviorAnnexParser.g:3658:3: ( () ( (lv_operator_2_0= AsteriskAsterisk ) ) ( (lv_right_3_0= rulePowerExpression ) ) )? - int alt68=2; - int LA68_0 = input.LA(1); - if ( (LA68_0==AsteriskAsterisk) ) { - alt68=1; + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleFactor" + + + // $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 ) ) ) ) ; + public final EObject ruleFactor() throws RecognitionException { + EObject current = null; + + EObject this_Value_0 = null; + + AntlrDatatypeRuleToken lv_operator_2_0 = null; + + EObject lv_right_3_0 = null; + + AntlrDatatypeRuleToken lv_operator_5_0 = null; + + EObject lv_operand_6_0 = null; + + + + 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: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); + + 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; + } + else if ( (LA71_0==Abs||LA71_0==Not) ) { + alt71=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 71, 0, input); + + throw nvae; } - switch (alt68) { + switch (alt71) { case 1 : - // InternalBehaviorAnnexParser.g:3659:4: () ( (lv_operator_2_0= AsteriskAsterisk ) ) ( (lv_right_3_0= rulePowerExpression ) ) + // InternalBehaviorAnnexParser.g:3707:3: (this_Value_0= ruleValue ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? ) { - // InternalBehaviorAnnexParser.g:3659:4: () - // InternalBehaviorAnnexParser.g:3660:5: + // 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 ) ) )? { if ( state.backtracking==0 ) { - current = forceCreateModelElementAndSet( - grammarAccess.getPowerExpressionAccess().getBinaryExpressionLeftAction_1_0(), + newCompositeNode(grammarAccess.getFactorAccess().getValueParserRuleCall_0_0()); + + } + pushFollow(FollowSets000.FOLLOW_68); + this_Value_0=ruleValue(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_Value_0; + afterParserOrEnumRuleCall(); + + } + // InternalBehaviorAnnexParser.g:3716:4: ( () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) )? + int alt70=2; + int LA70_0 = input.LA(1); + + if ( (LA70_0==AsteriskAsterisk) ) { + alt70=1; + } + switch (alt70) { + case 1 : + // InternalBehaviorAnnexParser.g:3717:5: () ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) ( (lv_right_3_0= ruleValue ) ) + { + // InternalBehaviorAnnexParser.g:3717:5: () + // InternalBehaviorAnnexParser.g:3718:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getFactorAccess().getBinaryExpressionLeftAction_0_1_0(), + current); + + } + + } + + // InternalBehaviorAnnexParser.g:3724:5: ( (lv_operator_2_0= ruleBinaryNumericOperator ) ) + // InternalBehaviorAnnexParser.g:3725:6: (lv_operator_2_0= ruleBinaryNumericOperator ) + { + // InternalBehaviorAnnexParser.g:3725:6: (lv_operator_2_0= ruleBinaryNumericOperator ) + // InternalBehaviorAnnexParser.g:3726:7: lv_operator_2_0= ruleBinaryNumericOperator + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFactorAccess().getOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0()); + + } + pushFollow(FollowSets000.FOLLOW_69); + lv_operator_2_0=ruleBinaryNumericOperator(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFactorRule()); + } + set( + current, + "operator", + lv_operator_2_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.BinaryNumericOperator"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalBehaviorAnnexParser.g:3743:5: ( (lv_right_3_0= ruleValue ) ) + // InternalBehaviorAnnexParser.g:3744:6: (lv_right_3_0= ruleValue ) + { + // InternalBehaviorAnnexParser.g:3744:6: (lv_right_3_0= ruleValue ) + // InternalBehaviorAnnexParser.g:3745:7: lv_right_3_0= ruleValue + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFactorAccess().getRightValueParserRuleCall_0_1_2_0()); + + } + pushFollow(FollowSets000.FOLLOW_2); + lv_right_3_0=ruleValue(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFactorRule()); + } + set( + current, + "right", + lv_right_3_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Value"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + case 2 : + // InternalBehaviorAnnexParser.g:3765: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:3766:4: () + // InternalBehaviorAnnexParser.g:3767:5: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getFactorAccess().getUnaryExpressionAction_1_0(), current); } } - // InternalBehaviorAnnexParser.g:3666:4: ( (lv_operator_2_0= AsteriskAsterisk ) ) - // InternalBehaviorAnnexParser.g:3667:5: (lv_operator_2_0= AsteriskAsterisk ) + // InternalBehaviorAnnexParser.g:3773:4: ( (lv_operator_5_0= ruleUnaryValueOperator ) ) + // InternalBehaviorAnnexParser.g:3774:5: (lv_operator_5_0= ruleUnaryValueOperator ) { - // InternalBehaviorAnnexParser.g:3667:5: (lv_operator_2_0= AsteriskAsterisk ) - // InternalBehaviorAnnexParser.g:3668:6: lv_operator_2_0= AsteriskAsterisk + // InternalBehaviorAnnexParser.g:3774:5: (lv_operator_5_0= ruleUnaryValueOperator ) + // InternalBehaviorAnnexParser.g:3775:6: lv_operator_5_0= ruleUnaryValueOperator { - lv_operator_2_0=(Token)match(input,AsteriskAsterisk,FollowSets000.FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { - newLeafNode(lv_operator_2_0, grammarAccess.getPowerExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_0()); + newCompositeNode(grammarAccess.getFactorAccess().getOperatorUnaryValueOperatorParserRuleCall_1_1_0()); } + pushFollow(FollowSets000.FOLLOW_69); + lv_operator_5_0=ruleUnaryValueOperator(); + + state._fsp--; + if (state.failed) return current; if ( state.backtracking==0 ) { if (current==null) { - current = createModelElement(grammarAccess.getPowerExpressionRule()); + current = createModelElementForParent(grammarAccess.getFactorRule()); } - setWithLastConsumed(current, "operator", lv_operator_2_0, "**"); + set( + current, + "operator", + lv_operator_5_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.UnaryValueOperator"); + afterParserOrEnumRuleCall(); } @@ -10358,32 +10796,32 @@ public final EObject rulePowerExpression() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:3680:4: ( (lv_right_3_0= rulePowerExpression ) ) - // InternalBehaviorAnnexParser.g:3681:5: (lv_right_3_0= rulePowerExpression ) + // InternalBehaviorAnnexParser.g:3792:4: ( (lv_operand_6_0= ruleValue ) ) + // InternalBehaviorAnnexParser.g:3793:5: (lv_operand_6_0= ruleValue ) { - // InternalBehaviorAnnexParser.g:3681:5: (lv_right_3_0= rulePowerExpression ) - // InternalBehaviorAnnexParser.g:3682:6: lv_right_3_0= rulePowerExpression + // InternalBehaviorAnnexParser.g:3793:5: (lv_operand_6_0= ruleValue ) + // InternalBehaviorAnnexParser.g:3794:6: lv_operand_6_0= ruleValue { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getPowerExpressionAccess().getRightPowerExpressionParserRuleCall_1_2_0()); + newCompositeNode(grammarAccess.getFactorAccess().getOperandValueParserRuleCall_1_2_0()); } pushFollow(FollowSets000.FOLLOW_2); - lv_right_3_0=rulePowerExpression(); + lv_operand_6_0=ruleValue(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { if (current==null) { - current = createModelElementForParent(grammarAccess.getPowerExpressionRule()); + current = createModelElementForParent(grammarAccess.getFactorRule()); } set( current, - "right", - lv_right_3_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.PowerExpression"); + "operand", + lv_operand_6_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.Value"); afterParserOrEnumRuleCall(); } @@ -10394,15 +10832,97 @@ public final EObject rulePowerExpression() throws RecognitionException { } - } - break; + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleFactor" + + + // $ANTLR start "entryRuleBinaryNumericOperator" + // InternalBehaviorAnnexParser.g:3816:1: entryRuleBinaryNumericOperator returns [String current=null] : iv_ruleBinaryNumericOperator= ruleBinaryNumericOperator EOF ; + public final String entryRuleBinaryNumericOperator() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleBinaryNumericOperator = null; + + + try { + // InternalBehaviorAnnexParser.g:3816:61: (iv_ruleBinaryNumericOperator= ruleBinaryNumericOperator EOF ) + // InternalBehaviorAnnexParser.g:3817:2: iv_ruleBinaryNumericOperator= ruleBinaryNumericOperator EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getBinaryNumericOperatorRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + iv_ruleBinaryNumericOperator=ruleBinaryNumericOperator(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleBinaryNumericOperator.getText(); + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleBinaryNumericOperator" + + + // $ANTLR start "ruleBinaryNumericOperator" + // InternalBehaviorAnnexParser.g:3823:1: ruleBinaryNumericOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= AsteriskAsterisk ; + public final AntlrDatatypeRuleToken ruleBinaryNumericOperator() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + - } + enterRule(); + try { + // InternalBehaviorAnnexParser.g:3829:2: (kw= AsteriskAsterisk ) + // InternalBehaviorAnnexParser.g:3830:2: kw= AsteriskAsterisk + { + kw=(Token)match(input,AsteriskAsterisk,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + current.merge(kw); + newLeafNode(kw, grammarAccess.getBinaryNumericOperatorAccess().getAsteriskAsteriskKeyword()); + } - } if ( state.backtracking==0 ) { @@ -10420,31 +10940,31 @@ public final EObject rulePowerExpression() throws RecognitionException { } return current; } - // $ANTLR end "rulePowerExpression" + // $ANTLR end "ruleBinaryNumericOperator" - // $ANTLR start "entryRuleUnaryExpression" - // InternalBehaviorAnnexParser.g:3704:1: entryRuleUnaryExpression returns [EObject current=null] : iv_ruleUnaryExpression= ruleUnaryExpression EOF ; - public final EObject entryRuleUnaryExpression() throws RecognitionException { - EObject current = null; + // $ANTLR start "entryRuleUnaryValueOperator" + // InternalBehaviorAnnexParser.g:3838:1: entryRuleUnaryValueOperator returns [String current=null] : iv_ruleUnaryValueOperator= ruleUnaryValueOperator EOF ; + public final String entryRuleUnaryValueOperator() throws RecognitionException { + String current = null; - EObject iv_ruleUnaryExpression = null; + AntlrDatatypeRuleToken iv_ruleUnaryValueOperator = null; try { - // InternalBehaviorAnnexParser.g:3704:56: (iv_ruleUnaryExpression= ruleUnaryExpression EOF ) - // InternalBehaviorAnnexParser.g:3705:2: iv_ruleUnaryExpression= ruleUnaryExpression EOF + // InternalBehaviorAnnexParser.g:3838:58: (iv_ruleUnaryValueOperator= ruleUnaryValueOperator EOF ) + // InternalBehaviorAnnexParser.g:3839:2: iv_ruleUnaryValueOperator= ruleUnaryValueOperator EOF { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getUnaryExpressionRule()); + newCompositeNode(grammarAccess.getUnaryValueOperatorRule()); } pushFollow(FollowSets000.FOLLOW_1); - iv_ruleUnaryExpression=ruleUnaryExpression(); + iv_ruleUnaryValueOperator=ruleUnaryValueOperator(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { - current =iv_ruleUnaryExpression; + current =iv_ruleUnaryValueOperator.getText(); } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; @@ -10460,252 +10980,62 @@ public final EObject entryRuleUnaryExpression() throws RecognitionException { } return current; } - // $ANTLR end "entryRuleUnaryExpression" - - - // $ANTLR start "ruleUnaryExpression" - // InternalBehaviorAnnexParser.g:3711:1: ruleUnaryExpression returns [EObject current=null] : ( ( () ( ( (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) ) ) ( (lv_operand_2_0= ruleUnaryExpression ) ) ) | this_PrimaryExpression_3= rulePrimaryExpression ) ; - public final EObject ruleUnaryExpression() throws RecognitionException { - EObject current = null; + // $ANTLR end "entryRuleUnaryValueOperator" - Token lv_operator_1_1=null; - Token lv_operator_1_2=null; - Token lv_operator_1_3=null; - Token lv_operator_1_4=null; - EObject lv_operand_2_0 = null; - EObject this_PrimaryExpression_3 = null; + // $ANTLR start "ruleUnaryValueOperator" + // InternalBehaviorAnnexParser.g:3845:1: ruleUnaryValueOperator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= Abs | kw= Not ) ; + public final AntlrDatatypeRuleToken ruleUnaryValueOperator() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + Token kw=null; enterRule(); try { - // InternalBehaviorAnnexParser.g:3717:2: ( ( ( () ( ( (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) ) ) ( (lv_operand_2_0= ruleUnaryExpression ) ) ) | this_PrimaryExpression_3= rulePrimaryExpression ) ) - // InternalBehaviorAnnexParser.g:3718:2: ( ( () ( ( (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) ) ) ( (lv_operand_2_0= ruleUnaryExpression ) ) ) | this_PrimaryExpression_3= rulePrimaryExpression ) + // InternalBehaviorAnnexParser.g:3851:2: ( (kw= Abs | kw= Not ) ) + // InternalBehaviorAnnexParser.g:3852:2: (kw= Abs | kw= Not ) { - // InternalBehaviorAnnexParser.g:3718:2: ( ( () ( ( (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) ) ) ( (lv_operand_2_0= ruleUnaryExpression ) ) ) | this_PrimaryExpression_3= rulePrimaryExpression ) - int alt70=2; - int LA70_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:3852:2: (kw= Abs | kw= Not ) + int alt72=2; + int LA72_0 = input.LA(1); - if ( (LA70_0==Abs||LA70_0==Not||LA70_0==PlusSign||LA70_0==HyphenMinus) ) { - alt70=1; + if ( (LA72_0==Abs) ) { + alt72=1; } - else if ( (LA70_0==False||LA70_0==True||LA70_0==NumberSign||LA70_0==LeftParenthesis||LA70_0==RULE_REAL_LIT||LA70_0==RULE_INTEGER_LIT||(LA70_0>=RULE_STRING && LA70_0<=RULE_ID)) ) { - alt70=2; + else if ( (LA72_0==Not) ) { + alt72=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 70, 0, input); + new NoViableAltException("", 72, 0, input); throw nvae; } - switch (alt70) { + switch (alt72) { case 1 : - // InternalBehaviorAnnexParser.g:3719:3: ( () ( ( (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) ) ) ( (lv_operand_2_0= ruleUnaryExpression ) ) ) - { - // InternalBehaviorAnnexParser.g:3719:3: ( () ( ( (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) ) ) ( (lv_operand_2_0= ruleUnaryExpression ) ) ) - // InternalBehaviorAnnexParser.g:3720:4: () ( ( (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) ) ) ( (lv_operand_2_0= ruleUnaryExpression ) ) - { - // InternalBehaviorAnnexParser.g:3720:4: () - // InternalBehaviorAnnexParser.g:3721:5: - { - if ( state.backtracking==0 ) { - - current = forceCreateModelElement( - grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_0_0(), - current); - - } - - } - - // InternalBehaviorAnnexParser.g:3727:4: ( ( (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) ) ) - // InternalBehaviorAnnexParser.g:3728:5: ( (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) ) - { - // InternalBehaviorAnnexParser.g:3728:5: ( (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) ) - // InternalBehaviorAnnexParser.g:3729:6: (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) - { - // InternalBehaviorAnnexParser.g:3729:6: (lv_operator_1_1= PlusSign | lv_operator_1_2= HyphenMinus | lv_operator_1_3= Abs | lv_operator_1_4= Not ) - int alt69=4; - switch ( input.LA(1) ) { - case PlusSign: - { - alt69=1; - } - break; - case HyphenMinus: - { - alt69=2; - } - break; - case Abs: - { - alt69=3; - } - break; - case Not: - { - alt69=4; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return current;} - NoViableAltException nvae = - new NoViableAltException("", 69, 0, input); - - throw nvae; - } - - switch (alt69) { - case 1 : - // InternalBehaviorAnnexParser.g:3730:7: lv_operator_1_1= PlusSign - { - lv_operator_1_1=(Token)match(input,PlusSign,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_1_1, grammarAccess.getUnaryExpressionAccess().getOperatorPlusSignKeyword_0_1_0_0()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getUnaryExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_1_1, null); - - } - - } - break; - case 2 : - // InternalBehaviorAnnexParser.g:3741:7: lv_operator_1_2= HyphenMinus - { - lv_operator_1_2=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_1_2, grammarAccess.getUnaryExpressionAccess().getOperatorHyphenMinusKeyword_0_1_0_1()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getUnaryExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_1_2, null); - - } - - } - break; - case 3 : - // InternalBehaviorAnnexParser.g:3752:7: lv_operator_1_3= Abs - { - lv_operator_1_3=(Token)match(input,Abs,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_1_3, grammarAccess.getUnaryExpressionAccess().getOperatorAbsKeyword_0_1_0_2()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getUnaryExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_1_3, null); - - } - - } - break; - case 4 : - // InternalBehaviorAnnexParser.g:3763:7: lv_operator_1_4= Not - { - lv_operator_1_4=(Token)match(input,Not,FollowSets000.FOLLOW_50); if (state.failed) return current; - if ( state.backtracking==0 ) { - - newLeafNode(lv_operator_1_4, grammarAccess.getUnaryExpressionAccess().getOperatorNotKeyword_0_1_0_3()); - - } - if ( state.backtracking==0 ) { - - if (current==null) { - current = createModelElement(grammarAccess.getUnaryExpressionRule()); - } - setWithLastConsumed(current, "operator", lv_operator_1_4, null); - - } - - } - break; - - } - - - } - - - } - - // InternalBehaviorAnnexParser.g:3776:4: ( (lv_operand_2_0= ruleUnaryExpression ) ) - // InternalBehaviorAnnexParser.g:3777:5: (lv_operand_2_0= ruleUnaryExpression ) + // InternalBehaviorAnnexParser.g:3853:3: kw= Abs { - // InternalBehaviorAnnexParser.g:3777:5: (lv_operand_2_0= ruleUnaryExpression ) - // InternalBehaviorAnnexParser.g:3778:6: lv_operand_2_0= ruleUnaryExpression - { - if ( state.backtracking==0 ) { - - newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOperandUnaryExpressionParserRuleCall_0_2_0()); - - } - pushFollow(FollowSets000.FOLLOW_2); - lv_operand_2_0=ruleUnaryExpression(); - - state._fsp--; - if (state.failed) return current; + kw=(Token)match(input,Abs,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { - if (current==null) { - current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); - } - set( - current, - "operand", - lv_operand_2_0, - "org.osate.xtext.aadl2.ba.BehaviorAnnex.UnaryExpression"); - afterParserOrEnumRuleCall(); - - } - - } - - - } - - + current.merge(kw); + newLeafNode(kw, grammarAccess.getUnaryValueOperatorAccess().getAbsKeyword_0()); + } - } break; case 2 : - // InternalBehaviorAnnexParser.g:3797:3: this_PrimaryExpression_3= rulePrimaryExpression + // InternalBehaviorAnnexParser.g:3859:3: kw= Not { + kw=(Token)match(input,Not,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getUnaryExpressionAccess().getPrimaryExpressionParserRuleCall_1()); - - } - pushFollow(FollowSets000.FOLLOW_2); - this_PrimaryExpression_3=rulePrimaryExpression(); - - state._fsp--; - if (state.failed) return current; - if ( state.backtracking==0 ) { - - current = this_PrimaryExpression_3; - afterParserOrEnumRuleCall(); + current.merge(kw); + newLeafNode(kw, grammarAccess.getUnaryValueOperatorAccess().getNotKeyword_1()); } @@ -10732,31 +11062,31 @@ else if ( (LA70_0==False||LA70_0==True||LA70_0==NumberSign||LA70_0==LeftParenthe } return current; } - // $ANTLR end "ruleUnaryExpression" + // $ANTLR end "ruleUnaryValueOperator" - // $ANTLR start "entryRulePrimaryExpression" - // InternalBehaviorAnnexParser.g:3809:1: entryRulePrimaryExpression returns [EObject current=null] : iv_rulePrimaryExpression= rulePrimaryExpression EOF ; - public final EObject entryRulePrimaryExpression() throws RecognitionException { + // $ANTLR start "entryRuleValue" + // InternalBehaviorAnnexParser.g:3868:1: entryRuleValue returns [EObject current=null] : iv_ruleValue= ruleValue EOF ; + public final EObject entryRuleValue() throws RecognitionException { EObject current = null; - EObject iv_rulePrimaryExpression = null; + EObject iv_ruleValue = null; try { - // InternalBehaviorAnnexParser.g:3809:58: (iv_rulePrimaryExpression= rulePrimaryExpression EOF ) - // InternalBehaviorAnnexParser.g:3810:2: iv_rulePrimaryExpression= rulePrimaryExpression EOF + // InternalBehaviorAnnexParser.g:3868:46: (iv_ruleValue= ruleValue EOF ) + // InternalBehaviorAnnexParser.g:3869:2: iv_ruleValue= ruleValue EOF { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getPrimaryExpressionRule()); + newCompositeNode(grammarAccess.getValueRule()); } pushFollow(FollowSets000.FOLLOW_1); - iv_rulePrimaryExpression=rulePrimaryExpression(); + iv_ruleValue=ruleValue(); state._fsp--; if (state.failed) return current; if ( state.backtracking==0 ) { - current =iv_rulePrimaryExpression; + current =iv_ruleValue; } match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; @@ -10772,32 +11102,30 @@ public final EObject entryRulePrimaryExpression() throws RecognitionException { } return current; } - // $ANTLR end "entryRulePrimaryExpression" + // $ANTLR end "entryRuleValue" - // $ANTLR start "rulePrimaryExpression" - // InternalBehaviorAnnexParser.g:3816:1: rulePrimaryExpression returns [EObject current=null] : (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | (otherlv_2= LeftParenthesis this_ValueExpression_3= ruleValueExpression otherlv_4= RightParenthesis ) ) ; - public final EObject rulePrimaryExpression() 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 ) ; + public final EObject ruleValue() throws RecognitionException { EObject current = null; - Token otherlv_2=null; - Token otherlv_4=null; EObject this_ValueConstant_0 = null; EObject this_ReferenceExpression_1 = null; - EObject this_ValueExpression_3 = null; + EObject this_ParenthesizedExpression_2 = null; enterRule(); try { - // InternalBehaviorAnnexParser.g:3822:2: ( (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | (otherlv_2= LeftParenthesis this_ValueExpression_3= ruleValueExpression otherlv_4= RightParenthesis ) ) ) - // InternalBehaviorAnnexParser.g:3823:2: (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | (otherlv_2= LeftParenthesis this_ValueExpression_3= ruleValueExpression otherlv_4= RightParenthesis ) ) + // 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:3823:2: (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | (otherlv_2= LeftParenthesis this_ValueExpression_3= ruleValueExpression otherlv_4= RightParenthesis ) ) - int alt71=3; + // InternalBehaviorAnnexParser.g:3882:2: (this_ValueConstant_0= ruleValueConstant | this_ReferenceExpression_1= ruleReferenceExpression | this_ParenthesizedExpression_2= ruleParenthesizedExpression ) + int alt73=3; switch ( input.LA(1) ) { case False: case True: @@ -10806,34 +11134,34 @@ public final EObject rulePrimaryExpression() throws RecognitionException { case RULE_INTEGER_LIT: case RULE_STRING: { - alt71=1; + alt73=1; } break; case RULE_ID: { - alt71=2; + alt73=2; } break; case LeftParenthesis: { - alt71=3; + alt73=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 71, 0, input); + new NoViableAltException("", 73, 0, input); throw nvae; } - switch (alt71) { + switch (alt73) { case 1 : - // InternalBehaviorAnnexParser.g:3824:3: this_ValueConstant_0= ruleValueConstant + // InternalBehaviorAnnexParser.g:3883:3: this_ValueConstant_0= ruleValueConstant { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getValueConstantParserRuleCall_0()); + newCompositeNode(grammarAccess.getValueAccess().getValueConstantParserRuleCall_0()); } pushFollow(FollowSets000.FOLLOW_2); @@ -10851,11 +11179,11 @@ public final EObject rulePrimaryExpression() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:3833:3: this_ReferenceExpression_1= ruleReferenceExpression + // InternalBehaviorAnnexParser.g:3892:3: this_ReferenceExpression_1= ruleReferenceExpression { if ( state.backtracking==0 ) { - newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getReferenceExpressionParserRuleCall_1()); + newCompositeNode(grammarAccess.getValueAccess().getReferenceExpressionParserRuleCall_1()); } pushFollow(FollowSets000.FOLLOW_2); @@ -10873,45 +11201,158 @@ public final EObject rulePrimaryExpression() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:3842:3: (otherlv_2= LeftParenthesis this_ValueExpression_3= ruleValueExpression otherlv_4= RightParenthesis ) - { - // InternalBehaviorAnnexParser.g:3842:3: (otherlv_2= LeftParenthesis this_ValueExpression_3= ruleValueExpression otherlv_4= RightParenthesis ) - // InternalBehaviorAnnexParser.g:3843:4: otherlv_2= LeftParenthesis this_ValueExpression_3= ruleValueExpression otherlv_4= RightParenthesis + // InternalBehaviorAnnexParser.g:3901:3: this_ParenthesizedExpression_2= ruleParenthesizedExpression { - otherlv_2=(Token)match(input,LeftParenthesis,FollowSets000.FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { - newLeafNode(otherlv_2, grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_2_0()); - - } - if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getValueAccess().getParenthesizedExpressionParserRuleCall_2()); + + } + pushFollow(FollowSets000.FOLLOW_2); + this_ParenthesizedExpression_2=ruleParenthesizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_ParenthesizedExpression_2; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleValue" + + + // $ANTLR start "entryRuleParenthesizedExpression" + // InternalBehaviorAnnexParser.g:3913:1: entryRuleParenthesizedExpression returns [EObject current=null] : iv_ruleParenthesizedExpression= ruleParenthesizedExpression EOF ; + public final EObject entryRuleParenthesizedExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParenthesizedExpression = null; + + + try { + // InternalBehaviorAnnexParser.g:3913:64: (iv_ruleParenthesizedExpression= ruleParenthesizedExpression EOF ) + // InternalBehaviorAnnexParser.g:3914:2: iv_ruleParenthesizedExpression= ruleParenthesizedExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getParenthesizedExpressionRule()); + } + pushFollow(FollowSets000.FOLLOW_1); + iv_ruleParenthesizedExpression=ruleParenthesizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleParenthesizedExpression; + } + match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParenthesizedExpression" + + + // $ANTLR start "ruleParenthesizedExpression" + // InternalBehaviorAnnexParser.g:3920: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; + + Token otherlv_0=null; + Token otherlv_2=null; + EObject lv_expression_1_0 = null; + + + + 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: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 + { + otherlv_0=(Token)match(input,LeftParenthesis,FollowSets000.FOLLOW_50); if (state.failed) return current; + if ( state.backtracking==0 ) { + + 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:3933:4: (lv_expression_1_0= ruleValueExpression ) + // InternalBehaviorAnnexParser.g:3934:5: lv_expression_1_0= ruleValueExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getParenthesizedExpressionAccess().getExpressionValueExpressionParserRuleCall_1_0()); + + } + pushFollow(FollowSets000.FOLLOW_39); + lv_expression_1_0=ruleValueExpression(); - newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getValueExpressionParserRuleCall_2_1()); - - } - pushFollow(FollowSets000.FOLLOW_39); - this_ValueExpression_3=ruleValueExpression(); + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { - state._fsp--; - if (state.failed) return current; - if ( state.backtracking==0 ) { + if (current==null) { + current = createModelElementForParent(grammarAccess.getParenthesizedExpressionRule()); + } + set( + current, + "expression", + lv_expression_1_0, + "org.osate.xtext.aadl2.ba.BehaviorAnnex.ValueExpression"); + afterParserOrEnumRuleCall(); + + } - current = this_ValueExpression_3; - afterParserOrEnumRuleCall(); - - } - otherlv_4=(Token)match(input,RightParenthesis,FollowSets000.FOLLOW_2); if (state.failed) return current; - if ( state.backtracking==0 ) { + } - newLeafNode(otherlv_4, grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_2_2()); - - } - } + } + otherlv_2=(Token)match(input,RightParenthesis,FollowSets000.FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { - } - break; + newLeafNode(otherlv_2, grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + + } } @@ -10933,11 +11374,11 @@ public final EObject rulePrimaryExpression() throws RecognitionException { } return current; } - // $ANTLR end "rulePrimaryExpression" + // $ANTLR end "ruleParenthesizedExpression" // $ANTLR start "entryRuleValueConstant" - // InternalBehaviorAnnexParser.g:3864:1: entryRuleValueConstant returns [EObject current=null] : iv_ruleValueConstant= ruleValueConstant EOF ; + // InternalBehaviorAnnexParser.g:3959:1: entryRuleValueConstant returns [EObject current=null] : iv_ruleValueConstant= ruleValueConstant EOF ; public final EObject entryRuleValueConstant() throws RecognitionException { EObject current = null; @@ -10945,8 +11386,8 @@ public final EObject entryRuleValueConstant() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:3864:54: (iv_ruleValueConstant= ruleValueConstant EOF ) - // InternalBehaviorAnnexParser.g:3865:2: iv_ruleValueConstant= ruleValueConstant EOF + // InternalBehaviorAnnexParser.g:3959:54: (iv_ruleValueConstant= ruleValueConstant EOF ) + // InternalBehaviorAnnexParser.g:3960:2: iv_ruleValueConstant= ruleValueConstant EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getValueConstantRule()); @@ -10977,7 +11418,7 @@ public final EObject entryRuleValueConstant() throws RecognitionException { // $ANTLR start "ruleValueConstant" - // InternalBehaviorAnnexParser.g:3871: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: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 ) ; public final EObject ruleValueConstant() throws RecognitionException { EObject current = null; @@ -10996,49 +11437,49 @@ public final EObject ruleValueConstant() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3877:2: ( (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) ) - // InternalBehaviorAnnexParser.g:3878:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) + // 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:3878:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral | this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral | this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral | this_HashPropertyReference_4= ruleHashPropertyReference ) - int alt72=5; + // 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; switch ( input.LA(1) ) { case RULE_INTEGER_LIT: { - alt72=1; + alt74=1; } break; case RULE_REAL_LIT: { - alt72=2; + alt74=2; } break; case RULE_STRING: { - alt72=3; + alt74=3; } break; case False: case True: { - alt72=4; + alt74=4; } break; case NumberSign: { - alt72=5; + alt74=5; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 72, 0, input); + new NoViableAltException("", 74, 0, input); throw nvae; } - switch (alt72) { + switch (alt74) { case 1 : - // InternalBehaviorAnnexParser.g:3879:3: this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral + // InternalBehaviorAnnexParser.g:3974:3: this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral { if ( state.backtracking==0 ) { @@ -11060,7 +11501,7 @@ public final EObject ruleValueConstant() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:3888:3: this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral + // InternalBehaviorAnnexParser.g:3983:3: this_BehaviorRealLiteral_1= ruleBehaviorRealLiteral { if ( state.backtracking==0 ) { @@ -11082,7 +11523,7 @@ public final EObject ruleValueConstant() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:3897:3: this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral + // InternalBehaviorAnnexParser.g:3992:3: this_BehaviorStringLiteral_2= ruleBehaviorStringLiteral { if ( state.backtracking==0 ) { @@ -11104,7 +11545,7 @@ public final EObject ruleValueConstant() throws RecognitionException { } break; case 4 : - // InternalBehaviorAnnexParser.g:3906:3: this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral + // InternalBehaviorAnnexParser.g:4001:3: this_BehaviorBooleanLiteral_3= ruleBehaviorBooleanLiteral { if ( state.backtracking==0 ) { @@ -11126,7 +11567,7 @@ public final EObject ruleValueConstant() throws RecognitionException { } break; case 5 : - // InternalBehaviorAnnexParser.g:3915:3: this_HashPropertyReference_4= ruleHashPropertyReference + // InternalBehaviorAnnexParser.g:4010:3: this_HashPropertyReference_4= ruleHashPropertyReference { if ( state.backtracking==0 ) { @@ -11172,7 +11613,7 @@ public final EObject ruleValueConstant() throws RecognitionException { // $ANTLR start "entryRuleBehaviorIntegerLiteral" - // InternalBehaviorAnnexParser.g:3927:1: entryRuleBehaviorIntegerLiteral returns [EObject current=null] : iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF ; + // InternalBehaviorAnnexParser.g:4022:1: entryRuleBehaviorIntegerLiteral returns [EObject current=null] : iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF ; public final EObject entryRuleBehaviorIntegerLiteral() throws RecognitionException { EObject current = null; @@ -11180,8 +11621,8 @@ public final EObject entryRuleBehaviorIntegerLiteral() throws RecognitionExcepti try { - // InternalBehaviorAnnexParser.g:3927:63: (iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF ) - // InternalBehaviorAnnexParser.g:3928:2: iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF + // InternalBehaviorAnnexParser.g:4022:63: (iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF ) + // InternalBehaviorAnnexParser.g:4023:2: iv_ruleBehaviorIntegerLiteral= ruleBehaviorIntegerLiteral EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBehaviorIntegerLiteralRule()); @@ -11212,7 +11653,7 @@ public final EObject entryRuleBehaviorIntegerLiteral() throws RecognitionExcepti // $ANTLR start "ruleBehaviorIntegerLiteral" - // InternalBehaviorAnnexParser.g:3934:1: ruleBehaviorIntegerLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_INTEGER_LIT ) ) ; + // InternalBehaviorAnnexParser.g:4029:1: ruleBehaviorIntegerLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_INTEGER_LIT ) ) ; public final EObject ruleBehaviorIntegerLiteral() throws RecognitionException { EObject current = null; @@ -11222,14 +11663,14 @@ public final EObject ruleBehaviorIntegerLiteral() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3940:2: ( ( (lv_value_0_0= RULE_INTEGER_LIT ) ) ) - // InternalBehaviorAnnexParser.g:3941:2: ( (lv_value_0_0= RULE_INTEGER_LIT ) ) + // InternalBehaviorAnnexParser.g:4035:2: ( ( (lv_value_0_0= RULE_INTEGER_LIT ) ) ) + // InternalBehaviorAnnexParser.g:4036:2: ( (lv_value_0_0= RULE_INTEGER_LIT ) ) { - // InternalBehaviorAnnexParser.g:3941:2: ( (lv_value_0_0= RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:3942:3: (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:3942:3: (lv_value_0_0= RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:3943:4: 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 { lv_value_0_0=(Token)match(input,RULE_INTEGER_LIT,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -11277,7 +11718,7 @@ public final EObject ruleBehaviorIntegerLiteral() throws RecognitionException { // $ANTLR start "entryRuleBehaviorRealLiteral" - // InternalBehaviorAnnexParser.g:3962:1: entryRuleBehaviorRealLiteral returns [EObject current=null] : iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF ; + // InternalBehaviorAnnexParser.g:4057:1: entryRuleBehaviorRealLiteral returns [EObject current=null] : iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF ; public final EObject entryRuleBehaviorRealLiteral() throws RecognitionException { EObject current = null; @@ -11285,8 +11726,8 @@ public final EObject entryRuleBehaviorRealLiteral() throws RecognitionException try { - // InternalBehaviorAnnexParser.g:3962:60: (iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF ) - // InternalBehaviorAnnexParser.g:3963:2: iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF + // InternalBehaviorAnnexParser.g:4057:60: (iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF ) + // InternalBehaviorAnnexParser.g:4058:2: iv_ruleBehaviorRealLiteral= ruleBehaviorRealLiteral EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBehaviorRealLiteralRule()); @@ -11317,7 +11758,7 @@ public final EObject entryRuleBehaviorRealLiteral() throws RecognitionException // $ANTLR start "ruleBehaviorRealLiteral" - // InternalBehaviorAnnexParser.g:3969:1: ruleBehaviorRealLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_REAL_LIT ) ) ; + // InternalBehaviorAnnexParser.g:4064:1: ruleBehaviorRealLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_REAL_LIT ) ) ; public final EObject ruleBehaviorRealLiteral() throws RecognitionException { EObject current = null; @@ -11327,14 +11768,14 @@ public final EObject ruleBehaviorRealLiteral() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:3975:2: ( ( (lv_value_0_0= RULE_REAL_LIT ) ) ) - // InternalBehaviorAnnexParser.g:3976:2: ( (lv_value_0_0= RULE_REAL_LIT ) ) + // InternalBehaviorAnnexParser.g:4070:2: ( ( (lv_value_0_0= RULE_REAL_LIT ) ) ) + // InternalBehaviorAnnexParser.g:4071:2: ( (lv_value_0_0= RULE_REAL_LIT ) ) { - // InternalBehaviorAnnexParser.g:3976:2: ( (lv_value_0_0= RULE_REAL_LIT ) ) - // InternalBehaviorAnnexParser.g:3977:3: (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:3977:3: (lv_value_0_0= RULE_REAL_LIT ) - // InternalBehaviorAnnexParser.g:3978:4: 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 { lv_value_0_0=(Token)match(input,RULE_REAL_LIT,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -11382,7 +11823,7 @@ public final EObject ruleBehaviorRealLiteral() throws RecognitionException { // $ANTLR start "entryRuleBehaviorStringLiteral" - // InternalBehaviorAnnexParser.g:3997:1: entryRuleBehaviorStringLiteral returns [EObject current=null] : iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF ; + // InternalBehaviorAnnexParser.g:4092:1: entryRuleBehaviorStringLiteral returns [EObject current=null] : iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF ; public final EObject entryRuleBehaviorStringLiteral() throws RecognitionException { EObject current = null; @@ -11390,8 +11831,8 @@ public final EObject entryRuleBehaviorStringLiteral() throws RecognitionExceptio try { - // InternalBehaviorAnnexParser.g:3997:62: (iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF ) - // InternalBehaviorAnnexParser.g:3998:2: iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF + // InternalBehaviorAnnexParser.g:4092:62: (iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF ) + // InternalBehaviorAnnexParser.g:4093:2: iv_ruleBehaviorStringLiteral= ruleBehaviorStringLiteral EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBehaviorStringLiteralRule()); @@ -11422,7 +11863,7 @@ public final EObject entryRuleBehaviorStringLiteral() throws RecognitionExceptio // $ANTLR start "ruleBehaviorStringLiteral" - // InternalBehaviorAnnexParser.g:4004:1: ruleBehaviorStringLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; + // InternalBehaviorAnnexParser.g:4099:1: ruleBehaviorStringLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; public final EObject ruleBehaviorStringLiteral() throws RecognitionException { EObject current = null; @@ -11432,14 +11873,14 @@ public final EObject ruleBehaviorStringLiteral() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4010:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) - // InternalBehaviorAnnexParser.g:4011:2: ( (lv_value_0_0= RULE_STRING ) ) + // InternalBehaviorAnnexParser.g:4105:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) + // InternalBehaviorAnnexParser.g:4106:2: ( (lv_value_0_0= RULE_STRING ) ) { - // InternalBehaviorAnnexParser.g:4011:2: ( (lv_value_0_0= RULE_STRING ) ) - // InternalBehaviorAnnexParser.g:4012:3: (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:4012:3: (lv_value_0_0= RULE_STRING ) - // InternalBehaviorAnnexParser.g:4013:4: 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 { lv_value_0_0=(Token)match(input,RULE_STRING,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -11487,7 +11928,7 @@ public final EObject ruleBehaviorStringLiteral() throws RecognitionException { // $ANTLR start "entryRuleBehaviorBooleanLiteral" - // InternalBehaviorAnnexParser.g:4032:1: entryRuleBehaviorBooleanLiteral returns [EObject current=null] : iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF ; + // InternalBehaviorAnnexParser.g:4127:1: entryRuleBehaviorBooleanLiteral returns [EObject current=null] : iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF ; public final EObject entryRuleBehaviorBooleanLiteral() throws RecognitionException { EObject current = null; @@ -11495,8 +11936,8 @@ public final EObject entryRuleBehaviorBooleanLiteral() throws RecognitionExcepti try { - // InternalBehaviorAnnexParser.g:4032:63: (iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF ) - // InternalBehaviorAnnexParser.g:4033:2: iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF + // InternalBehaviorAnnexParser.g:4127:63: (iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF ) + // InternalBehaviorAnnexParser.g:4128:2: iv_ruleBehaviorBooleanLiteral= ruleBehaviorBooleanLiteral EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBehaviorBooleanLiteralRule()); @@ -11527,7 +11968,7 @@ public final EObject entryRuleBehaviorBooleanLiteral() throws RecognitionExcepti // $ANTLR start "ruleBehaviorBooleanLiteral" - // InternalBehaviorAnnexParser.g:4039:1: ruleBehaviorBooleanLiteral returns [EObject current=null] : ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ; + // InternalBehaviorAnnexParser.g:4134:1: ruleBehaviorBooleanLiteral returns [EObject current=null] : ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ; public final EObject ruleBehaviorBooleanLiteral() throws RecognitionException { EObject current = null; @@ -11538,14 +11979,14 @@ public final EObject ruleBehaviorBooleanLiteral() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4045:2: ( ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ) - // InternalBehaviorAnnexParser.g:4046:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) + // 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:4046:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) - // InternalBehaviorAnnexParser.g:4047:3: () ( ( (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:4047:3: () - // InternalBehaviorAnnexParser.g:4048:4: + // InternalBehaviorAnnexParser.g:4142:3: () + // InternalBehaviorAnnexParser.g:4143:4: { if ( state.backtracking==0 ) { @@ -11557,32 +11998,32 @@ public final EObject ruleBehaviorBooleanLiteral() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4054:3: ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) - int alt73=2; - int LA73_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:4149:3: ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) + int alt75=2; + int LA75_0 = input.LA(1); - if ( (LA73_0==True) ) { - alt73=1; + if ( (LA75_0==True) ) { + alt75=1; } - else if ( (LA73_0==False) ) { - alt73=2; + else if ( (LA75_0==False) ) { + alt75=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 73, 0, input); + new NoViableAltException("", 75, 0, input); throw nvae; } - switch (alt73) { + switch (alt75) { case 1 : - // InternalBehaviorAnnexParser.g:4055:4: ( (lv_value_1_0= True ) ) + // InternalBehaviorAnnexParser.g:4150:4: ( (lv_value_1_0= True ) ) { - // InternalBehaviorAnnexParser.g:4055:4: ( (lv_value_1_0= True ) ) - // InternalBehaviorAnnexParser.g:4056:5: (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:4056:5: (lv_value_1_0= True ) - // InternalBehaviorAnnexParser.g:4057:6: lv_value_1_0= True + // InternalBehaviorAnnexParser.g:4151:5: (lv_value_1_0= True ) + // InternalBehaviorAnnexParser.g:4152: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 ) { @@ -11608,7 +12049,7 @@ else if ( (LA73_0==False) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:4070:4: otherlv_2= False + // InternalBehaviorAnnexParser.g:4165:4: otherlv_2= False { otherlv_2=(Token)match(input,False,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -11647,7 +12088,7 @@ else if ( (LA73_0==False) ) { // $ANTLR start "entryRuleReferenceExpression" - // InternalBehaviorAnnexParser.g:4079:1: entryRuleReferenceExpression returns [EObject current=null] : iv_ruleReferenceExpression= ruleReferenceExpression EOF ; + // InternalBehaviorAnnexParser.g:4174:1: entryRuleReferenceExpression returns [EObject current=null] : iv_ruleReferenceExpression= ruleReferenceExpression EOF ; public final EObject entryRuleReferenceExpression() throws RecognitionException { EObject current = null; @@ -11655,8 +12096,8 @@ public final EObject entryRuleReferenceExpression() throws RecognitionException try { - // InternalBehaviorAnnexParser.g:4079:60: (iv_ruleReferenceExpression= ruleReferenceExpression EOF ) - // InternalBehaviorAnnexParser.g:4080:2: iv_ruleReferenceExpression= ruleReferenceExpression EOF + // InternalBehaviorAnnexParser.g:4174:60: (iv_ruleReferenceExpression= ruleReferenceExpression EOF ) + // InternalBehaviorAnnexParser.g:4175:2: iv_ruleReferenceExpression= ruleReferenceExpression EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceExpressionRule()); @@ -11687,7 +12128,7 @@ public final EObject entryRuleReferenceExpression() throws RecognitionException // $ANTLR start "ruleReferenceExpression" - // InternalBehaviorAnnexParser.g:4086: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: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 ) ) ) ) )? ) ; public final EObject ruleReferenceExpression() throws RecognitionException { EObject current = null; @@ -11705,24 +12146,24 @@ public final EObject ruleReferenceExpression() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4092: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:4093: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: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:4093: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:4094: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: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:4094:3: ( (lv_reference_0_0= ruleReference ) ) - // InternalBehaviorAnnexParser.g:4095:4: (lv_reference_0_0= ruleReference ) + // InternalBehaviorAnnexParser.g:4189:3: ( (lv_reference_0_0= ruleReference ) ) + // InternalBehaviorAnnexParser.g:4190:4: (lv_reference_0_0= ruleReference ) { - // InternalBehaviorAnnexParser.g:4095:4: (lv_reference_0_0= ruleReference ) - // InternalBehaviorAnnexParser.g:4096:5: lv_reference_0_0= ruleReference + // InternalBehaviorAnnexParser.g:4190:4: (lv_reference_0_0= ruleReference ) + // InternalBehaviorAnnexParser.g:4191:5: lv_reference_0_0= ruleReference { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceExpressionAccess().getReferenceReferenceParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_68); + pushFollow(FollowSets000.FOLLOW_70); lv_reference_0_0=ruleReference(); state._fsp--; @@ -11746,35 +12187,35 @@ public final EObject ruleReferenceExpression() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4113: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 alt75=4; + // 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; switch ( input.LA(1) ) { case NumberSign: { - alt75=1; + alt77=1; } break; case QuestionMark: { - alt75=2; + alt77=2; } break; case Apostrophe: { - alt75=3; + alt77=3; } break; } - switch (alt75) { + switch (alt77) { case 1 : - // InternalBehaviorAnnexParser.g:4114:4: ( (lv_property_1_0= rulePropertyReferenceTail ) ) + // InternalBehaviorAnnexParser.g:4209:4: ( (lv_property_1_0= rulePropertyReferenceTail ) ) { - // InternalBehaviorAnnexParser.g:4114:4: ( (lv_property_1_0= rulePropertyReferenceTail ) ) - // InternalBehaviorAnnexParser.g:4115:5: (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:4115:5: (lv_property_1_0= rulePropertyReferenceTail ) - // InternalBehaviorAnnexParser.g:4116:6: lv_property_1_0= rulePropertyReferenceTail + // InternalBehaviorAnnexParser.g:4210:5: (lv_property_1_0= rulePropertyReferenceTail ) + // InternalBehaviorAnnexParser.g:4211:6: lv_property_1_0= rulePropertyReferenceTail { if ( state.backtracking==0 ) { @@ -11809,13 +12250,13 @@ public final EObject ruleReferenceExpression() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:4134:4: ( (lv_dequeue_2_0= QuestionMark ) ) + // InternalBehaviorAnnexParser.g:4229:4: ( (lv_dequeue_2_0= QuestionMark ) ) { - // InternalBehaviorAnnexParser.g:4134:4: ( (lv_dequeue_2_0= QuestionMark ) ) - // InternalBehaviorAnnexParser.g:4135:5: (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:4135:5: (lv_dequeue_2_0= QuestionMark ) - // InternalBehaviorAnnexParser.g:4136:6: lv_dequeue_2_0= QuestionMark + // InternalBehaviorAnnexParser.g:4230:5: (lv_dequeue_2_0= QuestionMark ) + // InternalBehaviorAnnexParser.g:4231: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 ) { @@ -11841,52 +12282,52 @@ public final EObject ruleReferenceExpression() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:4149: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:4149:4: (otherlv_3= Apostrophe ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) ) - // InternalBehaviorAnnexParser.g:4150:5: 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 ) ) ) { - otherlv_3=(Token)match(input,Apostrophe,FollowSets000.FOLLOW_69); if (state.failed) return current; + otherlv_3=(Token)match(input,Apostrophe,FollowSets000.FOLLOW_71); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getReferenceExpressionAccess().getApostropheKeyword_1_2_0()); } - // InternalBehaviorAnnexParser.g:4154:5: ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) - int alt74=3; + // InternalBehaviorAnnexParser.g:4249:5: ( ( (lv_count_4_0= Count ) ) | ( (lv_fresh_5_0= Fresh ) ) | ( (lv_updated_6_0= Updated ) ) ) + int alt76=3; switch ( input.LA(1) ) { case Count: { - alt74=1; + alt76=1; } break; case Fresh: { - alt74=2; + alt76=2; } break; case Updated: { - alt74=3; + alt76=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 74, 0, input); + new NoViableAltException("", 76, 0, input); throw nvae; } - switch (alt74) { + switch (alt76) { case 1 : - // InternalBehaviorAnnexParser.g:4155:6: ( (lv_count_4_0= Count ) ) + // InternalBehaviorAnnexParser.g:4250:6: ( (lv_count_4_0= Count ) ) { - // InternalBehaviorAnnexParser.g:4155:6: ( (lv_count_4_0= Count ) ) - // InternalBehaviorAnnexParser.g:4156:7: (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:4156:7: (lv_count_4_0= Count ) - // InternalBehaviorAnnexParser.g:4157:8: lv_count_4_0= Count + // InternalBehaviorAnnexParser.g:4251:7: (lv_count_4_0= Count ) + // InternalBehaviorAnnexParser.g:4252: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 ) { @@ -11912,13 +12353,13 @@ public final EObject ruleReferenceExpression() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:4170:6: ( (lv_fresh_5_0= Fresh ) ) + // InternalBehaviorAnnexParser.g:4265:6: ( (lv_fresh_5_0= Fresh ) ) { - // InternalBehaviorAnnexParser.g:4170:6: ( (lv_fresh_5_0= Fresh ) ) - // InternalBehaviorAnnexParser.g:4171:7: (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:4171:7: (lv_fresh_5_0= Fresh ) - // InternalBehaviorAnnexParser.g:4172:8: lv_fresh_5_0= Fresh + // InternalBehaviorAnnexParser.g:4266:7: (lv_fresh_5_0= Fresh ) + // InternalBehaviorAnnexParser.g:4267: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 ) { @@ -11944,13 +12385,13 @@ public final EObject ruleReferenceExpression() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:4185:6: ( (lv_updated_6_0= Updated ) ) + // InternalBehaviorAnnexParser.g:4280:6: ( (lv_updated_6_0= Updated ) ) { - // InternalBehaviorAnnexParser.g:4185:6: ( (lv_updated_6_0= Updated ) ) - // InternalBehaviorAnnexParser.g:4186:7: (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:4186:7: (lv_updated_6_0= Updated ) - // InternalBehaviorAnnexParser.g:4187:8: lv_updated_6_0= Updated + // InternalBehaviorAnnexParser.g:4281:7: (lv_updated_6_0= Updated ) + // InternalBehaviorAnnexParser.g:4282: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 ) { @@ -12012,7 +12453,7 @@ public final EObject ruleReferenceExpression() throws RecognitionException { // $ANTLR start "entryRuleHashPropertyReference" - // InternalBehaviorAnnexParser.g:4206:1: entryRuleHashPropertyReference returns [EObject current=null] : iv_ruleHashPropertyReference= ruleHashPropertyReference EOF ; + // InternalBehaviorAnnexParser.g:4301:1: entryRuleHashPropertyReference returns [EObject current=null] : iv_ruleHashPropertyReference= ruleHashPropertyReference EOF ; public final EObject entryRuleHashPropertyReference() throws RecognitionException { EObject current = null; @@ -12020,8 +12461,8 @@ public final EObject entryRuleHashPropertyReference() throws RecognitionExceptio try { - // InternalBehaviorAnnexParser.g:4206:62: (iv_ruleHashPropertyReference= ruleHashPropertyReference EOF ) - // InternalBehaviorAnnexParser.g:4207:2: iv_ruleHashPropertyReference= ruleHashPropertyReference EOF + // InternalBehaviorAnnexParser.g:4301:62: (iv_ruleHashPropertyReference= ruleHashPropertyReference EOF ) + // InternalBehaviorAnnexParser.g:4302:2: iv_ruleHashPropertyReference= ruleHashPropertyReference EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getHashPropertyReferenceRule()); @@ -12052,7 +12493,7 @@ public final EObject entryRuleHashPropertyReference() throws RecognitionExceptio // $ANTLR start "ruleHashPropertyReference" - // InternalBehaviorAnnexParser.g:4213: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: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 ) )* ) ; public final EObject ruleHashPropertyReference() throws RecognitionException { EObject current = null; @@ -12068,11 +12509,11 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4219:2: ( (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) ) - // InternalBehaviorAnnexParser.g:4220:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) + // 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:4220:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) - // InternalBehaviorAnnexParser.g:4221:3: 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 ) )* { otherlv_0=(Token)match(input,NumberSign,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12080,18 +12521,18 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getHashPropertyReferenceAccess().getNumberSignKeyword_0()); } - // InternalBehaviorAnnexParser.g:4225:3: ( (lv_property_1_0= ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:4226:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4320:3: ( (lv_property_1_0= ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:4321:4: (lv_property_1_0= ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:4226:4: (lv_property_1_0= ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:4227:5: lv_property_1_0= ruleQualifiedName + // InternalBehaviorAnnexParser.g:4321:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4322:5: lv_property_1_0= ruleQualifiedName { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getHashPropertyReferenceAccess().getPropertyQualifiedNameParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_70); + pushFollow(FollowSets000.FOLLOW_72); lv_property_1_0=ruleQualifiedName(); state._fsp--; @@ -12115,30 +12556,30 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4244:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* - loop76: + // InternalBehaviorAnnexParser.g:4339:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* + loop78: do { - int alt76=2; - int LA76_0 = input.LA(1); + int alt78=2; + int LA78_0 = input.LA(1); - if ( (LA76_0==LeftSquareBracket) ) { - alt76=1; + if ( (LA78_0==LeftSquareBracket) ) { + alt78=1; } - switch (alt76) { + switch (alt78) { case 1 : - // InternalBehaviorAnnexParser.g:4245:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4340:4: (lv_indexes_2_0= rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:4245:4: (lv_indexes_2_0= rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:4246:5: lv_indexes_2_0= rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:4340:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4341:5: lv_indexes_2_0= rulePropertyArrayIndex { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getHashPropertyReferenceAccess().getIndexesPropertyArrayIndexParserRuleCall_2_0()); } - pushFollow(FollowSets000.FOLLOW_70); + pushFollow(FollowSets000.FOLLOW_72); lv_indexes_2_0=rulePropertyArrayIndex(); state._fsp--; @@ -12164,34 +12605,34 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { break; default : - break loop76; + break loop78; } } while (true); - // InternalBehaviorAnnexParser.g:4263:3: ( (lv_fields_3_0= ruleNamedPropertyField ) )* - loop77: + // InternalBehaviorAnnexParser.g:4358:3: ( (lv_fields_3_0= ruleNamedPropertyField ) )* + loop79: do { - int alt77=2; - int LA77_0 = input.LA(1); + int alt79=2; + int LA79_0 = input.LA(1); - if ( (LA77_0==FullStop) ) { - alt77=1; + if ( (LA79_0==FullStop) ) { + alt79=1; } - switch (alt77) { + switch (alt79) { case 1 : - // InternalBehaviorAnnexParser.g:4264:4: (lv_fields_3_0= ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:4359:4: (lv_fields_3_0= ruleNamedPropertyField ) { - // InternalBehaviorAnnexParser.g:4264:4: (lv_fields_3_0= ruleNamedPropertyField ) - // InternalBehaviorAnnexParser.g:4265:5: lv_fields_3_0= ruleNamedPropertyField + // InternalBehaviorAnnexParser.g:4359:4: (lv_fields_3_0= ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:4360:5: lv_fields_3_0= ruleNamedPropertyField { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getHashPropertyReferenceAccess().getFieldsNamedPropertyFieldParserRuleCall_3_0()); } - pushFollow(FollowSets000.FOLLOW_71); + pushFollow(FollowSets000.FOLLOW_73); lv_fields_3_0=ruleNamedPropertyField(); state._fsp--; @@ -12217,7 +12658,7 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { break; default : - break loop77; + break loop79; } } while (true); @@ -12246,7 +12687,7 @@ public final EObject ruleHashPropertyReference() throws RecognitionException { // $ANTLR start "entryRulePropertyReferenceTail" - // InternalBehaviorAnnexParser.g:4286:1: entryRulePropertyReferenceTail returns [EObject current=null] : iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF ; + // InternalBehaviorAnnexParser.g:4381:1: entryRulePropertyReferenceTail returns [EObject current=null] : iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF ; public final EObject entryRulePropertyReferenceTail() throws RecognitionException { EObject current = null; @@ -12254,8 +12695,8 @@ public final EObject entryRulePropertyReferenceTail() throws RecognitionExceptio try { - // InternalBehaviorAnnexParser.g:4286:62: (iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF ) - // InternalBehaviorAnnexParser.g:4287:2: iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF + // InternalBehaviorAnnexParser.g:4381:62: (iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF ) + // InternalBehaviorAnnexParser.g:4382:2: iv_rulePropertyReferenceTail= rulePropertyReferenceTail EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyReferenceTailRule()); @@ -12286,7 +12727,7 @@ public final EObject entryRulePropertyReferenceTail() throws RecognitionExceptio // $ANTLR start "rulePropertyReferenceTail" - // InternalBehaviorAnnexParser.g:4293: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: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 ) )* ) ; public final EObject rulePropertyReferenceTail() throws RecognitionException { EObject current = null; @@ -12302,11 +12743,11 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4299:2: ( (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) ) - // InternalBehaviorAnnexParser.g:4300:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) + // 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:4300:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ( (lv_fields_3_0= ruleNamedPropertyField ) )* ) - // InternalBehaviorAnnexParser.g:4301:3: 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 ) )* { otherlv_0=(Token)match(input,NumberSign,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12314,18 +12755,18 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getPropertyReferenceTailAccess().getNumberSignKeyword_0()); } - // InternalBehaviorAnnexParser.g:4305:3: ( (lv_property_1_0= ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:4306:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4400:3: ( (lv_property_1_0= ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:4401:4: (lv_property_1_0= ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:4306:4: (lv_property_1_0= ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:4307:5: lv_property_1_0= ruleQualifiedName + // InternalBehaviorAnnexParser.g:4401:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4402:5: lv_property_1_0= ruleQualifiedName { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyReferenceTailAccess().getPropertyQualifiedNameParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_70); + pushFollow(FollowSets000.FOLLOW_72); lv_property_1_0=ruleQualifiedName(); state._fsp--; @@ -12349,30 +12790,30 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4324:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* - loop78: + // InternalBehaviorAnnexParser.g:4419:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* + loop80: do { - int alt78=2; - int LA78_0 = input.LA(1); + int alt80=2; + int LA80_0 = input.LA(1); - if ( (LA78_0==LeftSquareBracket) ) { - alt78=1; + if ( (LA80_0==LeftSquareBracket) ) { + alt80=1; } - switch (alt78) { + switch (alt80) { case 1 : - // InternalBehaviorAnnexParser.g:4325:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4420:4: (lv_indexes_2_0= rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:4325:4: (lv_indexes_2_0= rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:4326:5: lv_indexes_2_0= rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:4420:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4421:5: lv_indexes_2_0= rulePropertyArrayIndex { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyReferenceTailAccess().getIndexesPropertyArrayIndexParserRuleCall_2_0()); } - pushFollow(FollowSets000.FOLLOW_70); + pushFollow(FollowSets000.FOLLOW_72); lv_indexes_2_0=rulePropertyArrayIndex(); state._fsp--; @@ -12398,34 +12839,34 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { break; default : - break loop78; + break loop80; } } while (true); - // InternalBehaviorAnnexParser.g:4343:3: ( (lv_fields_3_0= ruleNamedPropertyField ) )* - loop79: + // InternalBehaviorAnnexParser.g:4438:3: ( (lv_fields_3_0= ruleNamedPropertyField ) )* + loop81: do { - int alt79=2; - int LA79_0 = input.LA(1); + int alt81=2; + int LA81_0 = input.LA(1); - if ( (LA79_0==FullStop) ) { - alt79=1; + if ( (LA81_0==FullStop) ) { + alt81=1; } - switch (alt79) { + switch (alt81) { case 1 : - // InternalBehaviorAnnexParser.g:4344:4: (lv_fields_3_0= ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:4439:4: (lv_fields_3_0= ruleNamedPropertyField ) { - // InternalBehaviorAnnexParser.g:4344:4: (lv_fields_3_0= ruleNamedPropertyField ) - // InternalBehaviorAnnexParser.g:4345:5: lv_fields_3_0= ruleNamedPropertyField + // InternalBehaviorAnnexParser.g:4439:4: (lv_fields_3_0= ruleNamedPropertyField ) + // InternalBehaviorAnnexParser.g:4440:5: lv_fields_3_0= ruleNamedPropertyField { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyReferenceTailAccess().getFieldsNamedPropertyFieldParserRuleCall_3_0()); } - pushFollow(FollowSets000.FOLLOW_71); + pushFollow(FollowSets000.FOLLOW_73); lv_fields_3_0=ruleNamedPropertyField(); state._fsp--; @@ -12451,7 +12892,7 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { break; default : - break loop79; + break loop81; } } while (true); @@ -12480,7 +12921,7 @@ public final EObject rulePropertyReferenceTail() throws RecognitionException { // $ANTLR start "entryRuleNamedPropertyField" - // InternalBehaviorAnnexParser.g:4366:1: entryRuleNamedPropertyField returns [EObject current=null] : iv_ruleNamedPropertyField= ruleNamedPropertyField EOF ; + // InternalBehaviorAnnexParser.g:4461:1: entryRuleNamedPropertyField returns [EObject current=null] : iv_ruleNamedPropertyField= ruleNamedPropertyField EOF ; public final EObject entryRuleNamedPropertyField() throws RecognitionException { EObject current = null; @@ -12488,8 +12929,8 @@ public final EObject entryRuleNamedPropertyField() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4366:59: (iv_ruleNamedPropertyField= ruleNamedPropertyField EOF ) - // InternalBehaviorAnnexParser.g:4367:2: iv_ruleNamedPropertyField= ruleNamedPropertyField EOF + // InternalBehaviorAnnexParser.g:4461:59: (iv_ruleNamedPropertyField= ruleNamedPropertyField EOF ) + // InternalBehaviorAnnexParser.g:4462:2: iv_ruleNamedPropertyField= ruleNamedPropertyField EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNamedPropertyFieldRule()); @@ -12520,7 +12961,7 @@ public final EObject entryRuleNamedPropertyField() throws RecognitionException { // $ANTLR start "ruleNamedPropertyField" - // InternalBehaviorAnnexParser.g:4373:1: ruleNamedPropertyField returns [EObject current=null] : (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) ; + // InternalBehaviorAnnexParser.g:4468: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; @@ -12533,11 +12974,11 @@ public final EObject ruleNamedPropertyField() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4379:2: ( (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) ) - // InternalBehaviorAnnexParser.g:4380:2: (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) + // 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:4380:2: (otherlv_0= FullStop ( (lv_name_1_0= RULE_ID ) ) ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* ) - // InternalBehaviorAnnexParser.g:4381:3: 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 ) )* { otherlv_0=(Token)match(input,FullStop,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12545,11 +12986,11 @@ public final EObject ruleNamedPropertyField() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getNamedPropertyFieldAccess().getFullStopKeyword_0()); } - // InternalBehaviorAnnexParser.g:4385:3: ( (lv_name_1_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:4386:4: (lv_name_1_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:4480:3: ( (lv_name_1_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:4481:4: (lv_name_1_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:4386:4: (lv_name_1_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:4387:5: 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 { lv_name_1_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_13); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -12575,23 +13016,23 @@ public final EObject ruleNamedPropertyField() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4403:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* - loop80: + // InternalBehaviorAnnexParser.g:4498:3: ( (lv_indexes_2_0= rulePropertyArrayIndex ) )* + loop82: do { - int alt80=2; - int LA80_0 = input.LA(1); + int alt82=2; + int LA82_0 = input.LA(1); - if ( (LA80_0==LeftSquareBracket) ) { - alt80=1; + if ( (LA82_0==LeftSquareBracket) ) { + alt82=1; } - switch (alt80) { + switch (alt82) { case 1 : - // InternalBehaviorAnnexParser.g:4404:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4499:4: (lv_indexes_2_0= rulePropertyArrayIndex ) { - // InternalBehaviorAnnexParser.g:4404:4: (lv_indexes_2_0= rulePropertyArrayIndex ) - // InternalBehaviorAnnexParser.g:4405:5: lv_indexes_2_0= rulePropertyArrayIndex + // InternalBehaviorAnnexParser.g:4499:4: (lv_indexes_2_0= rulePropertyArrayIndex ) + // InternalBehaviorAnnexParser.g:4500:5: lv_indexes_2_0= rulePropertyArrayIndex { if ( state.backtracking==0 ) { @@ -12624,7 +13065,7 @@ public final EObject ruleNamedPropertyField() throws RecognitionException { break; default : - break loop80; + break loop82; } } while (true); @@ -12653,7 +13094,7 @@ public final EObject ruleNamedPropertyField() throws RecognitionException { // $ANTLR start "entryRulePropertyArrayIndex" - // InternalBehaviorAnnexParser.g:4426:1: entryRulePropertyArrayIndex returns [EObject current=null] : iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF ; + // InternalBehaviorAnnexParser.g:4521:1: entryRulePropertyArrayIndex returns [EObject current=null] : iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF ; public final EObject entryRulePropertyArrayIndex() throws RecognitionException { EObject current = null; @@ -12661,8 +13102,8 @@ public final EObject entryRulePropertyArrayIndex() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4426:59: (iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF ) - // InternalBehaviorAnnexParser.g:4427:2: iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF + // InternalBehaviorAnnexParser.g:4521:59: (iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF ) + // InternalBehaviorAnnexParser.g:4522:2: iv_rulePropertyArrayIndex= rulePropertyArrayIndex EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyArrayIndexRule()); @@ -12693,7 +13134,7 @@ public final EObject entryRulePropertyArrayIndex() throws RecognitionException { // $ANTLR start "rulePropertyArrayIndex" - // InternalBehaviorAnnexParser.g:4433:1: rulePropertyArrayIndex returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:4528: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; @@ -12706,23 +13147,23 @@ public final EObject rulePropertyArrayIndex() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4439:2: ( (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:4440:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) + // 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:4440:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= rulePropertyIndexValue ) ) otherlv_2= RightSquareBracket ) - // InternalBehaviorAnnexParser.g:4441:3: 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 { - otherlv_0=(Token)match(input,LeftSquareBracket,FollowSets000.FOLLOW_72); if (state.failed) return current; + otherlv_0=(Token)match(input,LeftSquareBracket,FollowSets000.FOLLOW_74); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getPropertyArrayIndexAccess().getLeftSquareBracketKeyword_0()); } - // InternalBehaviorAnnexParser.g:4445:3: ( (lv_value_1_0= rulePropertyIndexValue ) ) - // InternalBehaviorAnnexParser.g:4446:4: (lv_value_1_0= rulePropertyIndexValue ) + // InternalBehaviorAnnexParser.g:4540:3: ( (lv_value_1_0= rulePropertyIndexValue ) ) + // InternalBehaviorAnnexParser.g:4541:4: (lv_value_1_0= rulePropertyIndexValue ) { - // InternalBehaviorAnnexParser.g:4446:4: (lv_value_1_0= rulePropertyIndexValue ) - // InternalBehaviorAnnexParser.g:4447:5: lv_value_1_0= rulePropertyIndexValue + // InternalBehaviorAnnexParser.g:4541:4: (lv_value_1_0= rulePropertyIndexValue ) + // InternalBehaviorAnnexParser.g:4542:5: lv_value_1_0= rulePropertyIndexValue { if ( state.backtracking==0 ) { @@ -12784,7 +13225,7 @@ public final EObject rulePropertyArrayIndex() throws RecognitionException { // $ANTLR start "entryRulePropertyIndexValue" - // InternalBehaviorAnnexParser.g:4472:1: entryRulePropertyIndexValue returns [EObject current=null] : iv_rulePropertyIndexValue= rulePropertyIndexValue EOF ; + // InternalBehaviorAnnexParser.g:4567:1: entryRulePropertyIndexValue returns [EObject current=null] : iv_rulePropertyIndexValue= rulePropertyIndexValue EOF ; public final EObject entryRulePropertyIndexValue() throws RecognitionException { EObject current = null; @@ -12792,8 +13233,8 @@ public final EObject entryRulePropertyIndexValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4472:59: (iv_rulePropertyIndexValue= rulePropertyIndexValue EOF ) - // InternalBehaviorAnnexParser.g:4473:2: iv_rulePropertyIndexValue= rulePropertyIndexValue EOF + // InternalBehaviorAnnexParser.g:4567:59: (iv_rulePropertyIndexValue= rulePropertyIndexValue EOF ) + // InternalBehaviorAnnexParser.g:4568:2: iv_rulePropertyIndexValue= rulePropertyIndexValue EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyIndexValueRule()); @@ -12824,7 +13265,7 @@ public final EObject entryRulePropertyIndexValue() throws RecognitionException { // $ANTLR start "rulePropertyIndexValue" - // InternalBehaviorAnnexParser.g:4479:1: rulePropertyIndexValue returns [EObject current=null] : (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) ; + // InternalBehaviorAnnexParser.g:4574: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; @@ -12839,38 +13280,38 @@ public final EObject rulePropertyIndexValue() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4485:2: ( (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) ) - // InternalBehaviorAnnexParser.g:4486:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) + // 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:4486:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) - int alt81=3; + // InternalBehaviorAnnexParser.g:4581:2: (this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral | this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference | this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression ) + int alt83=3; switch ( input.LA(1) ) { case RULE_INTEGER_LIT: { - alt81=1; + alt83=1; } break; case NumberSign: { - alt81=2; + alt83=2; } break; case RULE_ID: { - alt81=3; + alt83=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 81, 0, input); + new NoViableAltException("", 83, 0, input); throw nvae; } - switch (alt81) { + switch (alt83) { case 1 : - // InternalBehaviorAnnexParser.g:4487:3: this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral + // InternalBehaviorAnnexParser.g:4582:3: this_BehaviorIntegerLiteral_0= ruleBehaviorIntegerLiteral { if ( state.backtracking==0 ) { @@ -12892,7 +13333,7 @@ public final EObject rulePropertyIndexValue() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:4496:3: this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference + // InternalBehaviorAnnexParser.g:4591:3: this_PropertyIndexPropertyReference_1= rulePropertyIndexPropertyReference { if ( state.backtracking==0 ) { @@ -12914,7 +13355,7 @@ public final EObject rulePropertyIndexValue() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:4505:3: this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression + // InternalBehaviorAnnexParser.g:4600:3: this_UnindexedReferenceExpression_2= ruleUnindexedReferenceExpression { if ( state.backtracking==0 ) { @@ -12960,7 +13401,7 @@ public final EObject rulePropertyIndexValue() throws RecognitionException { // $ANTLR start "entryRulePropertyIndexPropertyReference" - // InternalBehaviorAnnexParser.g:4517:1: entryRulePropertyIndexPropertyReference returns [EObject current=null] : iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF ; + // InternalBehaviorAnnexParser.g:4612:1: entryRulePropertyIndexPropertyReference returns [EObject current=null] : iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF ; public final EObject entryRulePropertyIndexPropertyReference() throws RecognitionException { EObject current = null; @@ -12968,8 +13409,8 @@ public final EObject entryRulePropertyIndexPropertyReference() throws Recognitio try { - // InternalBehaviorAnnexParser.g:4517:71: (iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF ) - // InternalBehaviorAnnexParser.g:4518:2: iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF + // InternalBehaviorAnnexParser.g:4612:71: (iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF ) + // InternalBehaviorAnnexParser.g:4613:2: iv_rulePropertyIndexPropertyReference= rulePropertyIndexPropertyReference EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyIndexPropertyReferenceRule()); @@ -13000,7 +13441,7 @@ public final EObject entryRulePropertyIndexPropertyReference() throws Recognitio // $ANTLR start "rulePropertyIndexPropertyReference" - // InternalBehaviorAnnexParser.g:4524:1: rulePropertyIndexPropertyReference returns [EObject current=null] : (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) ; + // InternalBehaviorAnnexParser.g:4619:1: rulePropertyIndexPropertyReference returns [EObject current=null] : (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) ; public final EObject rulePropertyIndexPropertyReference() throws RecognitionException { EObject current = null; @@ -13012,11 +13453,11 @@ public final EObject rulePropertyIndexPropertyReference() throws RecognitionExce enterRule(); try { - // InternalBehaviorAnnexParser.g:4530:2: ( (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) ) - // InternalBehaviorAnnexParser.g:4531:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) + // 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:4531:2: (otherlv_0= NumberSign ( (lv_property_1_0= ruleQualifiedName ) ) ) - // InternalBehaviorAnnexParser.g:4532:3: 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 ) ) { otherlv_0=(Token)match(input,NumberSign,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -13024,11 +13465,11 @@ public final EObject rulePropertyIndexPropertyReference() throws RecognitionExce newLeafNode(otherlv_0, grammarAccess.getPropertyIndexPropertyReferenceAccess().getNumberSignKeyword_0()); } - // InternalBehaviorAnnexParser.g:4536:3: ( (lv_property_1_0= ruleQualifiedName ) ) - // InternalBehaviorAnnexParser.g:4537:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4631:3: ( (lv_property_1_0= ruleQualifiedName ) ) + // InternalBehaviorAnnexParser.g:4632:4: (lv_property_1_0= ruleQualifiedName ) { - // InternalBehaviorAnnexParser.g:4537:4: (lv_property_1_0= ruleQualifiedName ) - // InternalBehaviorAnnexParser.g:4538:5: lv_property_1_0= ruleQualifiedName + // InternalBehaviorAnnexParser.g:4632:4: (lv_property_1_0= ruleQualifiedName ) + // InternalBehaviorAnnexParser.g:4633:5: lv_property_1_0= ruleQualifiedName { if ( state.backtracking==0 ) { @@ -13084,7 +13525,7 @@ public final EObject rulePropertyIndexPropertyReference() throws RecognitionExce // $ANTLR start "entryRuleUnindexedReferenceExpression" - // InternalBehaviorAnnexParser.g:4559:1: entryRuleUnindexedReferenceExpression returns [EObject current=null] : iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF ; + // InternalBehaviorAnnexParser.g:4654:1: entryRuleUnindexedReferenceExpression returns [EObject current=null] : iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF ; public final EObject entryRuleUnindexedReferenceExpression() throws RecognitionException { EObject current = null; @@ -13092,8 +13533,8 @@ public final EObject entryRuleUnindexedReferenceExpression() throws RecognitionE try { - // InternalBehaviorAnnexParser.g:4559:69: (iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF ) - // InternalBehaviorAnnexParser.g:4560:2: iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF + // InternalBehaviorAnnexParser.g:4654:69: (iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF ) + // InternalBehaviorAnnexParser.g:4655:2: iv_ruleUnindexedReferenceExpression= ruleUnindexedReferenceExpression EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceExpressionRule()); @@ -13124,7 +13565,7 @@ public final EObject entryRuleUnindexedReferenceExpression() throws RecognitionE // $ANTLR start "ruleUnindexedReferenceExpression" - // InternalBehaviorAnnexParser.g:4566: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: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 ) ) ) ) )? ) ; public final EObject ruleUnindexedReferenceExpression() throws RecognitionException { EObject current = null; @@ -13140,24 +13581,24 @@ public final EObject ruleUnindexedReferenceExpression() throws RecognitionExcept enterRule(); try { - // InternalBehaviorAnnexParser.g:4572: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:4573: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: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:4573: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:4574: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: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:4574:3: ( (lv_reference_0_0= ruleUnindexedReference ) ) - // InternalBehaviorAnnexParser.g:4575:4: (lv_reference_0_0= ruleUnindexedReference ) + // InternalBehaviorAnnexParser.g:4669:3: ( (lv_reference_0_0= ruleUnindexedReference ) ) + // InternalBehaviorAnnexParser.g:4670:4: (lv_reference_0_0= ruleUnindexedReference ) { - // InternalBehaviorAnnexParser.g:4575:4: (lv_reference_0_0= ruleUnindexedReference ) - // InternalBehaviorAnnexParser.g:4576:5: lv_reference_0_0= ruleUnindexedReference + // InternalBehaviorAnnexParser.g:4670:4: (lv_reference_0_0= ruleUnindexedReference ) + // InternalBehaviorAnnexParser.g:4671:5: lv_reference_0_0= ruleUnindexedReference { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceExpressionAccess().getReferenceUnindexedReferenceParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_73); + pushFollow(FollowSets000.FOLLOW_75); lv_reference_0_0=ruleUnindexedReference(); state._fsp--; @@ -13181,25 +13622,25 @@ public final EObject ruleUnindexedReferenceExpression() throws RecognitionExcept } - // InternalBehaviorAnnexParser.g:4593: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 alt83=3; - int LA83_0 = input.LA(1); + // 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); - if ( (LA83_0==QuestionMark) ) { - alt83=1; + if ( (LA85_0==QuestionMark) ) { + alt85=1; } - else if ( (LA83_0==Apostrophe) ) { - alt83=2; + else if ( (LA85_0==Apostrophe) ) { + alt85=2; } - switch (alt83) { + switch (alt85) { case 1 : - // InternalBehaviorAnnexParser.g:4594:4: ( (lv_dequeue_1_0= QuestionMark ) ) + // InternalBehaviorAnnexParser.g:4689:4: ( (lv_dequeue_1_0= QuestionMark ) ) { - // InternalBehaviorAnnexParser.g:4594:4: ( (lv_dequeue_1_0= QuestionMark ) ) - // InternalBehaviorAnnexParser.g:4595:5: (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:4595:5: (lv_dequeue_1_0= QuestionMark ) - // InternalBehaviorAnnexParser.g:4596:6: lv_dequeue_1_0= QuestionMark + // InternalBehaviorAnnexParser.g:4690:5: (lv_dequeue_1_0= QuestionMark ) + // InternalBehaviorAnnexParser.g:4691: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 ) { @@ -13225,52 +13666,52 @@ else if ( (LA83_0==Apostrophe) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:4609: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:4609:4: (otherlv_2= Apostrophe ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) ) - // InternalBehaviorAnnexParser.g:4610:5: 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 ) ) ) { - otherlv_2=(Token)match(input,Apostrophe,FollowSets000.FOLLOW_69); if (state.failed) return current; + otherlv_2=(Token)match(input,Apostrophe,FollowSets000.FOLLOW_71); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getUnindexedReferenceExpressionAccess().getApostropheKeyword_1_1_0()); } - // InternalBehaviorAnnexParser.g:4614:5: ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) - int alt82=3; + // InternalBehaviorAnnexParser.g:4709:5: ( ( (lv_count_3_0= Count ) ) | ( (lv_fresh_4_0= Fresh ) ) | ( (lv_updated_5_0= Updated ) ) ) + int alt84=3; switch ( input.LA(1) ) { case Count: { - alt82=1; + alt84=1; } break; case Fresh: { - alt82=2; + alt84=2; } break; case Updated: { - alt82=3; + alt84=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 82, 0, input); + new NoViableAltException("", 84, 0, input); throw nvae; } - switch (alt82) { + switch (alt84) { case 1 : - // InternalBehaviorAnnexParser.g:4615:6: ( (lv_count_3_0= Count ) ) + // InternalBehaviorAnnexParser.g:4710:6: ( (lv_count_3_0= Count ) ) { - // InternalBehaviorAnnexParser.g:4615:6: ( (lv_count_3_0= Count ) ) - // InternalBehaviorAnnexParser.g:4616:7: (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:4616:7: (lv_count_3_0= Count ) - // InternalBehaviorAnnexParser.g:4617:8: lv_count_3_0= Count + // InternalBehaviorAnnexParser.g:4711:7: (lv_count_3_0= Count ) + // InternalBehaviorAnnexParser.g:4712: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 ) { @@ -13296,13 +13737,13 @@ else if ( (LA83_0==Apostrophe) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:4630:6: ( (lv_fresh_4_0= Fresh ) ) + // InternalBehaviorAnnexParser.g:4725:6: ( (lv_fresh_4_0= Fresh ) ) { - // InternalBehaviorAnnexParser.g:4630:6: ( (lv_fresh_4_0= Fresh ) ) - // InternalBehaviorAnnexParser.g:4631:7: (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:4631:7: (lv_fresh_4_0= Fresh ) - // InternalBehaviorAnnexParser.g:4632:8: lv_fresh_4_0= Fresh + // InternalBehaviorAnnexParser.g:4726:7: (lv_fresh_4_0= Fresh ) + // InternalBehaviorAnnexParser.g:4727: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 ) { @@ -13328,13 +13769,13 @@ else if ( (LA83_0==Apostrophe) ) { } break; case 3 : - // InternalBehaviorAnnexParser.g:4645:6: ( (lv_updated_5_0= Updated ) ) + // InternalBehaviorAnnexParser.g:4740:6: ( (lv_updated_5_0= Updated ) ) { - // InternalBehaviorAnnexParser.g:4645:6: ( (lv_updated_5_0= Updated ) ) - // InternalBehaviorAnnexParser.g:4646:7: (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:4646:7: (lv_updated_5_0= Updated ) - // InternalBehaviorAnnexParser.g:4647:8: lv_updated_5_0= Updated + // InternalBehaviorAnnexParser.g:4741:7: (lv_updated_5_0= Updated ) + // InternalBehaviorAnnexParser.g:4742: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 ) { @@ -13396,7 +13837,7 @@ else if ( (LA83_0==Apostrophe) ) { // $ANTLR start "entryRuleUnindexedReference" - // InternalBehaviorAnnexParser.g:4666:1: entryRuleUnindexedReference returns [EObject current=null] : iv_ruleUnindexedReference= ruleUnindexedReference EOF ; + // InternalBehaviorAnnexParser.g:4761:1: entryRuleUnindexedReference returns [EObject current=null] : iv_ruleUnindexedReference= ruleUnindexedReference EOF ; public final EObject entryRuleUnindexedReference() throws RecognitionException { EObject current = null; @@ -13404,8 +13845,8 @@ public final EObject entryRuleUnindexedReference() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4666:59: (iv_ruleUnindexedReference= ruleUnindexedReference EOF ) - // InternalBehaviorAnnexParser.g:4667:2: iv_ruleUnindexedReference= ruleUnindexedReference EOF + // InternalBehaviorAnnexParser.g:4761:59: (iv_ruleUnindexedReference= ruleUnindexedReference EOF ) + // InternalBehaviorAnnexParser.g:4762:2: iv_ruleUnindexedReference= ruleUnindexedReference EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceRule()); @@ -13436,7 +13877,7 @@ public final EObject entryRuleUnindexedReference() throws RecognitionException { // $ANTLR start "ruleUnindexedReference" - // InternalBehaviorAnnexParser.g:4673:1: ruleUnindexedReference returns [EObject current=null] : ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) ; + // InternalBehaviorAnnexParser.g:4768: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; @@ -13449,24 +13890,24 @@ public final EObject ruleUnindexedReference() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4679:2: ( ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) ) - // InternalBehaviorAnnexParser.g:4680:2: ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) + // 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:4680:2: ( ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* ) - // InternalBehaviorAnnexParser.g:4681:3: ( (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:4681:3: ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:4682:4: (lv_segments_0_0= ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:4776:3: ( (lv_segments_0_0= ruleUnindexedReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:4777:4: (lv_segments_0_0= ruleUnindexedReferenceSegment ) { - // InternalBehaviorAnnexParser.g:4682:4: (lv_segments_0_0= ruleUnindexedReferenceSegment ) - // InternalBehaviorAnnexParser.g:4683:5: lv_segments_0_0= ruleUnindexedReferenceSegment + // InternalBehaviorAnnexParser.g:4777:4: (lv_segments_0_0= ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:4778:5: lv_segments_0_0= ruleUnindexedReferenceSegment { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceAccess().getSegmentsUnindexedReferenceSegmentParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_74); + pushFollow(FollowSets000.FOLLOW_76); lv_segments_0_0=ruleUnindexedReferenceSegment(); state._fsp--; @@ -13490,30 +13931,30 @@ public final EObject ruleUnindexedReference() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4700:3: ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* - loop84: + // InternalBehaviorAnnexParser.g:4795:3: ( (lv_tails_1_0= ruleUnindexedReferenceTail ) )* + loop86: do { - int alt84=2; - int LA84_0 = input.LA(1); + int alt86=2; + int LA86_0 = input.LA(1); - if ( (LA84_0==ColonColon||LA84_0==FullStop) ) { - alt84=1; + if ( (LA86_0==ColonColon||LA86_0==FullStop) ) { + alt86=1; } - switch (alt84) { + switch (alt86) { case 1 : - // InternalBehaviorAnnexParser.g:4701:4: (lv_tails_1_0= ruleUnindexedReferenceTail ) + // InternalBehaviorAnnexParser.g:4796:4: (lv_tails_1_0= ruleUnindexedReferenceTail ) { - // InternalBehaviorAnnexParser.g:4701:4: (lv_tails_1_0= ruleUnindexedReferenceTail ) - // InternalBehaviorAnnexParser.g:4702:5: lv_tails_1_0= ruleUnindexedReferenceTail + // InternalBehaviorAnnexParser.g:4796:4: (lv_tails_1_0= ruleUnindexedReferenceTail ) + // InternalBehaviorAnnexParser.g:4797:5: lv_tails_1_0= ruleUnindexedReferenceTail { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceAccess().getTailsUnindexedReferenceTailParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_74); + pushFollow(FollowSets000.FOLLOW_76); lv_tails_1_0=ruleUnindexedReferenceTail(); state._fsp--; @@ -13539,7 +13980,7 @@ public final EObject ruleUnindexedReference() throws RecognitionException { break; default : - break loop84; + break loop86; } } while (true); @@ -13568,7 +14009,7 @@ public final EObject ruleUnindexedReference() throws RecognitionException { // $ANTLR start "entryRuleUnindexedReferenceTail" - // InternalBehaviorAnnexParser.g:4723:1: entryRuleUnindexedReferenceTail returns [EObject current=null] : iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF ; + // InternalBehaviorAnnexParser.g:4818:1: entryRuleUnindexedReferenceTail returns [EObject current=null] : iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF ; public final EObject entryRuleUnindexedReferenceTail() throws RecognitionException { EObject current = null; @@ -13576,8 +14017,8 @@ public final EObject entryRuleUnindexedReferenceTail() throws RecognitionExcepti try { - // InternalBehaviorAnnexParser.g:4723:63: (iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF ) - // InternalBehaviorAnnexParser.g:4724:2: iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF + // InternalBehaviorAnnexParser.g:4818:63: (iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF ) + // InternalBehaviorAnnexParser.g:4819:2: iv_ruleUnindexedReferenceTail= ruleUnindexedReferenceTail EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceTailRule()); @@ -13608,7 +14049,7 @@ public final EObject entryRuleUnindexedReferenceTail() throws RecognitionExcepti // $ANTLR start "ruleUnindexedReferenceTail" - // InternalBehaviorAnnexParser.g:4730:1: ruleUnindexedReferenceTail returns [EObject current=null] : ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) ; + // InternalBehaviorAnnexParser.g:4825: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; @@ -13621,24 +14062,24 @@ public final EObject ruleUnindexedReferenceTail() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4736:2: ( ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) ) - // InternalBehaviorAnnexParser.g:4737:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) + // 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:4737:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) ) - // InternalBehaviorAnnexParser.g:4738:3: ( (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:4738:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) - // InternalBehaviorAnnexParser.g:4739:4: (lv_separator_0_0= ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:4833:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) + // InternalBehaviorAnnexParser.g:4834:4: (lv_separator_0_0= ruleReferenceSeparator ) { - // InternalBehaviorAnnexParser.g:4739:4: (lv_separator_0_0= ruleReferenceSeparator ) - // InternalBehaviorAnnexParser.g:4740:5: lv_separator_0_0= ruleReferenceSeparator + // InternalBehaviorAnnexParser.g:4834:4: (lv_separator_0_0= ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:4835:5: lv_separator_0_0= ruleReferenceSeparator { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceTailAccess().getSeparatorReferenceSeparatorParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_72); + pushFollow(FollowSets000.FOLLOW_74); lv_separator_0_0=ruleReferenceSeparator(); state._fsp--; @@ -13662,11 +14103,11 @@ public final EObject ruleUnindexedReferenceTail() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4757:3: ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:4758:4: (lv_segment_1_0= ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:4852:3: ( (lv_segment_1_0= ruleUnindexedReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:4853:4: (lv_segment_1_0= ruleUnindexedReferenceSegment ) { - // InternalBehaviorAnnexParser.g:4758:4: (lv_segment_1_0= ruleUnindexedReferenceSegment ) - // InternalBehaviorAnnexParser.g:4759:5: lv_segment_1_0= ruleUnindexedReferenceSegment + // InternalBehaviorAnnexParser.g:4853:4: (lv_segment_1_0= ruleUnindexedReferenceSegment ) + // InternalBehaviorAnnexParser.g:4854:5: lv_segment_1_0= ruleUnindexedReferenceSegment { if ( state.backtracking==0 ) { @@ -13722,7 +14163,7 @@ public final EObject ruleUnindexedReferenceTail() throws RecognitionException { // $ANTLR start "entryRuleUnindexedReferenceSegment" - // InternalBehaviorAnnexParser.g:4780:1: entryRuleUnindexedReferenceSegment returns [EObject current=null] : iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF ; + // InternalBehaviorAnnexParser.g:4875:1: entryRuleUnindexedReferenceSegment returns [EObject current=null] : iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF ; public final EObject entryRuleUnindexedReferenceSegment() throws RecognitionException { EObject current = null; @@ -13730,8 +14171,8 @@ public final EObject entryRuleUnindexedReferenceSegment() throws RecognitionExce try { - // InternalBehaviorAnnexParser.g:4780:66: (iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF ) - // InternalBehaviorAnnexParser.g:4781:2: iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF + // InternalBehaviorAnnexParser.g:4875:66: (iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF ) + // InternalBehaviorAnnexParser.g:4876:2: iv_ruleUnindexedReferenceSegment= ruleUnindexedReferenceSegment EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getUnindexedReferenceSegmentRule()); @@ -13762,7 +14203,7 @@ public final EObject entryRuleUnindexedReferenceSegment() throws RecognitionExce // $ANTLR start "ruleUnindexedReferenceSegment" - // InternalBehaviorAnnexParser.g:4787:1: ruleUnindexedReferenceSegment returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; + // InternalBehaviorAnnexParser.g:4882:1: ruleUnindexedReferenceSegment returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; public final EObject ruleUnindexedReferenceSegment() throws RecognitionException { EObject current = null; @@ -13772,14 +14213,14 @@ public final EObject ruleUnindexedReferenceSegment() throws RecognitionException enterRule(); try { - // InternalBehaviorAnnexParser.g:4793:2: ( ( (lv_name_0_0= RULE_ID ) ) ) - // InternalBehaviorAnnexParser.g:4794:2: ( (lv_name_0_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:4888:2: ( ( (lv_name_0_0= RULE_ID ) ) ) + // InternalBehaviorAnnexParser.g:4889:2: ( (lv_name_0_0= RULE_ID ) ) { - // InternalBehaviorAnnexParser.g:4794:2: ( (lv_name_0_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:4795:3: (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:4795:3: (lv_name_0_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:4796:4: 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 { lv_name_0_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -13827,7 +14268,7 @@ public final EObject ruleUnindexedReferenceSegment() throws RecognitionException // $ANTLR start "entryRuleQualifiedName" - // InternalBehaviorAnnexParser.g:4815:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; + // InternalBehaviorAnnexParser.g:4910:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; public final String entryRuleQualifiedName() throws RecognitionException { String current = null; @@ -13835,8 +14276,8 @@ public final String entryRuleQualifiedName() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4815:53: (iv_ruleQualifiedName= ruleQualifiedName EOF ) - // InternalBehaviorAnnexParser.g:4816:2: iv_ruleQualifiedName= ruleQualifiedName EOF + // InternalBehaviorAnnexParser.g:4910:53: (iv_ruleQualifiedName= ruleQualifiedName EOF ) + // InternalBehaviorAnnexParser.g:4911:2: iv_ruleQualifiedName= ruleQualifiedName EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getQualifiedNameRule()); @@ -13867,7 +14308,7 @@ public final String entryRuleQualifiedName() throws RecognitionException { // $ANTLR start "ruleQualifiedName" - // InternalBehaviorAnnexParser.g:4822:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) ; + // InternalBehaviorAnnexParser.g:4917: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(); @@ -13879,13 +14320,13 @@ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionExcept enterRule(); try { - // InternalBehaviorAnnexParser.g:4828:2: ( (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) ) - // InternalBehaviorAnnexParser.g:4829:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) + // 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:4829:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )* ) - // InternalBehaviorAnnexParser.g:4830:3: 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 )* { - this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_75); if (state.failed) return current; + this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_77); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(this_ID_0); @@ -13896,20 +14337,20 @@ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionExcept newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); } - // InternalBehaviorAnnexParser.g:4837:3: (kw= ColonColon this_ID_2= RULE_ID )* - loop85: + // InternalBehaviorAnnexParser.g:4932:3: (kw= ColonColon this_ID_2= RULE_ID )* + loop87: do { - int alt85=2; - int LA85_0 = input.LA(1); + int alt87=2; + int LA87_0 = input.LA(1); - if ( (LA85_0==ColonColon) ) { - alt85=1; + if ( (LA87_0==ColonColon) ) { + alt87=1; } - switch (alt85) { + switch (alt87) { case 1 : - // InternalBehaviorAnnexParser.g:4838:4: kw= ColonColon this_ID_2= RULE_ID + // InternalBehaviorAnnexParser.g:4933: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 ) { @@ -13918,7 +14359,7 @@ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionExcept newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); } - this_ID_2=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_75); if (state.failed) return current; + this_ID_2=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_77); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(this_ID_2); @@ -13934,7 +14375,7 @@ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionExcept break; default : - break loop85; + break loop87; } } while (true); @@ -13963,7 +14404,7 @@ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionExcept // $ANTLR start "entryRuleReference" - // InternalBehaviorAnnexParser.g:4855:1: entryRuleReference returns [EObject current=null] : iv_ruleReference= ruleReference EOF ; + // InternalBehaviorAnnexParser.g:4950:1: entryRuleReference returns [EObject current=null] : iv_ruleReference= ruleReference EOF ; public final EObject entryRuleReference() throws RecognitionException { EObject current = null; @@ -13971,8 +14412,8 @@ public final EObject entryRuleReference() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4855:50: (iv_ruleReference= ruleReference EOF ) - // InternalBehaviorAnnexParser.g:4856:2: iv_ruleReference= ruleReference EOF + // InternalBehaviorAnnexParser.g:4950:50: (iv_ruleReference= ruleReference EOF ) + // InternalBehaviorAnnexParser.g:4951:2: iv_ruleReference= ruleReference EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceRule()); @@ -14003,7 +14444,7 @@ public final EObject entryRuleReference() throws RecognitionException { // $ANTLR start "ruleReference" - // InternalBehaviorAnnexParser.g:4862:1: ruleReference returns [EObject current=null] : ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) ; + // InternalBehaviorAnnexParser.g:4957: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; @@ -14016,24 +14457,24 @@ public final EObject ruleReference() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4868:2: ( ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) ) - // InternalBehaviorAnnexParser.g:4869:2: ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) + // 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:4869:2: ( ( (lv_segments_0_0= ruleReferenceSegment ) ) ( (lv_tails_1_0= ruleReferenceTail ) )* ) - // InternalBehaviorAnnexParser.g:4870:3: ( (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:4870:3: ( (lv_segments_0_0= ruleReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:4871:4: (lv_segments_0_0= ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:4965:3: ( (lv_segments_0_0= ruleReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:4966:4: (lv_segments_0_0= ruleReferenceSegment ) { - // InternalBehaviorAnnexParser.g:4871:4: (lv_segments_0_0= ruleReferenceSegment ) - // InternalBehaviorAnnexParser.g:4872:5: lv_segments_0_0= ruleReferenceSegment + // InternalBehaviorAnnexParser.g:4966:4: (lv_segments_0_0= ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:4967:5: lv_segments_0_0= ruleReferenceSegment { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceAccess().getSegmentsReferenceSegmentParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_74); + pushFollow(FollowSets000.FOLLOW_76); lv_segments_0_0=ruleReferenceSegment(); state._fsp--; @@ -14057,30 +14498,30 @@ public final EObject ruleReference() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4889:3: ( (lv_tails_1_0= ruleReferenceTail ) )* - loop86: + // InternalBehaviorAnnexParser.g:4984:3: ( (lv_tails_1_0= ruleReferenceTail ) )* + loop88: do { - int alt86=2; - int LA86_0 = input.LA(1); + int alt88=2; + int LA88_0 = input.LA(1); - if ( (LA86_0==ColonColon||LA86_0==FullStop) ) { - alt86=1; + if ( (LA88_0==ColonColon||LA88_0==FullStop) ) { + alt88=1; } - switch (alt86) { + switch (alt88) { case 1 : - // InternalBehaviorAnnexParser.g:4890:4: (lv_tails_1_0= ruleReferenceTail ) + // InternalBehaviorAnnexParser.g:4985:4: (lv_tails_1_0= ruleReferenceTail ) { - // InternalBehaviorAnnexParser.g:4890:4: (lv_tails_1_0= ruleReferenceTail ) - // InternalBehaviorAnnexParser.g:4891:5: lv_tails_1_0= ruleReferenceTail + // InternalBehaviorAnnexParser.g:4985:4: (lv_tails_1_0= ruleReferenceTail ) + // InternalBehaviorAnnexParser.g:4986:5: lv_tails_1_0= ruleReferenceTail { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceAccess().getTailsReferenceTailParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_74); + pushFollow(FollowSets000.FOLLOW_76); lv_tails_1_0=ruleReferenceTail(); state._fsp--; @@ -14106,7 +14547,7 @@ public final EObject ruleReference() throws RecognitionException { break; default : - break loop86; + break loop88; } } while (true); @@ -14135,7 +14576,7 @@ public final EObject ruleReference() throws RecognitionException { // $ANTLR start "entryRuleReferenceTail" - // InternalBehaviorAnnexParser.g:4912:1: entryRuleReferenceTail returns [EObject current=null] : iv_ruleReferenceTail= ruleReferenceTail EOF ; + // InternalBehaviorAnnexParser.g:5007:1: entryRuleReferenceTail returns [EObject current=null] : iv_ruleReferenceTail= ruleReferenceTail EOF ; public final EObject entryRuleReferenceTail() throws RecognitionException { EObject current = null; @@ -14143,8 +14584,8 @@ public final EObject entryRuleReferenceTail() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4912:54: (iv_ruleReferenceTail= ruleReferenceTail EOF ) - // InternalBehaviorAnnexParser.g:4913:2: iv_ruleReferenceTail= ruleReferenceTail EOF + // InternalBehaviorAnnexParser.g:5007:54: (iv_ruleReferenceTail= ruleReferenceTail EOF ) + // InternalBehaviorAnnexParser.g:5008:2: iv_ruleReferenceTail= ruleReferenceTail EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceTailRule()); @@ -14175,7 +14616,7 @@ public final EObject entryRuleReferenceTail() throws RecognitionException { // $ANTLR start "ruleReferenceTail" - // InternalBehaviorAnnexParser.g:4919:1: ruleReferenceTail returns [EObject current=null] : ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) ; + // InternalBehaviorAnnexParser.g:5014: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; @@ -14188,17 +14629,17 @@ public final EObject ruleReferenceTail() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:4925:2: ( ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) ) - // InternalBehaviorAnnexParser.g:4926:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) + // 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:4926:2: ( ( (lv_separator_0_0= ruleReferenceSeparator ) ) ( (lv_segment_1_0= ruleReferenceSegment ) ) ) - // InternalBehaviorAnnexParser.g:4927:3: ( (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:4927:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) - // InternalBehaviorAnnexParser.g:4928:4: (lv_separator_0_0= ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:5022:3: ( (lv_separator_0_0= ruleReferenceSeparator ) ) + // InternalBehaviorAnnexParser.g:5023:4: (lv_separator_0_0= ruleReferenceSeparator ) { - // InternalBehaviorAnnexParser.g:4928:4: (lv_separator_0_0= ruleReferenceSeparator ) - // InternalBehaviorAnnexParser.g:4929:5: lv_separator_0_0= ruleReferenceSeparator + // InternalBehaviorAnnexParser.g:5023:4: (lv_separator_0_0= ruleReferenceSeparator ) + // InternalBehaviorAnnexParser.g:5024:5: lv_separator_0_0= ruleReferenceSeparator { if ( state.backtracking==0 ) { @@ -14229,11 +14670,11 @@ public final EObject ruleReferenceTail() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:4946:3: ( (lv_segment_1_0= ruleReferenceSegment ) ) - // InternalBehaviorAnnexParser.g:4947:4: (lv_segment_1_0= ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:5041:3: ( (lv_segment_1_0= ruleReferenceSegment ) ) + // InternalBehaviorAnnexParser.g:5042:4: (lv_segment_1_0= ruleReferenceSegment ) { - // InternalBehaviorAnnexParser.g:4947:4: (lv_segment_1_0= ruleReferenceSegment ) - // InternalBehaviorAnnexParser.g:4948:5: lv_segment_1_0= ruleReferenceSegment + // InternalBehaviorAnnexParser.g:5042:4: (lv_segment_1_0= ruleReferenceSegment ) + // InternalBehaviorAnnexParser.g:5043:5: lv_segment_1_0= ruleReferenceSegment { if ( state.backtracking==0 ) { @@ -14289,7 +14730,7 @@ public final EObject ruleReferenceTail() throws RecognitionException { // $ANTLR start "entryRuleReferenceSeparator" - // InternalBehaviorAnnexParser.g:4969:1: entryRuleReferenceSeparator returns [String current=null] : iv_ruleReferenceSeparator= ruleReferenceSeparator EOF ; + // InternalBehaviorAnnexParser.g:5064:1: entryRuleReferenceSeparator returns [String current=null] : iv_ruleReferenceSeparator= ruleReferenceSeparator EOF ; public final String entryRuleReferenceSeparator() throws RecognitionException { String current = null; @@ -14297,8 +14738,8 @@ public final String entryRuleReferenceSeparator() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4969:58: (iv_ruleReferenceSeparator= ruleReferenceSeparator EOF ) - // InternalBehaviorAnnexParser.g:4970:2: iv_ruleReferenceSeparator= ruleReferenceSeparator EOF + // InternalBehaviorAnnexParser.g:5064:58: (iv_ruleReferenceSeparator= ruleReferenceSeparator EOF ) + // InternalBehaviorAnnexParser.g:5065:2: iv_ruleReferenceSeparator= ruleReferenceSeparator EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceSeparatorRule()); @@ -14329,7 +14770,7 @@ public final String entryRuleReferenceSeparator() throws RecognitionException { // $ANTLR start "ruleReferenceSeparator" - // InternalBehaviorAnnexParser.g:4976:1: ruleReferenceSeparator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= ColonColon | kw= FullStop ) ; + // InternalBehaviorAnnexParser.g:5071:1: ruleReferenceSeparator returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= ColonColon | kw= FullStop ) ; public final AntlrDatatypeRuleToken ruleReferenceSeparator() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -14339,29 +14780,29 @@ public final AntlrDatatypeRuleToken ruleReferenceSeparator() throws RecognitionE enterRule(); try { - // InternalBehaviorAnnexParser.g:4982:2: ( (kw= ColonColon | kw= FullStop ) ) - // InternalBehaviorAnnexParser.g:4983:2: (kw= ColonColon | kw= FullStop ) + // InternalBehaviorAnnexParser.g:5077:2: ( (kw= ColonColon | kw= FullStop ) ) + // InternalBehaviorAnnexParser.g:5078:2: (kw= ColonColon | kw= FullStop ) { - // InternalBehaviorAnnexParser.g:4983:2: (kw= ColonColon | kw= FullStop ) - int alt87=2; - int LA87_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5078:2: (kw= ColonColon | kw= FullStop ) + int alt89=2; + int LA89_0 = input.LA(1); - if ( (LA87_0==ColonColon) ) { - alt87=1; + if ( (LA89_0==ColonColon) ) { + alt89=1; } - else if ( (LA87_0==FullStop) ) { - alt87=2; + else if ( (LA89_0==FullStop) ) { + alt89=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 87, 0, input); + new NoViableAltException("", 89, 0, input); throw nvae; } - switch (alt87) { + switch (alt89) { case 1 : - // InternalBehaviorAnnexParser.g:4984:3: kw= ColonColon + // InternalBehaviorAnnexParser.g:5079:3: kw= ColonColon { kw=(Token)match(input,ColonColon,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -14374,7 +14815,7 @@ else if ( (LA87_0==FullStop) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:4990:3: kw= FullStop + // InternalBehaviorAnnexParser.g:5085:3: kw= FullStop { kw=(Token)match(input,FullStop,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -14411,7 +14852,7 @@ else if ( (LA87_0==FullStop) ) { // $ANTLR start "entryRuleReferenceSegment" - // InternalBehaviorAnnexParser.g:4999:1: entryRuleReferenceSegment returns [EObject current=null] : iv_ruleReferenceSegment= ruleReferenceSegment EOF ; + // InternalBehaviorAnnexParser.g:5094:1: entryRuleReferenceSegment returns [EObject current=null] : iv_ruleReferenceSegment= ruleReferenceSegment EOF ; public final EObject entryRuleReferenceSegment() throws RecognitionException { EObject current = null; @@ -14419,8 +14860,8 @@ public final EObject entryRuleReferenceSegment() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:4999:57: (iv_ruleReferenceSegment= ruleReferenceSegment EOF ) - // InternalBehaviorAnnexParser.g:5000:2: iv_ruleReferenceSegment= ruleReferenceSegment EOF + // InternalBehaviorAnnexParser.g:5094:57: (iv_ruleReferenceSegment= ruleReferenceSegment EOF ) + // InternalBehaviorAnnexParser.g:5095:2: iv_ruleReferenceSegment= ruleReferenceSegment EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceSegmentRule()); @@ -14451,7 +14892,7 @@ public final EObject entryRuleReferenceSegment() throws RecognitionException { // $ANTLR start "ruleReferenceSegment" - // InternalBehaviorAnnexParser.g:5006:1: ruleReferenceSegment returns [EObject current=null] : ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) ; + // InternalBehaviorAnnexParser.g:5101: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; @@ -14463,17 +14904,17 @@ public final EObject ruleReferenceSegment() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5012:2: ( ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) ) - // InternalBehaviorAnnexParser.g:5013:2: ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) + // 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:5013:2: ( ( (lv_name_0_0= RULE_ID ) ) ( (lv_indexes_1_0= ruleArrayIndex ) )* ) - // InternalBehaviorAnnexParser.g:5014:3: ( (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:5014:3: ( (lv_name_0_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:5015:4: (lv_name_0_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:5109:3: ( (lv_name_0_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:5110:4: (lv_name_0_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:5015:4: (lv_name_0_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:5016:5: 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 { lv_name_0_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_13); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -14499,23 +14940,23 @@ public final EObject ruleReferenceSegment() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:5032:3: ( (lv_indexes_1_0= ruleArrayIndex ) )* - loop88: + // InternalBehaviorAnnexParser.g:5127:3: ( (lv_indexes_1_0= ruleArrayIndex ) )* + loop90: do { - int alt88=2; - int LA88_0 = input.LA(1); + int alt90=2; + int LA90_0 = input.LA(1); - if ( (LA88_0==LeftSquareBracket) ) { - alt88=1; + if ( (LA90_0==LeftSquareBracket) ) { + alt90=1; } - switch (alt88) { + switch (alt90) { case 1 : - // InternalBehaviorAnnexParser.g:5033:4: (lv_indexes_1_0= ruleArrayIndex ) + // InternalBehaviorAnnexParser.g:5128:4: (lv_indexes_1_0= ruleArrayIndex ) { - // InternalBehaviorAnnexParser.g:5033:4: (lv_indexes_1_0= ruleArrayIndex ) - // InternalBehaviorAnnexParser.g:5034:5: lv_indexes_1_0= ruleArrayIndex + // InternalBehaviorAnnexParser.g:5128:4: (lv_indexes_1_0= ruleArrayIndex ) + // InternalBehaviorAnnexParser.g:5129:5: lv_indexes_1_0= ruleArrayIndex { if ( state.backtracking==0 ) { @@ -14548,7 +14989,7 @@ public final EObject ruleReferenceSegment() throws RecognitionException { break; default : - break loop88; + break loop90; } } while (true); @@ -14577,7 +15018,7 @@ public final EObject ruleReferenceSegment() throws RecognitionException { // $ANTLR start "entryRuleArrayIndex" - // InternalBehaviorAnnexParser.g:5055:1: entryRuleArrayIndex returns [EObject current=null] : iv_ruleArrayIndex= ruleArrayIndex EOF ; + // InternalBehaviorAnnexParser.g:5150:1: entryRuleArrayIndex returns [EObject current=null] : iv_ruleArrayIndex= ruleArrayIndex EOF ; public final EObject entryRuleArrayIndex() throws RecognitionException { EObject current = null; @@ -14585,8 +15026,8 @@ public final EObject entryRuleArrayIndex() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5055:51: (iv_ruleArrayIndex= ruleArrayIndex EOF ) - // InternalBehaviorAnnexParser.g:5056:2: iv_ruleArrayIndex= ruleArrayIndex EOF + // InternalBehaviorAnnexParser.g:5150:51: (iv_ruleArrayIndex= ruleArrayIndex EOF ) + // InternalBehaviorAnnexParser.g:5151:2: iv_ruleArrayIndex= ruleArrayIndex EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getArrayIndexRule()); @@ -14617,7 +15058,7 @@ public final EObject entryRuleArrayIndex() throws RecognitionException { // $ANTLR start "ruleArrayIndex" - // InternalBehaviorAnnexParser.g:5062:1: ruleArrayIndex returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:5157: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; @@ -14630,11 +15071,11 @@ public final EObject ruleArrayIndex() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5068:2: ( (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:5069:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) + // 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:5069:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleIntegerValue ) ) otherlv_2= RightSquareBracket ) - // InternalBehaviorAnnexParser.g:5070:3: 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 { otherlv_0=(Token)match(input,LeftSquareBracket,FollowSets000.FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -14642,11 +15083,11 @@ public final EObject ruleArrayIndex() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getArrayIndexAccess().getLeftSquareBracketKeyword_0()); } - // InternalBehaviorAnnexParser.g:5074:3: ( (lv_value_1_0= ruleIntegerValue ) ) - // InternalBehaviorAnnexParser.g:5075:4: (lv_value_1_0= ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:5169:3: ( (lv_value_1_0= ruleIntegerValue ) ) + // InternalBehaviorAnnexParser.g:5170:4: (lv_value_1_0= ruleIntegerValue ) { - // InternalBehaviorAnnexParser.g:5075:4: (lv_value_1_0= ruleIntegerValue ) - // InternalBehaviorAnnexParser.g:5076:5: lv_value_1_0= ruleIntegerValue + // InternalBehaviorAnnexParser.g:5170:4: (lv_value_1_0= ruleIntegerValue ) + // InternalBehaviorAnnexParser.g:5171:5: lv_value_1_0= ruleIntegerValue { if ( state.backtracking==0 ) { @@ -14708,7 +15149,7 @@ public final EObject ruleArrayIndex() throws RecognitionException { // $ANTLR start "entryRuleContainedPropertyAssociation" - // InternalBehaviorAnnexParser.g:5101:1: entryRuleContainedPropertyAssociation returns [EObject current=null] : iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF ; + // InternalBehaviorAnnexParser.g:5196:1: entryRuleContainedPropertyAssociation returns [EObject current=null] : iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF ; public final EObject entryRuleContainedPropertyAssociation() throws RecognitionException { EObject current = null; @@ -14716,8 +15157,8 @@ public final EObject entryRuleContainedPropertyAssociation() throws RecognitionE try { - // InternalBehaviorAnnexParser.g:5101:69: (iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF ) - // InternalBehaviorAnnexParser.g:5102:2: iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF + // InternalBehaviorAnnexParser.g:5196:69: (iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF ) + // InternalBehaviorAnnexParser.g:5197:2: iv_ruleContainedPropertyAssociation= ruleContainedPropertyAssociation EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainedPropertyAssociationRule()); @@ -14748,7 +15189,7 @@ public final EObject entryRuleContainedPropertyAssociation() throws RecognitionE // $ANTLR start "ruleContainedPropertyAssociation" - // InternalBehaviorAnnexParser.g:5108: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: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 ) ; public final EObject ruleContainedPropertyAssociation() throws RecognitionException { EObject current = null; @@ -14777,17 +15218,17 @@ public final EObject ruleContainedPropertyAssociation() throws RecognitionExcept enterRule(); try { - // InternalBehaviorAnnexParser.g:5114: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:5115: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: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:5115: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:5116: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: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:5116:3: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:5117:4: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5211:3: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:5212:4: ( ruleQPREF ) { - // InternalBehaviorAnnexParser.g:5117:4: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:5118:5: ruleQPREF + // InternalBehaviorAnnexParser.g:5212:4: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5213:5: ruleQPREF { if ( state.backtracking==0 ) { @@ -14801,7 +15242,7 @@ public final EObject ruleContainedPropertyAssociation() throws RecognitionExcept newCompositeNode(grammarAccess.getContainedPropertyAssociationAccess().getPropertyPropertyCrossReference_0_0()); } - pushFollow(FollowSets000.FOLLOW_76); + pushFollow(FollowSets000.FOLLOW_78); ruleQPREF(); state._fsp--; @@ -14817,28 +15258,28 @@ public final EObject ruleContainedPropertyAssociation() throws RecognitionExcept } - // InternalBehaviorAnnexParser.g:5132:3: (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) - int alt89=2; - int LA89_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5227:3: (otherlv_1= EqualsSignGreaterThanSign | ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) ) + int alt91=2; + int LA91_0 = input.LA(1); - if ( (LA89_0==EqualsSignGreaterThanSign) ) { - alt89=1; + if ( (LA91_0==EqualsSignGreaterThanSign) ) { + alt91=1; } - else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { - alt89=2; + else if ( (LA91_0==PlusSignEqualsSignGreaterThanSign) ) { + alt91=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 89, 0, input); + new NoViableAltException("", 91, 0, input); throw nvae; } - switch (alt89) { + switch (alt91) { case 1 : - // InternalBehaviorAnnexParser.g:5133:4: otherlv_1= EqualsSignGreaterThanSign + // InternalBehaviorAnnexParser.g:5228:4: otherlv_1= EqualsSignGreaterThanSign { - otherlv_1=(Token)match(input,EqualsSignGreaterThanSign,FollowSets000.FOLLOW_77); if (state.failed) return current; + otherlv_1=(Token)match(input,EqualsSignGreaterThanSign,FollowSets000.FOLLOW_79); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getContainedPropertyAssociationAccess().getEqualsSignGreaterThanSignKeyword_1_0()); @@ -14848,15 +15289,15 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:5138:4: ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) + // InternalBehaviorAnnexParser.g:5233:4: ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) { - // InternalBehaviorAnnexParser.g:5138:4: ( (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) ) - // InternalBehaviorAnnexParser.g:5139:5: (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:5139:5: (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) - // InternalBehaviorAnnexParser.g:5140:6: lv_append_2_0= PlusSignEqualsSignGreaterThanSign + // InternalBehaviorAnnexParser.g:5234:5: (lv_append_2_0= PlusSignEqualsSignGreaterThanSign ) + // InternalBehaviorAnnexParser.g:5235:6: lv_append_2_0= PlusSignEqualsSignGreaterThanSign { - lv_append_2_0=(Token)match(input,PlusSignEqualsSignGreaterThanSign,FollowSets000.FOLLOW_77); if (state.failed) return current; + lv_append_2_0=(Token)match(input,PlusSignEqualsSignGreaterThanSign,FollowSets000.FOLLOW_79); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_append_2_0, grammarAccess.getContainedPropertyAssociationAccess().getAppendPlusSignEqualsSignGreaterThanSignKeyword_1_1_0()); @@ -14882,21 +15323,21 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { } - // InternalBehaviorAnnexParser.g:5153:3: ( (lv_constant_3_0= Constant ) )? - int alt90=2; - int LA90_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5248:3: ( (lv_constant_3_0= Constant ) )? + int alt92=2; + int LA92_0 = input.LA(1); - if ( (LA90_0==Constant) ) { - alt90=1; + if ( (LA92_0==Constant) ) { + alt92=1; } - switch (alt90) { + switch (alt92) { case 1 : - // InternalBehaviorAnnexParser.g:5154:4: (lv_constant_3_0= Constant ) + // InternalBehaviorAnnexParser.g:5249:4: (lv_constant_3_0= Constant ) { - // InternalBehaviorAnnexParser.g:5154:4: (lv_constant_3_0= Constant ) - // InternalBehaviorAnnexParser.g:5155:5: lv_constant_3_0= Constant + // InternalBehaviorAnnexParser.g:5249:4: (lv_constant_3_0= Constant ) + // InternalBehaviorAnnexParser.g:5250:5: lv_constant_3_0= Constant { - lv_constant_3_0=(Token)match(input,Constant,FollowSets000.FOLLOW_77); if (state.failed) return current; + lv_constant_3_0=(Token)match(input,Constant,FollowSets000.FOLLOW_79); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_constant_3_0, grammarAccess.getContainedPropertyAssociationAccess().getConstantConstantKeyword_2_0()); @@ -14919,21 +15360,21 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { } - // InternalBehaviorAnnexParser.g:5167:3: ( ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* ) - // InternalBehaviorAnnexParser.g:5168:4: ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* + // 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:5168:4: ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) - // InternalBehaviorAnnexParser.g:5169:5: (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:5263:4: ( (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) ) + // InternalBehaviorAnnexParser.g:5264:5: (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) { - // InternalBehaviorAnnexParser.g:5169:5: (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) - // InternalBehaviorAnnexParser.g:5170:6: lv_ownedValue_4_0= ruleOptionalModalPropertyValue + // InternalBehaviorAnnexParser.g:5264:5: (lv_ownedValue_4_0= ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:5265:6: lv_ownedValue_4_0= ruleOptionalModalPropertyValue { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueOptionalModalPropertyValueParserRuleCall_3_0_0()); } - pushFollow(FollowSets000.FOLLOW_78); + pushFollow(FollowSets000.FOLLOW_80); lv_ownedValue_4_0=ruleOptionalModalPropertyValue(); state._fsp--; @@ -14957,39 +15398,39 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { } - // InternalBehaviorAnnexParser.g:5187:4: (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* - loop91: + // InternalBehaviorAnnexParser.g:5282:4: (otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) )* + loop93: do { - int alt91=2; - int LA91_0 = input.LA(1); + int alt93=2; + int LA93_0 = input.LA(1); - if ( (LA91_0==Comma) ) { - alt91=1; + if ( (LA93_0==Comma) ) { + alt93=1; } - switch (alt91) { + switch (alt93) { case 1 : - // InternalBehaviorAnnexParser.g:5188:5: otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) + // InternalBehaviorAnnexParser.g:5283:5: otherlv_5= Comma ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) { - otherlv_5=(Token)match(input,Comma,FollowSets000.FOLLOW_77); if (state.failed) return current; + otherlv_5=(Token)match(input,Comma,FollowSets000.FOLLOW_79); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getContainedPropertyAssociationAccess().getCommaKeyword_3_1_0()); } - // InternalBehaviorAnnexParser.g:5192:5: ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) - // InternalBehaviorAnnexParser.g:5193:6: (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:5287:5: ( (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) ) + // InternalBehaviorAnnexParser.g:5288:6: (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) { - // InternalBehaviorAnnexParser.g:5193:6: (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) - // InternalBehaviorAnnexParser.g:5194:7: lv_ownedValue_6_0= ruleOptionalModalPropertyValue + // InternalBehaviorAnnexParser.g:5288:6: (lv_ownedValue_6_0= ruleOptionalModalPropertyValue ) + // InternalBehaviorAnnexParser.g:5289:7: lv_ownedValue_6_0= ruleOptionalModalPropertyValue { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainedPropertyAssociationAccess().getOwnedValueOptionalModalPropertyValueParserRuleCall_3_1_1_0()); } - pushFollow(FollowSets000.FOLLOW_78); + pushFollow(FollowSets000.FOLLOW_80); lv_ownedValue_6_0=ruleOptionalModalPropertyValue(); state._fsp--; @@ -15018,25 +15459,25 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { break; default : - break loop91; + break loop93; } } while (true); } - // InternalBehaviorAnnexParser.g:5213:3: (otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* )? - int alt93=2; - int LA93_0 = input.LA(1); + // 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); - if ( (LA93_0==Applies) ) { - alt93=1; + if ( (LA95_0==Applies) ) { + alt95=1; } - switch (alt93) { + switch (alt95) { case 1 : - // InternalBehaviorAnnexParser.g:5214:4: otherlv_7= Applies otherlv_8= To ( (lv_appliesTo_9_0= ruleContainmentPath ) ) (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* + // InternalBehaviorAnnexParser.g:5309: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_79); if (state.failed) return current; + otherlv_7=(Token)match(input,Applies,FollowSets000.FOLLOW_81); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_7, grammarAccess.getContainedPropertyAssociationAccess().getAppliesKeyword_4_0()); @@ -15048,18 +15489,18 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { newLeafNode(otherlv_8, grammarAccess.getContainedPropertyAssociationAccess().getToKeyword_4_1()); } - // InternalBehaviorAnnexParser.g:5222:4: ( (lv_appliesTo_9_0= ruleContainmentPath ) ) - // InternalBehaviorAnnexParser.g:5223:5: (lv_appliesTo_9_0= ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:5317:4: ( (lv_appliesTo_9_0= ruleContainmentPath ) ) + // InternalBehaviorAnnexParser.g:5318:5: (lv_appliesTo_9_0= ruleContainmentPath ) { - // InternalBehaviorAnnexParser.g:5223:5: (lv_appliesTo_9_0= ruleContainmentPath ) - // InternalBehaviorAnnexParser.g:5224:6: lv_appliesTo_9_0= ruleContainmentPath + // InternalBehaviorAnnexParser.g:5318:5: (lv_appliesTo_9_0= ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:5319:6: lv_appliesTo_9_0= ruleContainmentPath { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToContainmentPathParserRuleCall_4_2_0()); } - pushFollow(FollowSets000.FOLLOW_80); + pushFollow(FollowSets000.FOLLOW_82); lv_appliesTo_9_0=ruleContainmentPath(); state._fsp--; @@ -15083,20 +15524,20 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { } - // InternalBehaviorAnnexParser.g:5241:4: (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* - loop92: + // InternalBehaviorAnnexParser.g:5336:4: (otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) )* + loop94: do { - int alt92=2; - int LA92_0 = input.LA(1); + int alt94=2; + int LA94_0 = input.LA(1); - if ( (LA92_0==Comma) ) { - alt92=1; + if ( (LA94_0==Comma) ) { + alt94=1; } - switch (alt92) { + switch (alt94) { case 1 : - // InternalBehaviorAnnexParser.g:5242:5: otherlv_10= Comma ( (lv_appliesTo_11_0= ruleContainmentPath ) ) + // InternalBehaviorAnnexParser.g:5337: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 ) { @@ -15104,18 +15545,18 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { newLeafNode(otherlv_10, grammarAccess.getContainedPropertyAssociationAccess().getCommaKeyword_4_3_0()); } - // InternalBehaviorAnnexParser.g:5246:5: ( (lv_appliesTo_11_0= ruleContainmentPath ) ) - // InternalBehaviorAnnexParser.g:5247:6: (lv_appliesTo_11_0= ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:5341:5: ( (lv_appliesTo_11_0= ruleContainmentPath ) ) + // InternalBehaviorAnnexParser.g:5342:6: (lv_appliesTo_11_0= ruleContainmentPath ) { - // InternalBehaviorAnnexParser.g:5247:6: (lv_appliesTo_11_0= ruleContainmentPath ) - // InternalBehaviorAnnexParser.g:5248:7: lv_appliesTo_11_0= ruleContainmentPath + // InternalBehaviorAnnexParser.g:5342:6: (lv_appliesTo_11_0= ruleContainmentPath ) + // InternalBehaviorAnnexParser.g:5343:7: lv_appliesTo_11_0= ruleContainmentPath { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainedPropertyAssociationAccess().getAppliesToContainmentPathParserRuleCall_4_3_1_0()); } - pushFollow(FollowSets000.FOLLOW_80); + pushFollow(FollowSets000.FOLLOW_82); lv_appliesTo_11_0=ruleContainmentPath(); state._fsp--; @@ -15144,7 +15585,7 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { break; default : - break loop92; + break loop94; } } while (true); @@ -15154,16 +15595,16 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { } - // InternalBehaviorAnnexParser.g:5267:3: (otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis )? - int alt94=2; - int LA94_0 = input.LA(1); + // 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); - if ( (LA94_0==In) ) { - alt94=1; + if ( (LA96_0==In) ) { + alt96=1; } - switch (alt94) { + switch (alt96) { case 1 : - // InternalBehaviorAnnexParser.g:5268:4: otherlv_12= In otherlv_13= Binding otherlv_14= LeftParenthesis ( ( ruleQCREF ) ) otherlv_16= RightParenthesis + // InternalBehaviorAnnexParser.g:5363: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 ) { @@ -15183,11 +15624,11 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { newLeafNode(otherlv_14, grammarAccess.getContainedPropertyAssociationAccess().getLeftParenthesisKeyword_5_2()); } - // InternalBehaviorAnnexParser.g:5280:4: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:5281:5: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:5375:4: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:5376:5: ( ruleQCREF ) { - // InternalBehaviorAnnexParser.g:5281:5: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:5282:6: ruleQCREF + // InternalBehaviorAnnexParser.g:5376:5: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:5377:6: ruleQCREF { if ( state.backtracking==0 ) { @@ -15260,7 +15701,7 @@ else if ( (LA89_0==PlusSignEqualsSignGreaterThanSign) ) { // $ANTLR start "entryRuleContainmentPath" - // InternalBehaviorAnnexParser.g:5309:1: entryRuleContainmentPath returns [EObject current=null] : iv_ruleContainmentPath= ruleContainmentPath EOF ; + // InternalBehaviorAnnexParser.g:5404:1: entryRuleContainmentPath returns [EObject current=null] : iv_ruleContainmentPath= ruleContainmentPath EOF ; public final EObject entryRuleContainmentPath() throws RecognitionException { EObject current = null; @@ -15268,8 +15709,8 @@ public final EObject entryRuleContainmentPath() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5309:56: (iv_ruleContainmentPath= ruleContainmentPath EOF ) - // InternalBehaviorAnnexParser.g:5310:2: iv_ruleContainmentPath= ruleContainmentPath EOF + // InternalBehaviorAnnexParser.g:5404:56: (iv_ruleContainmentPath= ruleContainmentPath EOF ) + // InternalBehaviorAnnexParser.g:5405:2: iv_ruleContainmentPath= ruleContainmentPath EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainmentPathRule()); @@ -15300,7 +15741,7 @@ public final EObject entryRuleContainmentPath() throws RecognitionException { // $ANTLR start "ruleContainmentPath" - // InternalBehaviorAnnexParser.g:5316:1: ruleContainmentPath returns [EObject current=null] : ( (lv_path_0_0= ruleContainmentPathElement ) ) ; + // InternalBehaviorAnnexParser.g:5411:1: ruleContainmentPath returns [EObject current=null] : ( (lv_path_0_0= ruleContainmentPathElement ) ) ; public final EObject ruleContainmentPath() throws RecognitionException { EObject current = null; @@ -15311,14 +15752,14 @@ public final EObject ruleContainmentPath() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5322:2: ( ( (lv_path_0_0= ruleContainmentPathElement ) ) ) - // InternalBehaviorAnnexParser.g:5323:2: ( (lv_path_0_0= ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:5417:2: ( ( (lv_path_0_0= ruleContainmentPathElement ) ) ) + // InternalBehaviorAnnexParser.g:5418:2: ( (lv_path_0_0= ruleContainmentPathElement ) ) { - // InternalBehaviorAnnexParser.g:5323:2: ( (lv_path_0_0= ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:5324:3: (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:5324:3: (lv_path_0_0= ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:5325:4: lv_path_0_0= ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:5419:3: (lv_path_0_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:5420:4: lv_path_0_0= ruleContainmentPathElement { if ( state.backtracking==0 ) { @@ -15371,7 +15812,7 @@ public final EObject ruleContainmentPath() throws RecognitionException { // $ANTLR start "entryRuleOptionalModalPropertyValue" - // InternalBehaviorAnnexParser.g:5345:1: entryRuleOptionalModalPropertyValue returns [EObject current=null] : iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF ; + // InternalBehaviorAnnexParser.g:5440:1: entryRuleOptionalModalPropertyValue returns [EObject current=null] : iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF ; public final EObject entryRuleOptionalModalPropertyValue() throws RecognitionException { EObject current = null; @@ -15379,8 +15820,8 @@ public final EObject entryRuleOptionalModalPropertyValue() throws RecognitionExc try { - // InternalBehaviorAnnexParser.g:5345:67: (iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF ) - // InternalBehaviorAnnexParser.g:5346:2: iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF + // InternalBehaviorAnnexParser.g:5440:67: (iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF ) + // InternalBehaviorAnnexParser.g:5441:2: iv_ruleOptionalModalPropertyValue= ruleOptionalModalPropertyValue EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getOptionalModalPropertyValueRule()); @@ -15411,7 +15852,7 @@ public final EObject entryRuleOptionalModalPropertyValue() throws RecognitionExc // $ANTLR start "ruleOptionalModalPropertyValue" - // InternalBehaviorAnnexParser.g:5352: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: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 )? ) ; public final EObject ruleOptionalModalPropertyValue() throws RecognitionException { EObject current = null; @@ -15429,17 +15870,17 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio enterRule(); try { - // InternalBehaviorAnnexParser.g:5358: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:5359: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: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:5359: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:5360: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: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:5360:3: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:5361:4: (lv_ownedValue_0_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:5455:3: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:5456:4: (lv_ownedValue_0_0= rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:5361:4: (lv_ownedValue_0_0= rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:5362:5: lv_ownedValue_0_0= rulePropertyExpression + // InternalBehaviorAnnexParser.g:5456:4: (lv_ownedValue_0_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:5457:5: lv_ownedValue_0_0= rulePropertyExpression { if ( state.backtracking==0 ) { @@ -15470,22 +15911,22 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio } - // InternalBehaviorAnnexParser.g:5379: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 alt96=2; - int LA96_0 = input.LA(1); + // 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); - if ( (LA96_0==In) ) { - int LA96_1 = input.LA(2); + if ( (LA98_0==In) ) { + int LA98_1 = input.LA(2); - if ( (LA96_1==Modes) ) { - alt96=1; + if ( (LA98_1==Modes) ) { + alt98=1; } } - switch (alt96) { + switch (alt98) { case 1 : - // InternalBehaviorAnnexParser.g:5380: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: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 { - otherlv_1=(Token)match(input,In,FollowSets000.FOLLOW_81); if (state.failed) return current; + otherlv_1=(Token)match(input,In,FollowSets000.FOLLOW_83); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getOptionalModalPropertyValueAccess().getInKeyword_1_0()); @@ -15503,11 +15944,11 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio newLeafNode(otherlv_3, grammarAccess.getOptionalModalPropertyValueAccess().getLeftParenthesisKeyword_1_2()); } - // InternalBehaviorAnnexParser.g:5392:4: ( (otherlv_4= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:5393:5: (otherlv_4= RULE_ID ) + // InternalBehaviorAnnexParser.g:5487:4: ( (otherlv_4= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:5488:5: (otherlv_4= RULE_ID ) { - // InternalBehaviorAnnexParser.g:5393:5: (otherlv_4= RULE_ID ) - // InternalBehaviorAnnexParser.g:5394:6: otherlv_4= RULE_ID + // InternalBehaviorAnnexParser.g:5488:5: (otherlv_4= RULE_ID ) + // InternalBehaviorAnnexParser.g:5489:6: otherlv_4= RULE_ID { if ( state.backtracking==0 ) { @@ -15528,20 +15969,20 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio } - // InternalBehaviorAnnexParser.g:5405:4: (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* - loop95: + // InternalBehaviorAnnexParser.g:5500:4: (otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) )* + loop97: do { - int alt95=2; - int LA95_0 = input.LA(1); + int alt97=2; + int LA97_0 = input.LA(1); - if ( (LA95_0==Comma) ) { - alt95=1; + if ( (LA97_0==Comma) ) { + alt97=1; } - switch (alt95) { + switch (alt97) { case 1 : - // InternalBehaviorAnnexParser.g:5406:5: otherlv_5= Comma ( (otherlv_6= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:5501: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 ) { @@ -15549,11 +15990,11 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio newLeafNode(otherlv_5, grammarAccess.getOptionalModalPropertyValueAccess().getCommaKeyword_1_4_0()); } - // InternalBehaviorAnnexParser.g:5410:5: ( (otherlv_6= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:5411:6: (otherlv_6= RULE_ID ) + // InternalBehaviorAnnexParser.g:5505:5: ( (otherlv_6= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:5506:6: (otherlv_6= RULE_ID ) { - // InternalBehaviorAnnexParser.g:5411:6: (otherlv_6= RULE_ID ) - // InternalBehaviorAnnexParser.g:5412:7: otherlv_6= RULE_ID + // InternalBehaviorAnnexParser.g:5506:6: (otherlv_6= RULE_ID ) + // InternalBehaviorAnnexParser.g:5507:7: otherlv_6= RULE_ID { if ( state.backtracking==0 ) { @@ -15579,7 +16020,7 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio break; default : - break loop95; + break loop97; } } while (true); @@ -15620,7 +16061,7 @@ public final EObject ruleOptionalModalPropertyValue() throws RecognitionExceptio // $ANTLR start "entryRulePropertyValue" - // InternalBehaviorAnnexParser.g:5433:1: entryRulePropertyValue returns [EObject current=null] : iv_rulePropertyValue= rulePropertyValue EOF ; + // InternalBehaviorAnnexParser.g:5528:1: entryRulePropertyValue returns [EObject current=null] : iv_rulePropertyValue= rulePropertyValue EOF ; public final EObject entryRulePropertyValue() throws RecognitionException { EObject current = null; @@ -15628,8 +16069,8 @@ public final EObject entryRulePropertyValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5433:54: (iv_rulePropertyValue= rulePropertyValue EOF ) - // InternalBehaviorAnnexParser.g:5434:2: iv_rulePropertyValue= rulePropertyValue EOF + // InternalBehaviorAnnexParser.g:5528:54: (iv_rulePropertyValue= rulePropertyValue EOF ) + // InternalBehaviorAnnexParser.g:5529:2: iv_rulePropertyValue= rulePropertyValue EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyValueRule()); @@ -15660,7 +16101,7 @@ public final EObject entryRulePropertyValue() throws RecognitionException { // $ANTLR start "rulePropertyValue" - // InternalBehaviorAnnexParser.g:5440:1: rulePropertyValue returns [EObject current=null] : ( (lv_ownedValue_0_0= rulePropertyExpression ) ) ; + // InternalBehaviorAnnexParser.g:5535:1: rulePropertyValue returns [EObject current=null] : ( (lv_ownedValue_0_0= rulePropertyExpression ) ) ; public final EObject rulePropertyValue() throws RecognitionException { EObject current = null; @@ -15671,14 +16112,14 @@ public final EObject rulePropertyValue() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5446:2: ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) ) - // InternalBehaviorAnnexParser.g:5447:2: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:5541:2: ( ( (lv_ownedValue_0_0= rulePropertyExpression ) ) ) + // InternalBehaviorAnnexParser.g:5542:2: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) { - // InternalBehaviorAnnexParser.g:5447:2: ( (lv_ownedValue_0_0= rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:5448:3: (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:5448:3: (lv_ownedValue_0_0= rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:5449:4: lv_ownedValue_0_0= rulePropertyExpression + // InternalBehaviorAnnexParser.g:5543:3: (lv_ownedValue_0_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:5544:4: lv_ownedValue_0_0= rulePropertyExpression { if ( state.backtracking==0 ) { @@ -15731,7 +16172,7 @@ public final EObject rulePropertyValue() throws RecognitionException { // $ANTLR start "entryRulePropertyExpression" - // InternalBehaviorAnnexParser.g:5469:1: entryRulePropertyExpression returns [EObject current=null] : iv_rulePropertyExpression= rulePropertyExpression EOF ; + // InternalBehaviorAnnexParser.g:5564:1: entryRulePropertyExpression returns [EObject current=null] : iv_rulePropertyExpression= rulePropertyExpression EOF ; public final EObject entryRulePropertyExpression() throws RecognitionException { EObject current = null; @@ -15739,8 +16180,8 @@ public final EObject entryRulePropertyExpression() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5469:59: (iv_rulePropertyExpression= rulePropertyExpression EOF ) - // InternalBehaviorAnnexParser.g:5470:2: iv_rulePropertyExpression= rulePropertyExpression EOF + // InternalBehaviorAnnexParser.g:5564:59: (iv_rulePropertyExpression= rulePropertyExpression EOF ) + // InternalBehaviorAnnexParser.g:5565:2: iv_rulePropertyExpression= rulePropertyExpression EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPropertyExpressionRule()); @@ -15771,7 +16212,7 @@ public final EObject entryRulePropertyExpression() throws RecognitionException { // $ANTLR start "rulePropertyExpression" - // InternalBehaviorAnnexParser.g:5476: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: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 ) ; public final EObject rulePropertyExpression() throws RecognitionException { EObject current = null; @@ -15802,15 +16243,15 @@ public final EObject rulePropertyExpression() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5482: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:5483: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: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:5483: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 alt97=11; - alt97 = dfa97.predict(input); - switch (alt97) { + // 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) { case 1 : - // InternalBehaviorAnnexParser.g:5484:3: this_RecordTerm_0= ruleRecordTerm + // InternalBehaviorAnnexParser.g:5579:3: this_RecordTerm_0= ruleRecordTerm { if ( state.backtracking==0 ) { @@ -15832,7 +16273,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:5493:3: this_ReferenceTerm_1= ruleReferenceTerm + // InternalBehaviorAnnexParser.g:5588:3: this_ReferenceTerm_1= ruleReferenceTerm { if ( state.backtracking==0 ) { @@ -15854,7 +16295,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:5502:3: this_ComponentClassifierTerm_2= ruleComponentClassifierTerm + // InternalBehaviorAnnexParser.g:5597:3: this_ComponentClassifierTerm_2= ruleComponentClassifierTerm { if ( state.backtracking==0 ) { @@ -15876,7 +16317,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 4 : - // InternalBehaviorAnnexParser.g:5511:3: this_ComputedTerm_3= ruleComputedTerm + // InternalBehaviorAnnexParser.g:5606:3: this_ComputedTerm_3= ruleComputedTerm { if ( state.backtracking==0 ) { @@ -15898,7 +16339,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 5 : - // InternalBehaviorAnnexParser.g:5520:3: this_StringTerm_4= ruleStringTerm + // InternalBehaviorAnnexParser.g:5615:3: this_StringTerm_4= ruleStringTerm { if ( state.backtracking==0 ) { @@ -15920,7 +16361,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 6 : - // InternalBehaviorAnnexParser.g:5529:3: this_NumericRangeTerm_5= ruleNumericRangeTerm + // InternalBehaviorAnnexParser.g:5624:3: this_NumericRangeTerm_5= ruleNumericRangeTerm { if ( state.backtracking==0 ) { @@ -15942,7 +16383,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 7 : - // InternalBehaviorAnnexParser.g:5538:3: this_RealTerm_6= ruleRealTerm + // InternalBehaviorAnnexParser.g:5633:3: this_RealTerm_6= ruleRealTerm { if ( state.backtracking==0 ) { @@ -15964,7 +16405,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 8 : - // InternalBehaviorAnnexParser.g:5547:3: this_IntegerTerm_7= ruleIntegerTerm + // InternalBehaviorAnnexParser.g:5642:3: this_IntegerTerm_7= ruleIntegerTerm { if ( state.backtracking==0 ) { @@ -15986,7 +16427,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 9 : - // InternalBehaviorAnnexParser.g:5556:3: this_ListTerm_8= ruleListTerm + // InternalBehaviorAnnexParser.g:5651:3: this_ListTerm_8= ruleListTerm { if ( state.backtracking==0 ) { @@ -16008,7 +16449,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 10 : - // InternalBehaviorAnnexParser.g:5565:3: this_BooleanLiteral_9= ruleBooleanLiteral + // InternalBehaviorAnnexParser.g:5660:3: this_BooleanLiteral_9= ruleBooleanLiteral { if ( state.backtracking==0 ) { @@ -16030,7 +16471,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { } break; case 11 : - // InternalBehaviorAnnexParser.g:5574:3: this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm + // InternalBehaviorAnnexParser.g:5669:3: this_LiteralorReferenceTerm_10= ruleLiteralorReferenceTerm { if ( state.backtracking==0 ) { @@ -16076,7 +16517,7 @@ public final EObject rulePropertyExpression() throws RecognitionException { // $ANTLR start "entryRuleLiteralorReferenceTerm" - // InternalBehaviorAnnexParser.g:5586:1: entryRuleLiteralorReferenceTerm returns [EObject current=null] : iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF ; + // InternalBehaviorAnnexParser.g:5681:1: entryRuleLiteralorReferenceTerm returns [EObject current=null] : iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF ; public final EObject entryRuleLiteralorReferenceTerm() throws RecognitionException { EObject current = null; @@ -16084,8 +16525,8 @@ public final EObject entryRuleLiteralorReferenceTerm() throws RecognitionExcepti try { - // InternalBehaviorAnnexParser.g:5586:63: (iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF ) - // InternalBehaviorAnnexParser.g:5587:2: iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF + // InternalBehaviorAnnexParser.g:5681:63: (iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF ) + // InternalBehaviorAnnexParser.g:5682:2: iv_ruleLiteralorReferenceTerm= ruleLiteralorReferenceTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getLiteralorReferenceTermRule()); @@ -16116,7 +16557,7 @@ public final EObject entryRuleLiteralorReferenceTerm() throws RecognitionExcepti // $ANTLR start "ruleLiteralorReferenceTerm" - // InternalBehaviorAnnexParser.g:5593:1: ruleLiteralorReferenceTerm returns [EObject current=null] : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:5688:1: ruleLiteralorReferenceTerm returns [EObject current=null] : ( ( ruleQPREF ) ) ; public final EObject ruleLiteralorReferenceTerm() throws RecognitionException { EObject current = null; @@ -16124,14 +16565,14 @@ public final EObject ruleLiteralorReferenceTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5599:2: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:5600:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:5694:2: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:5695:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:5600:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:5601:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5695:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:5696:3: ( ruleQPREF ) { - // InternalBehaviorAnnexParser.g:5601:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:5602:4: ruleQPREF + // InternalBehaviorAnnexParser.g:5696:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5697:4: ruleQPREF { if ( state.backtracking==0 ) { @@ -16183,7 +16624,7 @@ public final EObject ruleLiteralorReferenceTerm() throws RecognitionException { // $ANTLR start "entryRuleBooleanLiteral" - // InternalBehaviorAnnexParser.g:5619:1: entryRuleBooleanLiteral returns [EObject current=null] : iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ; + // InternalBehaviorAnnexParser.g:5714:1: entryRuleBooleanLiteral returns [EObject current=null] : iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ; public final EObject entryRuleBooleanLiteral() throws RecognitionException { EObject current = null; @@ -16191,8 +16632,8 @@ public final EObject entryRuleBooleanLiteral() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5619:55: (iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ) - // InternalBehaviorAnnexParser.g:5620:2: iv_ruleBooleanLiteral= ruleBooleanLiteral EOF + // InternalBehaviorAnnexParser.g:5714:55: (iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ) + // InternalBehaviorAnnexParser.g:5715:2: iv_ruleBooleanLiteral= ruleBooleanLiteral EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getBooleanLiteralRule()); @@ -16223,7 +16664,7 @@ public final EObject entryRuleBooleanLiteral() throws RecognitionException { // $ANTLR start "ruleBooleanLiteral" - // InternalBehaviorAnnexParser.g:5626:1: ruleBooleanLiteral returns [EObject current=null] : ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ; + // InternalBehaviorAnnexParser.g:5721:1: ruleBooleanLiteral returns [EObject current=null] : ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ; public final EObject ruleBooleanLiteral() throws RecognitionException { EObject current = null; @@ -16234,14 +16675,14 @@ public final EObject ruleBooleanLiteral() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5632:2: ( ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) ) - // InternalBehaviorAnnexParser.g:5633:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) + // 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:5633:2: ( () ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) ) - // InternalBehaviorAnnexParser.g:5634:3: () ( ( (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:5634:3: () - // InternalBehaviorAnnexParser.g:5635:4: + // InternalBehaviorAnnexParser.g:5729:3: () + // InternalBehaviorAnnexParser.g:5730:4: { if ( state.backtracking==0 ) { @@ -16253,32 +16694,32 @@ public final EObject ruleBooleanLiteral() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:5641:3: ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) - int alt98=2; - int LA98_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:5736:3: ( ( (lv_value_1_0= True ) ) | otherlv_2= False ) + int alt100=2; + int LA100_0 = input.LA(1); - if ( (LA98_0==True) ) { - alt98=1; + if ( (LA100_0==True) ) { + alt100=1; } - else if ( (LA98_0==False) ) { - alt98=2; + else if ( (LA100_0==False) ) { + alt100=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 98, 0, input); + new NoViableAltException("", 100, 0, input); throw nvae; } - switch (alt98) { + switch (alt100) { case 1 : - // InternalBehaviorAnnexParser.g:5642:4: ( (lv_value_1_0= True ) ) + // InternalBehaviorAnnexParser.g:5737:4: ( (lv_value_1_0= True ) ) { - // InternalBehaviorAnnexParser.g:5642:4: ( (lv_value_1_0= True ) ) - // InternalBehaviorAnnexParser.g:5643:5: (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:5643:5: (lv_value_1_0= True ) - // InternalBehaviorAnnexParser.g:5644:6: lv_value_1_0= True + // InternalBehaviorAnnexParser.g:5738:5: (lv_value_1_0= True ) + // InternalBehaviorAnnexParser.g:5739: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 ) { @@ -16304,7 +16745,7 @@ else if ( (LA98_0==False) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:5657:4: otherlv_2= False + // InternalBehaviorAnnexParser.g:5752:4: otherlv_2= False { otherlv_2=(Token)match(input,False,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -16343,7 +16784,7 @@ else if ( (LA98_0==False) ) { // $ANTLR start "entryRuleConstantValue" - // InternalBehaviorAnnexParser.g:5666:1: entryRuleConstantValue returns [EObject current=null] : iv_ruleConstantValue= ruleConstantValue EOF ; + // InternalBehaviorAnnexParser.g:5761:1: entryRuleConstantValue returns [EObject current=null] : iv_ruleConstantValue= ruleConstantValue EOF ; public final EObject entryRuleConstantValue() throws RecognitionException { EObject current = null; @@ -16351,8 +16792,8 @@ public final EObject entryRuleConstantValue() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5666:54: (iv_ruleConstantValue= ruleConstantValue EOF ) - // InternalBehaviorAnnexParser.g:5667:2: iv_ruleConstantValue= ruleConstantValue EOF + // InternalBehaviorAnnexParser.g:5761:54: (iv_ruleConstantValue= ruleConstantValue EOF ) + // InternalBehaviorAnnexParser.g:5762:2: iv_ruleConstantValue= ruleConstantValue EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getConstantValueRule()); @@ -16383,7 +16824,7 @@ public final EObject entryRuleConstantValue() throws RecognitionException { // $ANTLR start "ruleConstantValue" - // InternalBehaviorAnnexParser.g:5673:1: ruleConstantValue returns [EObject current=null] : ( ( ruleQPREF ) ) ; + // InternalBehaviorAnnexParser.g:5768:1: ruleConstantValue returns [EObject current=null] : ( ( ruleQPREF ) ) ; public final EObject ruleConstantValue() throws RecognitionException { EObject current = null; @@ -16391,14 +16832,14 @@ public final EObject ruleConstantValue() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5679:2: ( ( ( ruleQPREF ) ) ) - // InternalBehaviorAnnexParser.g:5680:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:5774:2: ( ( ( ruleQPREF ) ) ) + // InternalBehaviorAnnexParser.g:5775:2: ( ( ruleQPREF ) ) { - // InternalBehaviorAnnexParser.g:5680:2: ( ( ruleQPREF ) ) - // InternalBehaviorAnnexParser.g:5681:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5775:2: ( ( ruleQPREF ) ) + // InternalBehaviorAnnexParser.g:5776:3: ( ruleQPREF ) { - // InternalBehaviorAnnexParser.g:5681:3: ( ruleQPREF ) - // InternalBehaviorAnnexParser.g:5682:4: ruleQPREF + // InternalBehaviorAnnexParser.g:5776:3: ( ruleQPREF ) + // InternalBehaviorAnnexParser.g:5777:4: ruleQPREF { if ( state.backtracking==0 ) { @@ -16450,7 +16891,7 @@ public final EObject ruleConstantValue() throws RecognitionException { // $ANTLR start "entryRuleReferenceTerm" - // InternalBehaviorAnnexParser.g:5699:1: entryRuleReferenceTerm returns [EObject current=null] : iv_ruleReferenceTerm= ruleReferenceTerm EOF ; + // InternalBehaviorAnnexParser.g:5794:1: entryRuleReferenceTerm returns [EObject current=null] : iv_ruleReferenceTerm= ruleReferenceTerm EOF ; public final EObject entryRuleReferenceTerm() throws RecognitionException { EObject current = null; @@ -16458,8 +16899,8 @@ public final EObject entryRuleReferenceTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5699:54: (iv_ruleReferenceTerm= ruleReferenceTerm EOF ) - // InternalBehaviorAnnexParser.g:5700:2: iv_ruleReferenceTerm= ruleReferenceTerm EOF + // InternalBehaviorAnnexParser.g:5794:54: (iv_ruleReferenceTerm= ruleReferenceTerm EOF ) + // InternalBehaviorAnnexParser.g:5795:2: iv_ruleReferenceTerm= ruleReferenceTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getReferenceTermRule()); @@ -16490,7 +16931,7 @@ public final EObject entryRuleReferenceTerm() throws RecognitionException { // $ANTLR start "ruleReferenceTerm" - // InternalBehaviorAnnexParser.g:5706:1: ruleReferenceTerm returns [EObject current=null] : (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:5801: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; @@ -16504,11 +16945,11 @@ public final EObject ruleReferenceTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5712:2: ( (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:5713:2: (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) + // 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:5713:2: (otherlv_0= Reference otherlv_1= LeftParenthesis ( (lv_path_2_0= ruleContainmentPathElement ) ) otherlv_3= RightParenthesis ) - // InternalBehaviorAnnexParser.g:5714:3: 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 { otherlv_0=(Token)match(input,Reference,FollowSets000.FOLLOW_31); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -16522,11 +16963,11 @@ public final EObject ruleReferenceTerm() throws RecognitionException { newLeafNode(otherlv_1, grammarAccess.getReferenceTermAccess().getLeftParenthesisKeyword_1()); } - // InternalBehaviorAnnexParser.g:5722:3: ( (lv_path_2_0= ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:5723:4: (lv_path_2_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:5817:3: ( (lv_path_2_0= ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:5818:4: (lv_path_2_0= ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:5723:4: (lv_path_2_0= ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:5724:5: lv_path_2_0= ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:5818:4: (lv_path_2_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:5819:5: lv_path_2_0= ruleContainmentPathElement { if ( state.backtracking==0 ) { @@ -16588,7 +17029,7 @@ public final EObject ruleReferenceTerm() throws RecognitionException { // $ANTLR start "entryRuleRecordTerm" - // InternalBehaviorAnnexParser.g:5749:1: entryRuleRecordTerm returns [EObject current=null] : iv_ruleRecordTerm= ruleRecordTerm EOF ; + // InternalBehaviorAnnexParser.g:5844:1: entryRuleRecordTerm returns [EObject current=null] : iv_ruleRecordTerm= ruleRecordTerm EOF ; public final EObject entryRuleRecordTerm() throws RecognitionException { EObject current = null; @@ -16596,8 +17037,8 @@ public final EObject entryRuleRecordTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5749:51: (iv_ruleRecordTerm= ruleRecordTerm EOF ) - // InternalBehaviorAnnexParser.g:5750:2: iv_ruleRecordTerm= ruleRecordTerm EOF + // InternalBehaviorAnnexParser.g:5844:51: (iv_ruleRecordTerm= ruleRecordTerm EOF ) + // InternalBehaviorAnnexParser.g:5845:2: iv_ruleRecordTerm= ruleRecordTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getRecordTermRule()); @@ -16628,7 +17069,7 @@ public final EObject entryRuleRecordTerm() throws RecognitionException { // $ANTLR start "ruleRecordTerm" - // InternalBehaviorAnnexParser.g:5756:1: ruleRecordTerm returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) ; + // InternalBehaviorAnnexParser.g:5851: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; @@ -16641,11 +17082,11 @@ public final EObject ruleRecordTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5762:2: ( (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:5763:2: (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) + // 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:5763:2: (otherlv_0= LeftSquareBracket ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ otherlv_2= RightSquareBracket ) - // InternalBehaviorAnnexParser.g:5764:3: 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 { otherlv_0=(Token)match(input,LeftSquareBracket,FollowSets000.FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -16653,31 +17094,31 @@ public final EObject ruleRecordTerm() throws RecognitionException { newLeafNode(otherlv_0, grammarAccess.getRecordTermAccess().getLeftSquareBracketKeyword_0()); } - // InternalBehaviorAnnexParser.g:5768:3: ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ - int cnt99=0; - loop99: + // InternalBehaviorAnnexParser.g:5863:3: ( (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) )+ + int cnt101=0; + loop101: do { - int alt99=2; - int LA99_0 = input.LA(1); + int alt101=2; + int LA101_0 = input.LA(1); - if ( (LA99_0==RULE_ID) ) { - alt99=1; + if ( (LA101_0==RULE_ID) ) { + alt101=1; } - switch (alt99) { + switch (alt101) { case 1 : - // InternalBehaviorAnnexParser.g:5769:4: (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) + // InternalBehaviorAnnexParser.g:5864:4: (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) { - // InternalBehaviorAnnexParser.g:5769:4: (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) - // InternalBehaviorAnnexParser.g:5770:5: lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation + // InternalBehaviorAnnexParser.g:5864:4: (lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation ) + // InternalBehaviorAnnexParser.g:5865:5: lv_ownedFieldValue_1_0= ruleFieldPropertyAssociation { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getRecordTermAccess().getOwnedFieldValueFieldPropertyAssociationParserRuleCall_1_0()); } - pushFollow(FollowSets000.FOLLOW_82); + pushFollow(FollowSets000.FOLLOW_84); lv_ownedFieldValue_1_0=ruleFieldPropertyAssociation(); state._fsp--; @@ -16703,13 +17144,13 @@ public final EObject ruleRecordTerm() throws RecognitionException { break; default : - if ( cnt99 >= 1 ) break loop99; + if ( cnt101 >= 1 ) break loop101; if (state.backtracking>0) {state.failed=true; return current;} EarlyExitException eee = - new EarlyExitException(99, input); + new EarlyExitException(101, input); throw eee; } - cnt99++; + cnt101++; } while (true); otherlv_2=(Token)match(input,RightSquareBracket,FollowSets000.FOLLOW_2); if (state.failed) return current; @@ -16743,7 +17184,7 @@ public final EObject ruleRecordTerm() throws RecognitionException { // $ANTLR start "entryRuleComputedTerm" - // InternalBehaviorAnnexParser.g:5795:1: entryRuleComputedTerm returns [EObject current=null] : iv_ruleComputedTerm= ruleComputedTerm EOF ; + // InternalBehaviorAnnexParser.g:5890:1: entryRuleComputedTerm returns [EObject current=null] : iv_ruleComputedTerm= ruleComputedTerm EOF ; public final EObject entryRuleComputedTerm() throws RecognitionException { EObject current = null; @@ -16751,8 +17192,8 @@ public final EObject entryRuleComputedTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5795:53: (iv_ruleComputedTerm= ruleComputedTerm EOF ) - // InternalBehaviorAnnexParser.g:5796:2: iv_ruleComputedTerm= ruleComputedTerm EOF + // InternalBehaviorAnnexParser.g:5890:53: (iv_ruleComputedTerm= ruleComputedTerm EOF ) + // InternalBehaviorAnnexParser.g:5891:2: iv_ruleComputedTerm= ruleComputedTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getComputedTermRule()); @@ -16783,7 +17224,7 @@ public final EObject entryRuleComputedTerm() throws RecognitionException { // $ANTLR start "ruleComputedTerm" - // InternalBehaviorAnnexParser.g:5802:1: ruleComputedTerm returns [EObject current=null] : (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:5897: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; @@ -16796,11 +17237,11 @@ public final EObject ruleComputedTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5808:2: ( (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:5809:2: (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) + // 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:5809:2: (otherlv_0= Compute otherlv_1= LeftParenthesis ( (lv_function_2_0= RULE_ID ) ) otherlv_3= RightParenthesis ) - // InternalBehaviorAnnexParser.g:5810:3: 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 { otherlv_0=(Token)match(input,Compute,FollowSets000.FOLLOW_31); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -16814,11 +17255,11 @@ public final EObject ruleComputedTerm() throws RecognitionException { newLeafNode(otherlv_1, grammarAccess.getComputedTermAccess().getLeftParenthesisKeyword_1()); } - // InternalBehaviorAnnexParser.g:5818:3: ( (lv_function_2_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:5819:4: (lv_function_2_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:5913:3: ( (lv_function_2_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:5914:4: (lv_function_2_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:5819:4: (lv_function_2_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:5820:5: 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 { lv_function_2_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_39); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -16875,7 +17316,7 @@ public final EObject ruleComputedTerm() throws RecognitionException { // $ANTLR start "entryRuleComponentClassifierTerm" - // InternalBehaviorAnnexParser.g:5844:1: entryRuleComponentClassifierTerm returns [EObject current=null] : iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF ; + // InternalBehaviorAnnexParser.g:5939:1: entryRuleComponentClassifierTerm returns [EObject current=null] : iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF ; public final EObject entryRuleComponentClassifierTerm() throws RecognitionException { EObject current = null; @@ -16883,8 +17324,8 @@ public final EObject entryRuleComponentClassifierTerm() throws RecognitionExcept try { - // InternalBehaviorAnnexParser.g:5844:64: (iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF ) - // InternalBehaviorAnnexParser.g:5845:2: iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF + // InternalBehaviorAnnexParser.g:5939:64: (iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF ) + // InternalBehaviorAnnexParser.g:5940:2: iv_ruleComponentClassifierTerm= ruleComponentClassifierTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getComponentClassifierTermRule()); @@ -16915,7 +17356,7 @@ public final EObject entryRuleComponentClassifierTerm() throws RecognitionExcept // $ANTLR start "ruleComponentClassifierTerm" - // InternalBehaviorAnnexParser.g:5851:1: ruleComponentClassifierTerm returns [EObject current=null] : (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) ; + // InternalBehaviorAnnexParser.g:5946: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; @@ -16927,11 +17368,11 @@ public final EObject ruleComponentClassifierTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5857:2: ( (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:5858:2: (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) + // 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:5858:2: (otherlv_0= Classifier otherlv_1= LeftParenthesis ( ( ruleQCREF ) ) otherlv_3= RightParenthesis ) - // InternalBehaviorAnnexParser.g:5859:3: 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 { otherlv_0=(Token)match(input,Classifier,FollowSets000.FOLLOW_31); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -16945,11 +17386,11 @@ public final EObject ruleComponentClassifierTerm() throws RecognitionException { newLeafNode(otherlv_1, grammarAccess.getComponentClassifierTermAccess().getLeftParenthesisKeyword_1()); } - // InternalBehaviorAnnexParser.g:5867:3: ( ( ruleQCREF ) ) - // InternalBehaviorAnnexParser.g:5868:4: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:5962:3: ( ( ruleQCREF ) ) + // InternalBehaviorAnnexParser.g:5963:4: ( ruleQCREF ) { - // InternalBehaviorAnnexParser.g:5868:4: ( ruleQCREF ) - // InternalBehaviorAnnexParser.g:5869:5: ruleQCREF + // InternalBehaviorAnnexParser.g:5963:4: ( ruleQCREF ) + // InternalBehaviorAnnexParser.g:5964:5: ruleQCREF { if ( state.backtracking==0 ) { @@ -17010,7 +17451,7 @@ public final EObject ruleComponentClassifierTerm() throws RecognitionException { // $ANTLR start "entryRuleListTerm" - // InternalBehaviorAnnexParser.g:5891:1: entryRuleListTerm returns [EObject current=null] : iv_ruleListTerm= ruleListTerm EOF ; + // InternalBehaviorAnnexParser.g:5986:1: entryRuleListTerm returns [EObject current=null] : iv_ruleListTerm= ruleListTerm EOF ; public final EObject entryRuleListTerm() throws RecognitionException { EObject current = null; @@ -17018,8 +17459,8 @@ public final EObject entryRuleListTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:5891:49: (iv_ruleListTerm= ruleListTerm EOF ) - // InternalBehaviorAnnexParser.g:5892:2: iv_ruleListTerm= ruleListTerm EOF + // InternalBehaviorAnnexParser.g:5986:49: (iv_ruleListTerm= ruleListTerm EOF ) + // InternalBehaviorAnnexParser.g:5987:2: iv_ruleListTerm= ruleListTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getListTermRule()); @@ -17050,7 +17491,7 @@ public final EObject entryRuleListTerm() throws RecognitionException { // $ANTLR start "ruleListTerm" - // InternalBehaviorAnnexParser.g:5898: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: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 ) ; public final EObject ruleListTerm() throws RecognitionException { EObject current = null; @@ -17066,14 +17507,14 @@ public final EObject ruleListTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:5904:2: ( ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) ) - // InternalBehaviorAnnexParser.g:5905:2: ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) + // 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:5905:2: ( () otherlv_1= LeftParenthesis ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? otherlv_5= RightParenthesis ) - // InternalBehaviorAnnexParser.g:5906:3: () 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:5906:3: () - // InternalBehaviorAnnexParser.g:5907:4: + // InternalBehaviorAnnexParser.g:6001:3: () + // InternalBehaviorAnnexParser.g:6002:4: { if ( state.backtracking==0 ) { @@ -17085,28 +17526,28 @@ public final EObject ruleListTerm() throws RecognitionException { } - otherlv_1=(Token)match(input,LeftParenthesis,FollowSets000.FOLLOW_83); if (state.failed) return current; + otherlv_1=(Token)match(input,LeftParenthesis,FollowSets000.FOLLOW_85); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getListTermAccess().getLeftParenthesisKeyword_1()); } - // InternalBehaviorAnnexParser.g:5917:3: ( ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* )? - int alt101=2; - int LA101_0 = input.LA(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); - if ( (LA101_0==Classifier||LA101_0==Reference||LA101_0==Compute||LA101_0==False||LA101_0==True||LA101_0==LeftParenthesis||LA101_0==PlusSign||LA101_0==HyphenMinus||LA101_0==LeftSquareBracket||LA101_0==RULE_REAL_LIT||LA101_0==RULE_INTEGER_LIT||(LA101_0>=RULE_STRING && LA101_0<=RULE_ID)) ) { - alt101=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; } - switch (alt101) { + switch (alt103) { case 1 : - // InternalBehaviorAnnexParser.g:5918:4: ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* + // InternalBehaviorAnnexParser.g:6013:4: ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* { - // InternalBehaviorAnnexParser.g:5918:4: ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:5919:5: (lv_ownedListElement_2_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6013:4: ( (lv_ownedListElement_2_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:6014:5: (lv_ownedListElement_2_0= rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:5919:5: (lv_ownedListElement_2_0= rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:5920:6: lv_ownedListElement_2_0= rulePropertyExpression + // InternalBehaviorAnnexParser.g:6014:5: (lv_ownedListElement_2_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6015:6: lv_ownedListElement_2_0= rulePropertyExpression { if ( state.backtracking==0 ) { @@ -17137,20 +17578,20 @@ public final EObject ruleListTerm() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:5937:4: (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* - loop100: + // InternalBehaviorAnnexParser.g:6032:4: (otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) )* + loop102: do { - int alt100=2; - int LA100_0 = input.LA(1); + int alt102=2; + int LA102_0 = input.LA(1); - if ( (LA100_0==Comma) ) { - alt100=1; + if ( (LA102_0==Comma) ) { + alt102=1; } - switch (alt100) { + switch (alt102) { case 1 : - // InternalBehaviorAnnexParser.g:5938:5: otherlv_3= Comma ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:6033: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 ) { @@ -17158,11 +17599,11 @@ public final EObject ruleListTerm() throws RecognitionException { newLeafNode(otherlv_3, grammarAccess.getListTermAccess().getCommaKeyword_2_1_0()); } - // InternalBehaviorAnnexParser.g:5942:5: ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:5943:6: (lv_ownedListElement_4_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6037:5: ( (lv_ownedListElement_4_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:6038:6: (lv_ownedListElement_4_0= rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:5943:6: (lv_ownedListElement_4_0= rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:5944:7: lv_ownedListElement_4_0= rulePropertyExpression + // InternalBehaviorAnnexParser.g:6038:6: (lv_ownedListElement_4_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6039:7: lv_ownedListElement_4_0= rulePropertyExpression { if ( state.backtracking==0 ) { @@ -17198,7 +17639,7 @@ public final EObject ruleListTerm() throws RecognitionException { break; default : - break loop100; + break loop102; } } while (true); @@ -17239,7 +17680,7 @@ public final EObject ruleListTerm() throws RecognitionException { // $ANTLR start "entryRuleFieldPropertyAssociation" - // InternalBehaviorAnnexParser.g:5971:1: entryRuleFieldPropertyAssociation returns [EObject current=null] : iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF ; + // InternalBehaviorAnnexParser.g:6066:1: entryRuleFieldPropertyAssociation returns [EObject current=null] : iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF ; public final EObject entryRuleFieldPropertyAssociation() throws RecognitionException { EObject current = null; @@ -17247,8 +17688,8 @@ public final EObject entryRuleFieldPropertyAssociation() throws RecognitionExcep try { - // InternalBehaviorAnnexParser.g:5971:65: (iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF ) - // InternalBehaviorAnnexParser.g:5972:2: iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF + // InternalBehaviorAnnexParser.g:6066:65: (iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF ) + // InternalBehaviorAnnexParser.g:6067:2: iv_ruleFieldPropertyAssociation= ruleFieldPropertyAssociation EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getFieldPropertyAssociationRule()); @@ -17279,7 +17720,7 @@ public final EObject entryRuleFieldPropertyAssociation() throws RecognitionExcep // $ANTLR start "ruleFieldPropertyAssociation" - // InternalBehaviorAnnexParser.g:5978:1: ruleFieldPropertyAssociation returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) ; + // InternalBehaviorAnnexParser.g:6073: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; @@ -17293,17 +17734,17 @@ public final EObject ruleFieldPropertyAssociation() throws RecognitionException enterRule(); try { - // InternalBehaviorAnnexParser.g:5984:2: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) ) - // InternalBehaviorAnnexParser.g:5985:2: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) + // 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:5985:2: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= EqualsSignGreaterThanSign ( (lv_ownedValue_2_0= rulePropertyExpression ) ) otherlv_3= Semicolon ) - // InternalBehaviorAnnexParser.g:5986:3: ( (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:5986:3: ( (otherlv_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:5987:4: (otherlv_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:6081:3: ( (otherlv_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:6082:4: (otherlv_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:5987:4: (otherlv_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:5988:5: otherlv_0= RULE_ID + // InternalBehaviorAnnexParser.g:6082:4: (otherlv_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:6083:5: otherlv_0= RULE_ID { if ( state.backtracking==0 ) { @@ -17330,11 +17771,11 @@ public final EObject ruleFieldPropertyAssociation() throws RecognitionException newLeafNode(otherlv_1, grammarAccess.getFieldPropertyAssociationAccess().getEqualsSignGreaterThanSignKeyword_1()); } - // InternalBehaviorAnnexParser.g:6003:3: ( (lv_ownedValue_2_0= rulePropertyExpression ) ) - // InternalBehaviorAnnexParser.g:6004:4: (lv_ownedValue_2_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6098:3: ( (lv_ownedValue_2_0= rulePropertyExpression ) ) + // InternalBehaviorAnnexParser.g:6099:4: (lv_ownedValue_2_0= rulePropertyExpression ) { - // InternalBehaviorAnnexParser.g:6004:4: (lv_ownedValue_2_0= rulePropertyExpression ) - // InternalBehaviorAnnexParser.g:6005:5: lv_ownedValue_2_0= rulePropertyExpression + // InternalBehaviorAnnexParser.g:6099:4: (lv_ownedValue_2_0= rulePropertyExpression ) + // InternalBehaviorAnnexParser.g:6100:5: lv_ownedValue_2_0= rulePropertyExpression { if ( state.backtracking==0 ) { @@ -17396,7 +17837,7 @@ public final EObject ruleFieldPropertyAssociation() throws RecognitionException // $ANTLR start "entryRuleContainmentPathElement" - // InternalBehaviorAnnexParser.g:6030:1: entryRuleContainmentPathElement returns [EObject current=null] : iv_ruleContainmentPathElement= ruleContainmentPathElement EOF ; + // InternalBehaviorAnnexParser.g:6125:1: entryRuleContainmentPathElement returns [EObject current=null] : iv_ruleContainmentPathElement= ruleContainmentPathElement EOF ; public final EObject entryRuleContainmentPathElement() throws RecognitionException { EObject current = null; @@ -17404,8 +17845,8 @@ public final EObject entryRuleContainmentPathElement() throws RecognitionExcepti try { - // InternalBehaviorAnnexParser.g:6030:63: (iv_ruleContainmentPathElement= ruleContainmentPathElement EOF ) - // InternalBehaviorAnnexParser.g:6031:2: iv_ruleContainmentPathElement= ruleContainmentPathElement EOF + // InternalBehaviorAnnexParser.g:6125:63: (iv_ruleContainmentPathElement= ruleContainmentPathElement EOF ) + // InternalBehaviorAnnexParser.g:6126:2: iv_ruleContainmentPathElement= ruleContainmentPathElement EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainmentPathElementRule()); @@ -17436,7 +17877,7 @@ public final EObject entryRuleContainmentPathElement() throws RecognitionExcepti // $ANTLR start "ruleContainmentPathElement" - // InternalBehaviorAnnexParser.g:6037: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:6132: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; @@ -17451,20 +17892,20 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6043:2: ( ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) ) - // InternalBehaviorAnnexParser.g:6044:2: ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) + // 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:6044:2: ( ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? ) - // InternalBehaviorAnnexParser.g:6045:3: ( ( (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:6045:3: ( ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* ) - // InternalBehaviorAnnexParser.g:6046:4: ( (otherlv_0= RULE_ID ) ) ( (lv_arrayRange_1_0= ruleArrayRange ) )* + // 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:6046:4: ( (otherlv_0= RULE_ID ) ) - // InternalBehaviorAnnexParser.g:6047:5: (otherlv_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:6141:4: ( (otherlv_0= RULE_ID ) ) + // InternalBehaviorAnnexParser.g:6142:5: (otherlv_0= RULE_ID ) { - // InternalBehaviorAnnexParser.g:6047:5: (otherlv_0= RULE_ID ) - // InternalBehaviorAnnexParser.g:6048:6: otherlv_0= RULE_ID + // InternalBehaviorAnnexParser.g:6142:5: (otherlv_0= RULE_ID ) + // InternalBehaviorAnnexParser.g:6143:6: otherlv_0= RULE_ID { if ( state.backtracking==0 ) { @@ -17473,7 +17914,7 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { } } - otherlv_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_70); if (state.failed) return current; + otherlv_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_72); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getContainmentPathElementAccess().getNamedElementNamedElementCrossReference_0_0_0()); @@ -17485,30 +17926,30 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6059:4: ( (lv_arrayRange_1_0= ruleArrayRange ) )* - loop102: + // InternalBehaviorAnnexParser.g:6154:4: ( (lv_arrayRange_1_0= ruleArrayRange ) )* + loop104: do { - int alt102=2; - int LA102_0 = input.LA(1); + int alt104=2; + int LA104_0 = input.LA(1); - if ( (LA102_0==LeftSquareBracket) ) { - alt102=1; + if ( (LA104_0==LeftSquareBracket) ) { + alt104=1; } - switch (alt102) { + switch (alt104) { case 1 : - // InternalBehaviorAnnexParser.g:6060:5: (lv_arrayRange_1_0= ruleArrayRange ) + // InternalBehaviorAnnexParser.g:6155:5: (lv_arrayRange_1_0= ruleArrayRange ) { - // InternalBehaviorAnnexParser.g:6060:5: (lv_arrayRange_1_0= ruleArrayRange ) - // InternalBehaviorAnnexParser.g:6061:6: lv_arrayRange_1_0= ruleArrayRange + // InternalBehaviorAnnexParser.g:6155:5: (lv_arrayRange_1_0= ruleArrayRange ) + // InternalBehaviorAnnexParser.g:6156:6: lv_arrayRange_1_0= ruleArrayRange { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getContainmentPathElementAccess().getArrayRangeArrayRangeParserRuleCall_0_1_0()); } - pushFollow(FollowSets000.FOLLOW_70); + pushFollow(FollowSets000.FOLLOW_72); lv_arrayRange_1_0=ruleArrayRange(); state._fsp--; @@ -17534,23 +17975,23 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { break; default : - break loop102; + break loop104; } } while (true); } - // InternalBehaviorAnnexParser.g:6079:3: (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? - int alt103=2; - int LA103_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6174:3: (otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) )? + int alt105=2; + int LA105_0 = input.LA(1); - if ( (LA103_0==FullStop) ) { - alt103=1; + if ( (LA105_0==FullStop) ) { + alt105=1; } - switch (alt103) { + switch (alt105) { case 1 : - // InternalBehaviorAnnexParser.g:6080:4: otherlv_2= FullStop ( (lv_path_3_0= ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:6175: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 ) { @@ -17558,11 +17999,11 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { newLeafNode(otherlv_2, grammarAccess.getContainmentPathElementAccess().getFullStopKeyword_1_0()); } - // InternalBehaviorAnnexParser.g:6084:4: ( (lv_path_3_0= ruleContainmentPathElement ) ) - // InternalBehaviorAnnexParser.g:6085:5: (lv_path_3_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:6179:4: ( (lv_path_3_0= ruleContainmentPathElement ) ) + // InternalBehaviorAnnexParser.g:6180:5: (lv_path_3_0= ruleContainmentPathElement ) { - // InternalBehaviorAnnexParser.g:6085:5: (lv_path_3_0= ruleContainmentPathElement ) - // InternalBehaviorAnnexParser.g:6086:6: lv_path_3_0= ruleContainmentPathElement + // InternalBehaviorAnnexParser.g:6180:5: (lv_path_3_0= ruleContainmentPathElement ) + // InternalBehaviorAnnexParser.g:6181:6: lv_path_3_0= ruleContainmentPathElement { if ( state.backtracking==0 ) { @@ -17624,7 +18065,7 @@ public final EObject ruleContainmentPathElement() throws RecognitionException { // $ANTLR start "entryRulePlusMinus" - // InternalBehaviorAnnexParser.g:6108:1: entryRulePlusMinus returns [String current=null] : iv_rulePlusMinus= rulePlusMinus EOF ; + // InternalBehaviorAnnexParser.g:6203:1: entryRulePlusMinus returns [String current=null] : iv_rulePlusMinus= rulePlusMinus EOF ; public final String entryRulePlusMinus() throws RecognitionException { String current = null; @@ -17632,8 +18073,8 @@ public final String entryRulePlusMinus() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6108:49: (iv_rulePlusMinus= rulePlusMinus EOF ) - // InternalBehaviorAnnexParser.g:6109:2: iv_rulePlusMinus= rulePlusMinus EOF + // InternalBehaviorAnnexParser.g:6203:49: (iv_rulePlusMinus= rulePlusMinus EOF ) + // InternalBehaviorAnnexParser.g:6204:2: iv_rulePlusMinus= rulePlusMinus EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getPlusMinusRule()); @@ -17664,7 +18105,7 @@ public final String entryRulePlusMinus() throws RecognitionException { // $ANTLR start "rulePlusMinus" - // InternalBehaviorAnnexParser.g:6115:1: rulePlusMinus returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= PlusSign | kw= HyphenMinus ) ; + // InternalBehaviorAnnexParser.g:6210:1: rulePlusMinus returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= PlusSign | kw= HyphenMinus ) ; public final AntlrDatatypeRuleToken rulePlusMinus() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -17674,29 +18115,29 @@ public final AntlrDatatypeRuleToken rulePlusMinus() throws RecognitionException enterRule(); try { - // InternalBehaviorAnnexParser.g:6121:2: ( (kw= PlusSign | kw= HyphenMinus ) ) - // InternalBehaviorAnnexParser.g:6122:2: (kw= PlusSign | kw= HyphenMinus ) + // InternalBehaviorAnnexParser.g:6216:2: ( (kw= PlusSign | kw= HyphenMinus ) ) + // InternalBehaviorAnnexParser.g:6217:2: (kw= PlusSign | kw= HyphenMinus ) { - // InternalBehaviorAnnexParser.g:6122:2: (kw= PlusSign | kw= HyphenMinus ) - int alt104=2; - int LA104_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6217:2: (kw= PlusSign | kw= HyphenMinus ) + int alt106=2; + int LA106_0 = input.LA(1); - if ( (LA104_0==PlusSign) ) { - alt104=1; + if ( (LA106_0==PlusSign) ) { + alt106=1; } - else if ( (LA104_0==HyphenMinus) ) { - alt104=2; + else if ( (LA106_0==HyphenMinus) ) { + alt106=2; } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 104, 0, input); + new NoViableAltException("", 106, 0, input); throw nvae; } - switch (alt104) { + switch (alt106) { case 1 : - // InternalBehaviorAnnexParser.g:6123:3: kw= PlusSign + // InternalBehaviorAnnexParser.g:6218:3: kw= PlusSign { kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -17709,7 +18150,7 @@ else if ( (LA104_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:6129:3: kw= HyphenMinus + // InternalBehaviorAnnexParser.g:6224:3: kw= HyphenMinus { kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -17746,7 +18187,7 @@ else if ( (LA104_0==HyphenMinus) ) { // $ANTLR start "entryRuleStringTerm" - // InternalBehaviorAnnexParser.g:6138:1: entryRuleStringTerm returns [EObject current=null] : iv_ruleStringTerm= ruleStringTerm EOF ; + // InternalBehaviorAnnexParser.g:6233:1: entryRuleStringTerm returns [EObject current=null] : iv_ruleStringTerm= ruleStringTerm EOF ; public final EObject entryRuleStringTerm() throws RecognitionException { EObject current = null; @@ -17754,8 +18195,8 @@ public final EObject entryRuleStringTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6138:51: (iv_ruleStringTerm= ruleStringTerm EOF ) - // InternalBehaviorAnnexParser.g:6139:2: iv_ruleStringTerm= ruleStringTerm EOF + // InternalBehaviorAnnexParser.g:6233:51: (iv_ruleStringTerm= ruleStringTerm EOF ) + // InternalBehaviorAnnexParser.g:6234:2: iv_ruleStringTerm= ruleStringTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getStringTermRule()); @@ -17786,7 +18227,7 @@ public final EObject entryRuleStringTerm() throws RecognitionException { // $ANTLR start "ruleStringTerm" - // InternalBehaviorAnnexParser.g:6145:1: ruleStringTerm returns [EObject current=null] : ( (lv_value_0_0= ruleNoQuoteString ) ) ; + // InternalBehaviorAnnexParser.g:6240:1: ruleStringTerm returns [EObject current=null] : ( (lv_value_0_0= ruleNoQuoteString ) ) ; public final EObject ruleStringTerm() throws RecognitionException { EObject current = null; @@ -17797,14 +18238,14 @@ public final EObject ruleStringTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6151:2: ( ( (lv_value_0_0= ruleNoQuoteString ) ) ) - // InternalBehaviorAnnexParser.g:6152:2: ( (lv_value_0_0= ruleNoQuoteString ) ) + // InternalBehaviorAnnexParser.g:6246:2: ( ( (lv_value_0_0= ruleNoQuoteString ) ) ) + // InternalBehaviorAnnexParser.g:6247:2: ( (lv_value_0_0= ruleNoQuoteString ) ) { - // InternalBehaviorAnnexParser.g:6152:2: ( (lv_value_0_0= ruleNoQuoteString ) ) - // InternalBehaviorAnnexParser.g:6153:3: (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:6153:3: (lv_value_0_0= ruleNoQuoteString ) - // InternalBehaviorAnnexParser.g:6154:4: lv_value_0_0= ruleNoQuoteString + // InternalBehaviorAnnexParser.g:6248:3: (lv_value_0_0= ruleNoQuoteString ) + // InternalBehaviorAnnexParser.g:6249:4: lv_value_0_0= ruleNoQuoteString { if ( state.backtracking==0 ) { @@ -17857,7 +18298,7 @@ public final EObject ruleStringTerm() throws RecognitionException { // $ANTLR start "entryRuleNoQuoteString" - // InternalBehaviorAnnexParser.g:6174:1: entryRuleNoQuoteString returns [String current=null] : iv_ruleNoQuoteString= ruleNoQuoteString EOF ; + // InternalBehaviorAnnexParser.g:6269:1: entryRuleNoQuoteString returns [String current=null] : iv_ruleNoQuoteString= ruleNoQuoteString EOF ; public final String entryRuleNoQuoteString() throws RecognitionException { String current = null; @@ -17865,8 +18306,8 @@ public final String entryRuleNoQuoteString() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6174:53: (iv_ruleNoQuoteString= ruleNoQuoteString EOF ) - // InternalBehaviorAnnexParser.g:6175:2: iv_ruleNoQuoteString= ruleNoQuoteString EOF + // InternalBehaviorAnnexParser.g:6269:53: (iv_ruleNoQuoteString= ruleNoQuoteString EOF ) + // InternalBehaviorAnnexParser.g:6270:2: iv_ruleNoQuoteString= ruleNoQuoteString EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNoQuoteStringRule()); @@ -17897,7 +18338,7 @@ public final String entryRuleNoQuoteString() throws RecognitionException { // $ANTLR start "ruleNoQuoteString" - // InternalBehaviorAnnexParser.g:6181:1: ruleNoQuoteString returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_STRING_0= RULE_STRING ; + // InternalBehaviorAnnexParser.g:6276:1: ruleNoQuoteString returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_STRING_0= RULE_STRING ; public final AntlrDatatypeRuleToken ruleNoQuoteString() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -17907,8 +18348,8 @@ public final AntlrDatatypeRuleToken ruleNoQuoteString() throws RecognitionExcept enterRule(); try { - // InternalBehaviorAnnexParser.g:6187:2: (this_STRING_0= RULE_STRING ) - // InternalBehaviorAnnexParser.g:6188:2: this_STRING_0= RULE_STRING + // InternalBehaviorAnnexParser.g:6282:2: (this_STRING_0= RULE_STRING ) + // InternalBehaviorAnnexParser.g:6283: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 ) { @@ -17943,7 +18384,7 @@ public final AntlrDatatypeRuleToken ruleNoQuoteString() throws RecognitionExcept // $ANTLR start "entryRuleArrayRange" - // InternalBehaviorAnnexParser.g:6198:1: entryRuleArrayRange returns [EObject current=null] : iv_ruleArrayRange= ruleArrayRange EOF ; + // InternalBehaviorAnnexParser.g:6293:1: entryRuleArrayRange returns [EObject current=null] : iv_ruleArrayRange= ruleArrayRange EOF ; public final EObject entryRuleArrayRange() throws RecognitionException { EObject current = null; @@ -17951,8 +18392,8 @@ public final EObject entryRuleArrayRange() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6198:51: (iv_ruleArrayRange= ruleArrayRange EOF ) - // InternalBehaviorAnnexParser.g:6199:2: iv_ruleArrayRange= ruleArrayRange EOF + // InternalBehaviorAnnexParser.g:6293:51: (iv_ruleArrayRange= ruleArrayRange EOF ) + // InternalBehaviorAnnexParser.g:6294:2: iv_ruleArrayRange= ruleArrayRange EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getArrayRangeRule()); @@ -17983,7 +18424,7 @@ public final EObject entryRuleArrayRange() throws RecognitionException { // $ANTLR start "ruleArrayRange" - // InternalBehaviorAnnexParser.g:6205: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: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 ) ; public final EObject ruleArrayRange() throws RecognitionException { EObject current = null; @@ -17999,14 +18440,14 @@ public final EObject ruleArrayRange() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6211:2: ( ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) ) - // InternalBehaviorAnnexParser.g:6212:2: ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) + // 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:6212:2: ( () otherlv_1= LeftSquareBracket ( (lv_lowerBound_2_0= ruleINTVALUE ) ) (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? otherlv_5= RightSquareBracket ) - // InternalBehaviorAnnexParser.g:6213:3: () 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:6213:3: () - // InternalBehaviorAnnexParser.g:6214:4: + // InternalBehaviorAnnexParser.g:6308:3: () + // InternalBehaviorAnnexParser.g:6309:4: { if ( state.backtracking==0 ) { @@ -18024,18 +18465,18 @@ public final EObject ruleArrayRange() throws RecognitionException { newLeafNode(otherlv_1, grammarAccess.getArrayRangeAccess().getLeftSquareBracketKeyword_1()); } - // InternalBehaviorAnnexParser.g:6224:3: ( (lv_lowerBound_2_0= ruleINTVALUE ) ) - // InternalBehaviorAnnexParser.g:6225:4: (lv_lowerBound_2_0= ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:6319:3: ( (lv_lowerBound_2_0= ruleINTVALUE ) ) + // InternalBehaviorAnnexParser.g:6320:4: (lv_lowerBound_2_0= ruleINTVALUE ) { - // InternalBehaviorAnnexParser.g:6225:4: (lv_lowerBound_2_0= ruleINTVALUE ) - // InternalBehaviorAnnexParser.g:6226:5: lv_lowerBound_2_0= ruleINTVALUE + // InternalBehaviorAnnexParser.g:6320:4: (lv_lowerBound_2_0= ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:6321:5: lv_lowerBound_2_0= ruleINTVALUE { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getArrayRangeAccess().getLowerBoundINTVALUEParserRuleCall_2_0()); } - pushFollow(FollowSets000.FOLLOW_84); + pushFollow(FollowSets000.FOLLOW_86); lv_lowerBound_2_0=ruleINTVALUE(); state._fsp--; @@ -18059,16 +18500,16 @@ public final EObject ruleArrayRange() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6243:3: (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? - int alt105=2; - int LA105_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6338:3: (otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) )? + int alt107=2; + int LA107_0 = input.LA(1); - if ( (LA105_0==FullStopFullStop) ) { - alt105=1; + if ( (LA107_0==FullStopFullStop) ) { + alt107=1; } - switch (alt105) { + switch (alt107) { case 1 : - // InternalBehaviorAnnexParser.g:6244:4: otherlv_3= FullStopFullStop ( (lv_upperBound_4_0= ruleINTVALUE ) ) + // InternalBehaviorAnnexParser.g:6339: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 ) { @@ -18076,11 +18517,11 @@ public final EObject ruleArrayRange() throws RecognitionException { newLeafNode(otherlv_3, grammarAccess.getArrayRangeAccess().getFullStopFullStopKeyword_3_0()); } - // InternalBehaviorAnnexParser.g:6248:4: ( (lv_upperBound_4_0= ruleINTVALUE ) ) - // InternalBehaviorAnnexParser.g:6249:5: (lv_upperBound_4_0= ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:6343:4: ( (lv_upperBound_4_0= ruleINTVALUE ) ) + // InternalBehaviorAnnexParser.g:6344:5: (lv_upperBound_4_0= ruleINTVALUE ) { - // InternalBehaviorAnnexParser.g:6249:5: (lv_upperBound_4_0= ruleINTVALUE ) - // InternalBehaviorAnnexParser.g:6250:6: lv_upperBound_4_0= ruleINTVALUE + // InternalBehaviorAnnexParser.g:6344:5: (lv_upperBound_4_0= ruleINTVALUE ) + // InternalBehaviorAnnexParser.g:6345:6: lv_upperBound_4_0= ruleINTVALUE { if ( state.backtracking==0 ) { @@ -18148,7 +18589,7 @@ public final EObject ruleArrayRange() throws RecognitionException { // $ANTLR start "entryRuleSignedConstant" - // InternalBehaviorAnnexParser.g:6276:1: entryRuleSignedConstant returns [EObject current=null] : iv_ruleSignedConstant= ruleSignedConstant EOF ; + // InternalBehaviorAnnexParser.g:6371:1: entryRuleSignedConstant returns [EObject current=null] : iv_ruleSignedConstant= ruleSignedConstant EOF ; public final EObject entryRuleSignedConstant() throws RecognitionException { EObject current = null; @@ -18156,8 +18597,8 @@ public final EObject entryRuleSignedConstant() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6276:55: (iv_ruleSignedConstant= ruleSignedConstant EOF ) - // InternalBehaviorAnnexParser.g:6277:2: iv_ruleSignedConstant= ruleSignedConstant EOF + // InternalBehaviorAnnexParser.g:6371:55: (iv_ruleSignedConstant= ruleSignedConstant EOF ) + // InternalBehaviorAnnexParser.g:6372:2: iv_ruleSignedConstant= ruleSignedConstant EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSignedConstantRule()); @@ -18188,7 +18629,7 @@ public final EObject entryRuleSignedConstant() throws RecognitionException { // $ANTLR start "ruleSignedConstant" - // InternalBehaviorAnnexParser.g:6283:1: ruleSignedConstant returns [EObject current=null] : ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) ; + // InternalBehaviorAnnexParser.g:6378: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; @@ -18201,24 +18642,24 @@ public final EObject ruleSignedConstant() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6289:2: ( ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) ) - // InternalBehaviorAnnexParser.g:6290:2: ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) + // 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:6290:2: ( ( (lv_op_0_0= rulePlusMinus ) ) ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) ) - // InternalBehaviorAnnexParser.g:6291:3: ( (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:6291:3: ( (lv_op_0_0= rulePlusMinus ) ) - // InternalBehaviorAnnexParser.g:6292:4: (lv_op_0_0= rulePlusMinus ) + // InternalBehaviorAnnexParser.g:6386:3: ( (lv_op_0_0= rulePlusMinus ) ) + // InternalBehaviorAnnexParser.g:6387:4: (lv_op_0_0= rulePlusMinus ) { - // InternalBehaviorAnnexParser.g:6292:4: (lv_op_0_0= rulePlusMinus ) - // InternalBehaviorAnnexParser.g:6293:5: lv_op_0_0= rulePlusMinus + // InternalBehaviorAnnexParser.g:6387:4: (lv_op_0_0= rulePlusMinus ) + // InternalBehaviorAnnexParser.g:6388:5: lv_op_0_0= rulePlusMinus { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSignedConstantAccess().getOpPlusMinusParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_85); + pushFollow(FollowSets000.FOLLOW_87); lv_op_0_0=rulePlusMinus(); state._fsp--; @@ -18242,11 +18683,11 @@ public final EObject ruleSignedConstant() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6310:3: ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) - // InternalBehaviorAnnexParser.g:6311:4: (lv_ownedPropertyExpression_1_0= ruleConstantValue ) + // InternalBehaviorAnnexParser.g:6405:3: ( (lv_ownedPropertyExpression_1_0= ruleConstantValue ) ) + // InternalBehaviorAnnexParser.g:6406:4: (lv_ownedPropertyExpression_1_0= ruleConstantValue ) { - // InternalBehaviorAnnexParser.g:6311:4: (lv_ownedPropertyExpression_1_0= ruleConstantValue ) - // InternalBehaviorAnnexParser.g:6312:5: lv_ownedPropertyExpression_1_0= ruleConstantValue + // InternalBehaviorAnnexParser.g:6406:4: (lv_ownedPropertyExpression_1_0= ruleConstantValue ) + // InternalBehaviorAnnexParser.g:6407:5: lv_ownedPropertyExpression_1_0= ruleConstantValue { if ( state.backtracking==0 ) { @@ -18302,7 +18743,7 @@ public final EObject ruleSignedConstant() throws RecognitionException { // $ANTLR start "entryRuleIntegerTerm" - // InternalBehaviorAnnexParser.g:6333:1: entryRuleIntegerTerm returns [EObject current=null] : iv_ruleIntegerTerm= ruleIntegerTerm EOF ; + // InternalBehaviorAnnexParser.g:6428:1: entryRuleIntegerTerm returns [EObject current=null] : iv_ruleIntegerTerm= ruleIntegerTerm EOF ; public final EObject entryRuleIntegerTerm() throws RecognitionException { EObject current = null; @@ -18310,8 +18751,8 @@ public final EObject entryRuleIntegerTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6333:52: (iv_ruleIntegerTerm= ruleIntegerTerm EOF ) - // InternalBehaviorAnnexParser.g:6334:2: iv_ruleIntegerTerm= ruleIntegerTerm EOF + // InternalBehaviorAnnexParser.g:6428:52: (iv_ruleIntegerTerm= ruleIntegerTerm EOF ) + // InternalBehaviorAnnexParser.g:6429:2: iv_ruleIntegerTerm= ruleIntegerTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getIntegerTermRule()); @@ -18342,7 +18783,7 @@ public final EObject entryRuleIntegerTerm() throws RecognitionException { // $ANTLR start "ruleIntegerTerm" - // InternalBehaviorAnnexParser.g:6340:1: ruleIntegerTerm returns [EObject current=null] : ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) ; + // InternalBehaviorAnnexParser.g:6435:1: ruleIntegerTerm returns [EObject current=null] : ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) ; public final EObject ruleIntegerTerm() throws RecognitionException { EObject current = null; @@ -18354,17 +18795,17 @@ public final EObject ruleIntegerTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6346:2: ( ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) ) - // InternalBehaviorAnnexParser.g:6347:2: ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) + // 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:6347:2: ( ( (lv_value_0_0= ruleSignedInt ) ) ( (otherlv_1= RULE_ID ) )? ) - // InternalBehaviorAnnexParser.g:6348:3: ( (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:6348:3: ( (lv_value_0_0= ruleSignedInt ) ) - // InternalBehaviorAnnexParser.g:6349:4: (lv_value_0_0= ruleSignedInt ) + // InternalBehaviorAnnexParser.g:6443:3: ( (lv_value_0_0= ruleSignedInt ) ) + // InternalBehaviorAnnexParser.g:6444:4: (lv_value_0_0= ruleSignedInt ) { - // InternalBehaviorAnnexParser.g:6349:4: (lv_value_0_0= ruleSignedInt ) - // InternalBehaviorAnnexParser.g:6350:5: lv_value_0_0= ruleSignedInt + // InternalBehaviorAnnexParser.g:6444:4: (lv_value_0_0= ruleSignedInt ) + // InternalBehaviorAnnexParser.g:6445:5: lv_value_0_0= ruleSignedInt { if ( state.backtracking==0 ) { @@ -18395,19 +18836,19 @@ public final EObject ruleIntegerTerm() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6367:3: ( (otherlv_1= RULE_ID ) )? - int alt106=2; - int LA106_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6462:3: ( (otherlv_1= RULE_ID ) )? + int alt108=2; + int LA108_0 = input.LA(1); - if ( (LA106_0==RULE_ID) ) { - alt106=1; + if ( (LA108_0==RULE_ID) ) { + alt108=1; } - switch (alt106) { + switch (alt108) { case 1 : - // InternalBehaviorAnnexParser.g:6368:4: (otherlv_1= RULE_ID ) + // InternalBehaviorAnnexParser.g:6463:4: (otherlv_1= RULE_ID ) { - // InternalBehaviorAnnexParser.g:6368:4: (otherlv_1= RULE_ID ) - // InternalBehaviorAnnexParser.g:6369:5: otherlv_1= RULE_ID + // InternalBehaviorAnnexParser.g:6463:4: (otherlv_1= RULE_ID ) + // InternalBehaviorAnnexParser.g:6464:5: otherlv_1= RULE_ID { if ( state.backtracking==0 ) { @@ -18456,7 +18897,7 @@ public final EObject ruleIntegerTerm() throws RecognitionException { // $ANTLR start "entryRuleSignedInt" - // InternalBehaviorAnnexParser.g:6384:1: entryRuleSignedInt returns [String current=null] : iv_ruleSignedInt= ruleSignedInt EOF ; + // InternalBehaviorAnnexParser.g:6479:1: entryRuleSignedInt returns [String current=null] : iv_ruleSignedInt= ruleSignedInt EOF ; public final String entryRuleSignedInt() throws RecognitionException { String current = null; @@ -18464,8 +18905,8 @@ public final String entryRuleSignedInt() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6384:49: (iv_ruleSignedInt= ruleSignedInt EOF ) - // InternalBehaviorAnnexParser.g:6385:2: iv_ruleSignedInt= ruleSignedInt EOF + // InternalBehaviorAnnexParser.g:6479:49: (iv_ruleSignedInt= ruleSignedInt EOF ) + // InternalBehaviorAnnexParser.g:6480:2: iv_ruleSignedInt= ruleSignedInt EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSignedIntRule()); @@ -18496,7 +18937,7 @@ public final String entryRuleSignedInt() throws RecognitionException { // $ANTLR start "ruleSignedInt" - // InternalBehaviorAnnexParser.g:6391:1: ruleSignedInt returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) ; + // InternalBehaviorAnnexParser.g:6486: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(); @@ -18507,25 +18948,25 @@ public final AntlrDatatypeRuleToken ruleSignedInt() throws RecognitionException enterRule(); try { - // InternalBehaviorAnnexParser.g:6397:2: ( ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) ) - // InternalBehaviorAnnexParser.g:6398:2: ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) + // 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:6398:2: ( (kw= PlusSign | kw= HyphenMinus )? this_INTEGER_LIT_2= RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:6399:3: (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:6399:3: (kw= PlusSign | kw= HyphenMinus )? - int alt107=3; - int LA107_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6494:3: (kw= PlusSign | kw= HyphenMinus )? + int alt109=3; + int LA109_0 = input.LA(1); - if ( (LA107_0==PlusSign) ) { - alt107=1; + if ( (LA109_0==PlusSign) ) { + alt109=1; } - else if ( (LA107_0==HyphenMinus) ) { - alt107=2; + else if ( (LA109_0==HyphenMinus) ) { + alt109=2; } - switch (alt107) { + switch (alt109) { case 1 : - // InternalBehaviorAnnexParser.g:6400:4: kw= PlusSign + // InternalBehaviorAnnexParser.g:6495:4: kw= PlusSign { kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -18538,7 +18979,7 @@ else if ( (LA107_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:6406:4: kw= HyphenMinus + // InternalBehaviorAnnexParser.g:6501:4: kw= HyphenMinus { kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -18589,7 +19030,7 @@ else if ( (LA107_0==HyphenMinus) ) { // $ANTLR start "entryRuleRealTerm" - // InternalBehaviorAnnexParser.g:6423:1: entryRuleRealTerm returns [EObject current=null] : iv_ruleRealTerm= ruleRealTerm EOF ; + // InternalBehaviorAnnexParser.g:6518:1: entryRuleRealTerm returns [EObject current=null] : iv_ruleRealTerm= ruleRealTerm EOF ; public final EObject entryRuleRealTerm() throws RecognitionException { EObject current = null; @@ -18597,8 +19038,8 @@ public final EObject entryRuleRealTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6423:49: (iv_ruleRealTerm= ruleRealTerm EOF ) - // InternalBehaviorAnnexParser.g:6424:2: iv_ruleRealTerm= ruleRealTerm EOF + // InternalBehaviorAnnexParser.g:6518:49: (iv_ruleRealTerm= ruleRealTerm EOF ) + // InternalBehaviorAnnexParser.g:6519:2: iv_ruleRealTerm= ruleRealTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getRealTermRule()); @@ -18629,7 +19070,7 @@ public final EObject entryRuleRealTerm() throws RecognitionException { // $ANTLR start "ruleRealTerm" - // InternalBehaviorAnnexParser.g:6430:1: ruleRealTerm returns [EObject current=null] : ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) ; + // InternalBehaviorAnnexParser.g:6525:1: ruleRealTerm returns [EObject current=null] : ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) ; public final EObject ruleRealTerm() throws RecognitionException { EObject current = null; @@ -18641,17 +19082,17 @@ public final EObject ruleRealTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6436:2: ( ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) ) - // InternalBehaviorAnnexParser.g:6437:2: ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) + // 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:6437:2: ( ( (lv_value_0_0= ruleSignedReal ) ) ( (otherlv_1= RULE_ID ) )? ) - // InternalBehaviorAnnexParser.g:6438:3: ( (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:6438:3: ( (lv_value_0_0= ruleSignedReal ) ) - // InternalBehaviorAnnexParser.g:6439:4: (lv_value_0_0= ruleSignedReal ) + // InternalBehaviorAnnexParser.g:6533:3: ( (lv_value_0_0= ruleSignedReal ) ) + // InternalBehaviorAnnexParser.g:6534:4: (lv_value_0_0= ruleSignedReal ) { - // InternalBehaviorAnnexParser.g:6439:4: (lv_value_0_0= ruleSignedReal ) - // InternalBehaviorAnnexParser.g:6440:5: lv_value_0_0= ruleSignedReal + // InternalBehaviorAnnexParser.g:6534:4: (lv_value_0_0= ruleSignedReal ) + // InternalBehaviorAnnexParser.g:6535:5: lv_value_0_0= ruleSignedReal { if ( state.backtracking==0 ) { @@ -18682,19 +19123,19 @@ public final EObject ruleRealTerm() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6457:3: ( (otherlv_1= RULE_ID ) )? - int alt108=2; - int LA108_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6552:3: ( (otherlv_1= RULE_ID ) )? + int alt110=2; + int LA110_0 = input.LA(1); - if ( (LA108_0==RULE_ID) ) { - alt108=1; + if ( (LA110_0==RULE_ID) ) { + alt110=1; } - switch (alt108) { + switch (alt110) { case 1 : - // InternalBehaviorAnnexParser.g:6458:4: (otherlv_1= RULE_ID ) + // InternalBehaviorAnnexParser.g:6553:4: (otherlv_1= RULE_ID ) { - // InternalBehaviorAnnexParser.g:6458:4: (otherlv_1= RULE_ID ) - // InternalBehaviorAnnexParser.g:6459:5: otherlv_1= RULE_ID + // InternalBehaviorAnnexParser.g:6553:4: (otherlv_1= RULE_ID ) + // InternalBehaviorAnnexParser.g:6554:5: otherlv_1= RULE_ID { if ( state.backtracking==0 ) { @@ -18743,7 +19184,7 @@ public final EObject ruleRealTerm() throws RecognitionException { // $ANTLR start "entryRuleSignedReal" - // InternalBehaviorAnnexParser.g:6474:1: entryRuleSignedReal returns [String current=null] : iv_ruleSignedReal= ruleSignedReal EOF ; + // InternalBehaviorAnnexParser.g:6569:1: entryRuleSignedReal returns [String current=null] : iv_ruleSignedReal= ruleSignedReal EOF ; public final String entryRuleSignedReal() throws RecognitionException { String current = null; @@ -18751,8 +19192,8 @@ public final String entryRuleSignedReal() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6474:50: (iv_ruleSignedReal= ruleSignedReal EOF ) - // InternalBehaviorAnnexParser.g:6475:2: iv_ruleSignedReal= ruleSignedReal EOF + // InternalBehaviorAnnexParser.g:6569:50: (iv_ruleSignedReal= ruleSignedReal EOF ) + // InternalBehaviorAnnexParser.g:6570:2: iv_ruleSignedReal= ruleSignedReal EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSignedRealRule()); @@ -18783,7 +19224,7 @@ public final String entryRuleSignedReal() throws RecognitionException { // $ANTLR start "ruleSignedReal" - // InternalBehaviorAnnexParser.g:6481:1: ruleSignedReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) ; + // InternalBehaviorAnnexParser.g:6576: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(); @@ -18794,27 +19235,27 @@ public final AntlrDatatypeRuleToken ruleSignedReal() throws RecognitionException enterRule(); try { - // InternalBehaviorAnnexParser.g:6487:2: ( ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) ) - // InternalBehaviorAnnexParser.g:6488:2: ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) + // 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:6488:2: ( (kw= PlusSign | kw= HyphenMinus )? this_REAL_LIT_2= RULE_REAL_LIT ) - // InternalBehaviorAnnexParser.g:6489:3: (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:6489:3: (kw= PlusSign | kw= HyphenMinus )? - int alt109=3; - int LA109_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6584:3: (kw= PlusSign | kw= HyphenMinus )? + int alt111=3; + int LA111_0 = input.LA(1); - if ( (LA109_0==PlusSign) ) { - alt109=1; + if ( (LA111_0==PlusSign) ) { + alt111=1; } - else if ( (LA109_0==HyphenMinus) ) { - alt109=2; + else if ( (LA111_0==HyphenMinus) ) { + alt111=2; } - switch (alt109) { + switch (alt111) { case 1 : - // InternalBehaviorAnnexParser.g:6490:4: kw= PlusSign + // InternalBehaviorAnnexParser.g:6585:4: kw= PlusSign { - kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_86); if (state.failed) return current; + kw=(Token)match(input,PlusSign,FollowSets000.FOLLOW_88); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(kw); @@ -18825,9 +19266,9 @@ else if ( (LA109_0==HyphenMinus) ) { } break; case 2 : - // InternalBehaviorAnnexParser.g:6496:4: kw= HyphenMinus + // InternalBehaviorAnnexParser.g:6591:4: kw= HyphenMinus { - kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_86); if (state.failed) return current; + kw=(Token)match(input,HyphenMinus,FollowSets000.FOLLOW_88); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(kw); @@ -18876,7 +19317,7 @@ else if ( (LA109_0==HyphenMinus) ) { // $ANTLR start "entryRuleNumericRangeTerm" - // InternalBehaviorAnnexParser.g:6513:1: entryRuleNumericRangeTerm returns [EObject current=null] : iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF ; + // InternalBehaviorAnnexParser.g:6608:1: entryRuleNumericRangeTerm returns [EObject current=null] : iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF ; public final EObject entryRuleNumericRangeTerm() throws RecognitionException { EObject current = null; @@ -18884,8 +19325,8 @@ public final EObject entryRuleNumericRangeTerm() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6513:57: (iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF ) - // InternalBehaviorAnnexParser.g:6514:2: iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF + // InternalBehaviorAnnexParser.g:6608:57: (iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF ) + // InternalBehaviorAnnexParser.g:6609:2: iv_ruleNumericRangeTerm= ruleNumericRangeTerm EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNumericRangeTermRule()); @@ -18916,7 +19357,7 @@ public final EObject entryRuleNumericRangeTerm() throws RecognitionException { // $ANTLR start "ruleNumericRangeTerm" - // InternalBehaviorAnnexParser.g:6520: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: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 ) ) )? ) ; public final EObject ruleNumericRangeTerm() throws RecognitionException { EObject current = null; @@ -18933,24 +19374,24 @@ public final EObject ruleNumericRangeTerm() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6526:2: ( ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) ) - // InternalBehaviorAnnexParser.g:6527:2: ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) + // 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:6527:2: ( ( (lv_minimum_0_0= ruleNumAlt ) ) otherlv_1= FullStopFullStop ( (lv_maximum_2_0= ruleNumAlt ) ) (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? ) - // InternalBehaviorAnnexParser.g:6528:3: ( (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:6528:3: ( (lv_minimum_0_0= ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:6529:4: (lv_minimum_0_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6623:3: ( (lv_minimum_0_0= ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:6624:4: (lv_minimum_0_0= ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:6529:4: (lv_minimum_0_0= ruleNumAlt ) - // InternalBehaviorAnnexParser.g:6530:5: lv_minimum_0_0= ruleNumAlt + // InternalBehaviorAnnexParser.g:6624:4: (lv_minimum_0_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6625:5: lv_minimum_0_0= ruleNumAlt { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNumericRangeTermAccess().getMinimumNumAltParserRuleCall_0_0()); } - pushFollow(FollowSets000.FOLLOW_87); + pushFollow(FollowSets000.FOLLOW_89); lv_minimum_0_0=ruleNumAlt(); state._fsp--; @@ -18974,24 +19415,24 @@ public final EObject ruleNumericRangeTerm() throws RecognitionException { } - otherlv_1=(Token)match(input,FullStopFullStop,FollowSets000.FOLLOW_85); if (state.failed) return current; + otherlv_1=(Token)match(input,FullStopFullStop,FollowSets000.FOLLOW_87); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getNumericRangeTermAccess().getFullStopFullStopKeyword_1()); } - // InternalBehaviorAnnexParser.g:6551:3: ( (lv_maximum_2_0= ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:6552:4: (lv_maximum_2_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6646:3: ( (lv_maximum_2_0= ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:6647:4: (lv_maximum_2_0= ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:6552:4: (lv_maximum_2_0= ruleNumAlt ) - // InternalBehaviorAnnexParser.g:6553:5: lv_maximum_2_0= ruleNumAlt + // InternalBehaviorAnnexParser.g:6647:4: (lv_maximum_2_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6648:5: lv_maximum_2_0= ruleNumAlt { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNumericRangeTermAccess().getMaximumNumAltParserRuleCall_2_0()); } - pushFollow(FollowSets000.FOLLOW_88); + pushFollow(FollowSets000.FOLLOW_90); lv_maximum_2_0=ruleNumAlt(); state._fsp--; @@ -19015,28 +19456,28 @@ public final EObject ruleNumericRangeTerm() throws RecognitionException { } - // InternalBehaviorAnnexParser.g:6570:3: (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? - int alt110=2; - int LA110_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6665:3: (otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) )? + int alt112=2; + int LA112_0 = input.LA(1); - if ( (LA110_0==Delta) ) { - alt110=1; + if ( (LA112_0==Delta) ) { + alt112=1; } - switch (alt110) { + switch (alt112) { case 1 : - // InternalBehaviorAnnexParser.g:6571:4: otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:6666:4: otherlv_3= Delta ( (lv_delta_4_0= ruleNumAlt ) ) { - otherlv_3=(Token)match(input,Delta,FollowSets000.FOLLOW_85); if (state.failed) return current; + otherlv_3=(Token)match(input,Delta,FollowSets000.FOLLOW_87); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getNumericRangeTermAccess().getDeltaKeyword_3_0()); } - // InternalBehaviorAnnexParser.g:6575:4: ( (lv_delta_4_0= ruleNumAlt ) ) - // InternalBehaviorAnnexParser.g:6576:5: (lv_delta_4_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6670:4: ( (lv_delta_4_0= ruleNumAlt ) ) + // InternalBehaviorAnnexParser.g:6671:5: (lv_delta_4_0= ruleNumAlt ) { - // InternalBehaviorAnnexParser.g:6576:5: (lv_delta_4_0= ruleNumAlt ) - // InternalBehaviorAnnexParser.g:6577:6: lv_delta_4_0= ruleNumAlt + // InternalBehaviorAnnexParser.g:6671:5: (lv_delta_4_0= ruleNumAlt ) + // InternalBehaviorAnnexParser.g:6672:6: lv_delta_4_0= ruleNumAlt { if ( state.backtracking==0 ) { @@ -19098,7 +19539,7 @@ public final EObject ruleNumericRangeTerm() throws RecognitionException { // $ANTLR start "entryRuleNumAlt" - // InternalBehaviorAnnexParser.g:6599:1: entryRuleNumAlt returns [EObject current=null] : iv_ruleNumAlt= ruleNumAlt EOF ; + // InternalBehaviorAnnexParser.g:6694:1: entryRuleNumAlt returns [EObject current=null] : iv_ruleNumAlt= ruleNumAlt EOF ; public final EObject entryRuleNumAlt() throws RecognitionException { EObject current = null; @@ -19106,8 +19547,8 @@ public final EObject entryRuleNumAlt() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6599:47: (iv_ruleNumAlt= ruleNumAlt EOF ) - // InternalBehaviorAnnexParser.g:6600:2: iv_ruleNumAlt= ruleNumAlt EOF + // InternalBehaviorAnnexParser.g:6694:47: (iv_ruleNumAlt= ruleNumAlt EOF ) + // InternalBehaviorAnnexParser.g:6695:2: iv_ruleNumAlt= ruleNumAlt EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getNumAltRule()); @@ -19138,7 +19579,7 @@ public final EObject entryRuleNumAlt() throws RecognitionException { // $ANTLR start "ruleNumAlt" - // InternalBehaviorAnnexParser.g:6606:1: ruleNumAlt returns [EObject current=null] : (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) ; + // 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 ) ; public final EObject ruleNumAlt() throws RecognitionException { EObject current = null; @@ -19155,34 +19596,34 @@ public final EObject ruleNumAlt() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6612:2: ( (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) ) - // InternalBehaviorAnnexParser.g:6613:2: (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) + // 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:6613:2: (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) - int alt111=4; + // InternalBehaviorAnnexParser.g:6708:2: (this_RealTerm_0= ruleRealTerm | this_IntegerTerm_1= ruleIntegerTerm | this_SignedConstant_2= ruleSignedConstant | this_ConstantValue_3= ruleConstantValue ) + int alt113=4; switch ( input.LA(1) ) { case PlusSign: { switch ( input.LA(2) ) { case RULE_REAL_LIT: { - alt111=1; + alt113=1; } break; case RULE_INTEGER_LIT: { - alt111=2; + alt113=2; } break; case RULE_ID: { - alt111=3; + alt113=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 111, 1, input); + new NoViableAltException("", 113, 1, input); throw nvae; } @@ -19194,23 +19635,23 @@ public final EObject ruleNumAlt() throws RecognitionException { switch ( input.LA(2) ) { case RULE_REAL_LIT: { - alt111=1; + alt113=1; } break; case RULE_INTEGER_LIT: { - alt111=2; + alt113=2; } break; case RULE_ID: { - alt111=3; + alt113=3; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 111, 2, input); + new NoViableAltException("", 113, 2, input); throw nvae; } @@ -19219,30 +19660,30 @@ public final EObject ruleNumAlt() throws RecognitionException { break; case RULE_REAL_LIT: { - alt111=1; + alt113=1; } break; case RULE_INTEGER_LIT: { - alt111=2; + alt113=2; } break; case RULE_ID: { - alt111=4; + alt113=4; } break; default: if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = - new NoViableAltException("", 111, 0, input); + new NoViableAltException("", 113, 0, input); throw nvae; } - switch (alt111) { + switch (alt113) { case 1 : - // InternalBehaviorAnnexParser.g:6614:3: this_RealTerm_0= ruleRealTerm + // InternalBehaviorAnnexParser.g:6709:3: this_RealTerm_0= ruleRealTerm { if ( state.backtracking==0 ) { @@ -19264,7 +19705,7 @@ public final EObject ruleNumAlt() throws RecognitionException { } break; case 2 : - // InternalBehaviorAnnexParser.g:6623:3: this_IntegerTerm_1= ruleIntegerTerm + // InternalBehaviorAnnexParser.g:6718:3: this_IntegerTerm_1= ruleIntegerTerm { if ( state.backtracking==0 ) { @@ -19286,7 +19727,7 @@ public final EObject ruleNumAlt() throws RecognitionException { } break; case 3 : - // InternalBehaviorAnnexParser.g:6632:3: this_SignedConstant_2= ruleSignedConstant + // InternalBehaviorAnnexParser.g:6727:3: this_SignedConstant_2= ruleSignedConstant { if ( state.backtracking==0 ) { @@ -19308,7 +19749,7 @@ public final EObject ruleNumAlt() throws RecognitionException { } break; case 4 : - // InternalBehaviorAnnexParser.g:6641:3: this_ConstantValue_3= ruleConstantValue + // InternalBehaviorAnnexParser.g:6736:3: this_ConstantValue_3= ruleConstantValue { if ( state.backtracking==0 ) { @@ -19354,7 +19795,7 @@ public final EObject ruleNumAlt() throws RecognitionException { // $ANTLR start "entryRuleINTVALUE" - // InternalBehaviorAnnexParser.g:6653:1: entryRuleINTVALUE returns [String current=null] : iv_ruleINTVALUE= ruleINTVALUE EOF ; + // InternalBehaviorAnnexParser.g:6748:1: entryRuleINTVALUE returns [String current=null] : iv_ruleINTVALUE= ruleINTVALUE EOF ; public final String entryRuleINTVALUE() throws RecognitionException { String current = null; @@ -19362,8 +19803,8 @@ public final String entryRuleINTVALUE() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6653:48: (iv_ruleINTVALUE= ruleINTVALUE EOF ) - // InternalBehaviorAnnexParser.g:6654:2: iv_ruleINTVALUE= ruleINTVALUE EOF + // InternalBehaviorAnnexParser.g:6748:48: (iv_ruleINTVALUE= ruleINTVALUE EOF ) + // InternalBehaviorAnnexParser.g:6749:2: iv_ruleINTVALUE= ruleINTVALUE EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getINTVALUERule()); @@ -19394,7 +19835,7 @@ public final String entryRuleINTVALUE() throws RecognitionException { // $ANTLR start "ruleINTVALUE" - // InternalBehaviorAnnexParser.g:6660:1: ruleINTVALUE returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_INTEGER_LIT_0= RULE_INTEGER_LIT ; + // InternalBehaviorAnnexParser.g:6755:1: ruleINTVALUE returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_INTEGER_LIT_0= RULE_INTEGER_LIT ; public final AntlrDatatypeRuleToken ruleINTVALUE() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -19404,8 +19845,8 @@ public final AntlrDatatypeRuleToken ruleINTVALUE() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6666:2: (this_INTEGER_LIT_0= RULE_INTEGER_LIT ) - // InternalBehaviorAnnexParser.g:6667:2: this_INTEGER_LIT_0= RULE_INTEGER_LIT + // InternalBehaviorAnnexParser.g:6761:2: (this_INTEGER_LIT_0= RULE_INTEGER_LIT ) + // InternalBehaviorAnnexParser.g:6762: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 ) { @@ -19440,7 +19881,7 @@ public final AntlrDatatypeRuleToken ruleINTVALUE() throws RecognitionException { // $ANTLR start "entryRuleQPREF" - // InternalBehaviorAnnexParser.g:6677:1: entryRuleQPREF returns [String current=null] : iv_ruleQPREF= ruleQPREF EOF ; + // InternalBehaviorAnnexParser.g:6772:1: entryRuleQPREF returns [String current=null] : iv_ruleQPREF= ruleQPREF EOF ; public final String entryRuleQPREF() throws RecognitionException { String current = null; @@ -19448,8 +19889,8 @@ public final String entryRuleQPREF() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6677:45: (iv_ruleQPREF= ruleQPREF EOF ) - // InternalBehaviorAnnexParser.g:6678:2: iv_ruleQPREF= ruleQPREF EOF + // InternalBehaviorAnnexParser.g:6772:45: (iv_ruleQPREF= ruleQPREF EOF ) + // InternalBehaviorAnnexParser.g:6773:2: iv_ruleQPREF= ruleQPREF EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getQPREFRule()); @@ -19480,7 +19921,7 @@ public final String entryRuleQPREF() throws RecognitionException { // $ANTLR start "ruleQPREF" - // InternalBehaviorAnnexParser.g:6684:1: ruleQPREF returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) ; + // InternalBehaviorAnnexParser.g:6779: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(); @@ -19492,13 +19933,13 @@ public final AntlrDatatypeRuleToken ruleQPREF() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6690:2: ( (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) ) - // InternalBehaviorAnnexParser.g:6691:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) + // 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:6691:2: (this_ID_0= RULE_ID (kw= ColonColon this_ID_2= RULE_ID )? ) - // InternalBehaviorAnnexParser.g:6692:3: 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 )? { - this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_75); if (state.failed) return current; + this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_77); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(this_ID_0); @@ -19509,16 +19950,16 @@ public final AntlrDatatypeRuleToken ruleQPREF() throws RecognitionException { newLeafNode(this_ID_0, grammarAccess.getQPREFAccess().getIDTerminalRuleCall_0()); } - // InternalBehaviorAnnexParser.g:6699:3: (kw= ColonColon this_ID_2= RULE_ID )? - int alt112=2; - int LA112_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6794:3: (kw= ColonColon this_ID_2= RULE_ID )? + int alt114=2; + int LA114_0 = input.LA(1); - if ( (LA112_0==ColonColon) ) { - alt112=1; + if ( (LA114_0==ColonColon) ) { + alt114=1; } - switch (alt112) { + switch (alt114) { case 1 : - // InternalBehaviorAnnexParser.g:6700:4: kw= ColonColon this_ID_2= RULE_ID + // InternalBehaviorAnnexParser.g:6795: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 ) { @@ -19569,7 +20010,7 @@ public final AntlrDatatypeRuleToken ruleQPREF() throws RecognitionException { // $ANTLR start "entryRuleQCREF" - // InternalBehaviorAnnexParser.g:6717:1: entryRuleQCREF returns [String current=null] : iv_ruleQCREF= ruleQCREF EOF ; + // InternalBehaviorAnnexParser.g:6812:1: entryRuleQCREF returns [String current=null] : iv_ruleQCREF= ruleQCREF EOF ; public final String entryRuleQCREF() throws RecognitionException { String current = null; @@ -19577,8 +20018,8 @@ public final String entryRuleQCREF() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6717:45: (iv_ruleQCREF= ruleQCREF EOF ) - // InternalBehaviorAnnexParser.g:6718:2: iv_ruleQCREF= ruleQCREF EOF + // InternalBehaviorAnnexParser.g:6812:45: (iv_ruleQCREF= ruleQCREF EOF ) + // InternalBehaviorAnnexParser.g:6813:2: iv_ruleQCREF= ruleQCREF EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getQCREFRule()); @@ -19609,7 +20050,7 @@ public final String entryRuleQCREF() throws RecognitionException { // $ANTLR start "ruleQCREF" - // InternalBehaviorAnnexParser.g:6724: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: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 )? ) ; public final AntlrDatatypeRuleToken ruleQCREF() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -19622,34 +20063,34 @@ public final AntlrDatatypeRuleToken ruleQCREF() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6730:2: ( ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) ) - // InternalBehaviorAnnexParser.g:6731:2: ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) + // 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:6731:2: ( (this_ID_0= RULE_ID kw= ColonColon )* this_ID_2= RULE_ID (kw= FullStop this_ID_4= RULE_ID )? ) - // InternalBehaviorAnnexParser.g:6732:3: (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:6732:3: (this_ID_0= RULE_ID kw= ColonColon )* - loop113: + // InternalBehaviorAnnexParser.g:6827:3: (this_ID_0= RULE_ID kw= ColonColon )* + loop115: do { - int alt113=2; - int LA113_0 = input.LA(1); + int alt115=2; + int LA115_0 = input.LA(1); - if ( (LA113_0==RULE_ID) ) { - int LA113_1 = input.LA(2); + if ( (LA115_0==RULE_ID) ) { + int LA115_1 = input.LA(2); - if ( (LA113_1==ColonColon) ) { - alt113=1; + if ( (LA115_1==ColonColon) ) { + alt115=1; } } - switch (alt113) { + switch (alt115) { case 1 : - // InternalBehaviorAnnexParser.g:6733:4: this_ID_0= RULE_ID kw= ColonColon + // InternalBehaviorAnnexParser.g:6828:4: this_ID_0= RULE_ID kw= ColonColon { - this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_89); if (state.failed) return current; + this_ID_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_91); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(this_ID_0); @@ -19672,11 +20113,11 @@ public final AntlrDatatypeRuleToken ruleQCREF() throws RecognitionException { break; default : - break loop113; + break loop115; } } while (true); - this_ID_2=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_71); if (state.failed) return current; + this_ID_2=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_73); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(this_ID_2); @@ -19687,16 +20128,16 @@ public final AntlrDatatypeRuleToken ruleQCREF() throws RecognitionException { newLeafNode(this_ID_2, grammarAccess.getQCREFAccess().getIDTerminalRuleCall_1()); } - // InternalBehaviorAnnexParser.g:6753:3: (kw= FullStop this_ID_4= RULE_ID )? - int alt114=2; - int LA114_0 = input.LA(1); + // InternalBehaviorAnnexParser.g:6848:3: (kw= FullStop this_ID_4= RULE_ID )? + int alt116=2; + int LA116_0 = input.LA(1); - if ( (LA114_0==FullStop) ) { - alt114=1; + if ( (LA116_0==FullStop) ) { + alt116=1; } - switch (alt114) { + switch (alt116) { case 1 : - // InternalBehaviorAnnexParser.g:6754:4: kw= FullStop this_ID_4= RULE_ID + // InternalBehaviorAnnexParser.g:6849: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 ) { @@ -19747,7 +20188,7 @@ public final AntlrDatatypeRuleToken ruleQCREF() throws RecognitionException { // $ANTLR start "entryRuleSTAR" - // InternalBehaviorAnnexParser.g:6771:1: entryRuleSTAR returns [String current=null] : iv_ruleSTAR= ruleSTAR EOF ; + // InternalBehaviorAnnexParser.g:6866:1: entryRuleSTAR returns [String current=null] : iv_ruleSTAR= ruleSTAR EOF ; public final String entryRuleSTAR() throws RecognitionException { String current = null; @@ -19755,8 +20196,8 @@ public final String entryRuleSTAR() throws RecognitionException { try { - // InternalBehaviorAnnexParser.g:6771:44: (iv_ruleSTAR= ruleSTAR EOF ) - // InternalBehaviorAnnexParser.g:6772:2: iv_ruleSTAR= ruleSTAR EOF + // InternalBehaviorAnnexParser.g:6866:44: (iv_ruleSTAR= ruleSTAR EOF ) + // InternalBehaviorAnnexParser.g:6867:2: iv_ruleSTAR= ruleSTAR EOF { if ( state.backtracking==0 ) { newCompositeNode(grammarAccess.getSTARRule()); @@ -19787,7 +20228,7 @@ public final String entryRuleSTAR() throws RecognitionException { // $ANTLR start "ruleSTAR" - // InternalBehaviorAnnexParser.g:6778:1: ruleSTAR returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= Asterisk ; + // InternalBehaviorAnnexParser.g:6873:1: ruleSTAR returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= Asterisk ; public final AntlrDatatypeRuleToken ruleSTAR() throws RecognitionException { AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); @@ -19797,8 +20238,8 @@ public final AntlrDatatypeRuleToken ruleSTAR() throws RecognitionException { enterRule(); try { - // InternalBehaviorAnnexParser.g:6784:2: (kw= Asterisk ) - // InternalBehaviorAnnexParser.g:6785:2: kw= Asterisk + // InternalBehaviorAnnexParser.g:6879:2: (kw= Asterisk ) + // InternalBehaviorAnnexParser.g:6880:2: kw= Asterisk { kw=(Token)match(input,Asterisk,FollowSets000.FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { @@ -19861,7 +20302,7 @@ public final boolean synpred1_InternalBehaviorAnnexParser() { protected DFA41 dfa41 = new DFA41(this); - protected DFA97 dfa97 = new DFA97(this); + protected DFA99 dfa99 = new DFA99(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"; @@ -19969,11 +20410,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 DFA97 extends DFA { + class DFA99 extends DFA { - public DFA97(BaseRecognizer recognizer) { + public DFA99(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 97; + this.decisionNumber = 99; this.eot = dfa_7; this.eof = dfa_8; this.min = dfa_9; @@ -19983,7 +20424,7 @@ public DFA97(BaseRecognizer recognizer) { this.transition = dfa_13; } public String getDescription() { - return "5483: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 "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 )"; } } @@ -20051,34 +20492,36 @@ private static class FollowSets000 { 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[]{0x0000000200000002L}); - public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000800000002L}); - public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0502000000000002L,0x0000000000070000L}); - public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000A00L}); - public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000500000000002L,0x0000000000002100L}); - public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0008000000000002L}); - public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080028L}); - public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000010880000L}); - public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000000002L,0x0000000000101000L}); - public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001000L}); - public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000000L,0x0000000240000008L}); - public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080020L}); - public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0040000000000002L,0x0000000000001000L}); - public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0040000000000002L}); - public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0200002000000000L}); - public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000001004010940L,0x0000000350100A40L}); - public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x4000000000004000L,0x0000000000008400L}); - public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); - public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x4000000000000000L,0x0000000000008400L}); - public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000020000000L}); - public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000000000000000L,0x0000000200200000L}); - public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000001004010140L,0x0000000350100AC0L}); - public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0020000000000000L,0x0000000000200000L}); - public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000000000L,0x0000000250000A00L}); - public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); - public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0020000000000000L}); - public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000001000002L}); - public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0040000000000000L}); + 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}); } 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 a7299f531a..2923fd0936 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 @@ -90,6 +90,7 @@ import org.osate.xtext.aadl2.ba.behaviorAnnex.ModeSwitchConjunction; import org.osate.xtext.aadl2.ba.behaviorAnnex.ModeSwitchTrigger; import org.osate.xtext.aadl2.ba.behaviorAnnex.NamedPropertyField; +import org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression; import org.osate.xtext.aadl2.ba.behaviorAnnex.PropertyArrayIndex; import org.osate.xtext.aadl2.ba.behaviorAnnex.PropertyIndexPropertyReference; import org.osate.xtext.aadl2.ba.behaviorAnnex.PropertyReferenceTail; @@ -276,8 +277,31 @@ else if (epackage == BehaviorAnnexPackage.eINSTANCE) sequence_BehaviorVariableGroup(context, (BehaviorVariableGroup) semanticObject); return; case BehaviorAnnexPackage.BINARY_EXPRESSION: - sequence_AdditiveExpression_LogicalAndExpression_LogicalOrExpression_MultiplicativeExpression_PowerExpression_RelationalExpression(context, (BinaryExpression) semanticObject); - return; + if (rule == grammarAccess.getFactorRule()) { + sequence_Factor(context, (BinaryExpression) semanticObject); + return; + } + else if (rule == grammarAccess.getRelationRule()) { + sequence_Factor_Relation_SimpleExpression_Term(context, (BinaryExpression) semanticObject); + return; + } + else if (rule == grammarAccess.getValueExpressionRule() + || action == grammarAccess.getValueExpressionAccess().getBinaryExpressionLeftAction_1_0()) { + sequence_Factor_Relation_SimpleExpression_Term_ValueExpression(context, (BinaryExpression) semanticObject); + return; + } + else if (action == grammarAccess.getRelationAccess().getBinaryExpressionLeftAction_1_0() + || rule == grammarAccess.getSimpleExpressionRule() + || action == grammarAccess.getSimpleExpressionAccess().getBinaryExpressionLeftAction_1_0()) { + sequence_Factor_SimpleExpression_Term(context, (BinaryExpression) semanticObject); + return; + } + else if (rule == grammarAccess.getTermRule() + || action == grammarAccess.getTermAccess().getBinaryExpressionLeftAction_1_0()) { + sequence_Factor_Term(context, (BinaryExpression) semanticObject); + return; + } + else break; case BehaviorAnnexPackage.COMMUNICATION_ACTION: sequence_CommunicationAction(context, (CommunicationAction) semanticObject); return; @@ -329,6 +353,9 @@ else if (epackage == BehaviorAnnexPackage.eINSTANCE) case BehaviorAnnexPackage.NAMED_PROPERTY_FIELD: sequence_NamedPropertyField(context, (NamedPropertyField) semanticObject); return; + case BehaviorAnnexPackage.PARENTHESIZED_EXPRESSION: + sequence_ParenthesizedExpression(context, (ParenthesizedExpression) semanticObject); + return; case BehaviorAnnexPackage.PROPERTY_ARRAY_INDEX: sequence_PropertyArrayIndex(context, (PropertyArrayIndex) semanticObject); return; @@ -354,8 +381,22 @@ else if (epackage == BehaviorAnnexPackage.eINSTANCE) sequence_TimedAction(context, (TimedAction) semanticObject); return; case BehaviorAnnexPackage.UNARY_EXPRESSION: - sequence_UnaryExpression(context, (UnaryExpression) semanticObject); - return; + if (rule == grammarAccess.getValueExpressionRule() + || action == grammarAccess.getValueExpressionAccess().getBinaryExpressionLeftAction_1_0() + || rule == grammarAccess.getRelationRule() + || action == grammarAccess.getRelationAccess().getBinaryExpressionLeftAction_1_0() + || rule == grammarAccess.getSimpleExpressionRule() + || action == grammarAccess.getSimpleExpressionAccess().getBinaryExpressionLeftAction_1_0()) { + sequence_Factor_SimpleExpression(context, (UnaryExpression) semanticObject); + return; + } + else if (rule == grammarAccess.getTermRule() + || action == grammarAccess.getTermAccess().getBinaryExpressionLeftAction_1_0() + || rule == grammarAccess.getFactorRule()) { + sequence_Factor(context, (UnaryExpression) semanticObject); + return; + } + else break; case BehaviorAnnexPackage.UNINDEXED_REFERENCE: sequence_UnindexedReference(context, (UnindexedReference) semanticObject); return; @@ -376,52 +417,6 @@ else if (epackage == BehaviorAnnexPackage.eINSTANCE) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); } - /** - * 
-	 * Contexts:
-	 *     ValueExpression returns BinaryExpression
-	 *     LogicalOrExpression returns BinaryExpression
-	 *     LogicalOrExpression.BinaryExpression_1_0 returns BinaryExpression
-	 *     LogicalAndExpression returns BinaryExpression
-	 *     LogicalAndExpression.BinaryExpression_1_0 returns BinaryExpression
-	 *     RelationalExpression returns BinaryExpression
-	 *     RelationalExpression.BinaryExpression_1_0 returns BinaryExpression
-	 *     AdditiveExpression returns BinaryExpression
-	 *     AdditiveExpression.BinaryExpression_1_0 returns BinaryExpression
-	 *     MultiplicativeExpression returns BinaryExpression
-	 *     MultiplicativeExpression.BinaryExpression_1_0 returns BinaryExpression
-	 *     PowerExpression returns BinaryExpression
-	 *     PowerExpression.BinaryExpression_1_0 returns BinaryExpression
-	 *     UnaryExpression returns BinaryExpression
-	 *     PrimaryExpression returns BinaryExpression
-	 *
-	 * Constraint:
-	 *     (
-	 *         (left=LogicalOrExpression_BinaryExpression_1_0 operator=LogicalOrOperator right=LogicalAndExpression) | 
-	 *         (left=LogicalAndExpression_BinaryExpression_1_0 operator=LogicalAndOperator right=RelationalExpression) | 
-	 *         (
-	 *             left=RelationalExpression_BinaryExpression_1_0 
-	 *             (
-	 *                 operator='=' | 
-	 *                 operator='!=' | 
-	 *                 operator='<' | 
-	 *                 operator='<=' | 
-	 *                 operator='>' | 
-	 *                 operator='>='
-	 *             ) 
-	 *             right=AdditiveExpression
-	 *         ) | 
-	 *         (left=AdditiveExpression_BinaryExpression_1_0 (operator='+' | operator='-') right=MultiplicativeExpression) | 
-	 *         (left=MultiplicativeExpression_BinaryExpression_1_0 (operator='*' | operator='/' | operator='mod' | operator='rem') right=PowerExpression) | 
-	 *         (left=PowerExpression_BinaryExpression_1_0 operator='**' right=PowerExpression)
-	 *     )
-	 *
- */ - protected void sequence_AdditiveExpression_LogicalAndExpression_LogicalOrExpression_MultiplicativeExpression_PowerExpression_RelationalExpression(ISerializationContext context, BinaryExpression semanticObject) { - genericSequencer.createSequence(context, semanticObject); - } - - /** * 
 	 * Contexts:
@@ -545,20 +540,16 @@ protected void sequence_BehaviorAnnex(ISerializationContext context, BehaviorAnn
 	 * 
 	 * Contexts:
 	 *     ValueExpression returns BehaviorBooleanLiteral
-	 *     LogicalOrExpression returns BehaviorBooleanLiteral
-	 *     LogicalOrExpression.BinaryExpression_1_0 returns BehaviorBooleanLiteral
-	 *     LogicalAndExpression returns BehaviorBooleanLiteral
-	 *     LogicalAndExpression.BinaryExpression_1_0 returns BehaviorBooleanLiteral
-	 *     RelationalExpression returns BehaviorBooleanLiteral
-	 *     RelationalExpression.BinaryExpression_1_0 returns BehaviorBooleanLiteral
-	 *     AdditiveExpression returns BehaviorBooleanLiteral
-	 *     AdditiveExpression.BinaryExpression_1_0 returns BehaviorBooleanLiteral
-	 *     MultiplicativeExpression returns BehaviorBooleanLiteral
-	 *     MultiplicativeExpression.BinaryExpression_1_0 returns BehaviorBooleanLiteral
-	 *     PowerExpression returns BehaviorBooleanLiteral
-	 *     PowerExpression.BinaryExpression_1_0 returns BehaviorBooleanLiteral
-	 *     UnaryExpression returns BehaviorBooleanLiteral
-	 *     PrimaryExpression returns BehaviorBooleanLiteral
+	 *     ValueExpression.BinaryExpression_1_0 returns BehaviorBooleanLiteral
+	 *     Relation returns BehaviorBooleanLiteral
+	 *     Relation.BinaryExpression_1_0 returns BehaviorBooleanLiteral
+	 *     SimpleExpression returns BehaviorBooleanLiteral
+	 *     SimpleExpression.BinaryExpression_1_0 returns BehaviorBooleanLiteral
+	 *     Term returns BehaviorBooleanLiteral
+	 *     Term.BinaryExpression_1_0 returns BehaviorBooleanLiteral
+	 *     Factor returns BehaviorBooleanLiteral
+	 *     Factor.BinaryExpression_0_1_0 returns BehaviorBooleanLiteral
+	 *     Value returns BehaviorBooleanLiteral
 	 *     ValueConstant returns BehaviorBooleanLiteral
 	 *     BehaviorBooleanLiteral returns BehaviorBooleanLiteral
 	 *
@@ -590,20 +581,16 @@ protected void sequence_BehaviorCondition(ISerializationContext context, Behavio
 	 * Contexts:
 	 *     IntegerValue returns BehaviorIntegerLiteral
 	 *     ValueExpression returns BehaviorIntegerLiteral
-	 *     LogicalOrExpression returns BehaviorIntegerLiteral
-	 *     LogicalOrExpression.BinaryExpression_1_0 returns BehaviorIntegerLiteral
-	 *     LogicalAndExpression returns BehaviorIntegerLiteral
-	 *     LogicalAndExpression.BinaryExpression_1_0 returns BehaviorIntegerLiteral
-	 *     RelationalExpression returns BehaviorIntegerLiteral
-	 *     RelationalExpression.BinaryExpression_1_0 returns BehaviorIntegerLiteral
-	 *     AdditiveExpression returns BehaviorIntegerLiteral
-	 *     AdditiveExpression.BinaryExpression_1_0 returns BehaviorIntegerLiteral
-	 *     MultiplicativeExpression returns BehaviorIntegerLiteral
-	 *     MultiplicativeExpression.BinaryExpression_1_0 returns BehaviorIntegerLiteral
-	 *     PowerExpression returns BehaviorIntegerLiteral
-	 *     PowerExpression.BinaryExpression_1_0 returns BehaviorIntegerLiteral
-	 *     UnaryExpression returns BehaviorIntegerLiteral
-	 *     PrimaryExpression returns BehaviorIntegerLiteral
+	 *     ValueExpression.BinaryExpression_1_0 returns BehaviorIntegerLiteral
+	 *     Relation returns BehaviorIntegerLiteral
+	 *     Relation.BinaryExpression_1_0 returns BehaviorIntegerLiteral
+	 *     SimpleExpression returns BehaviorIntegerLiteral
+	 *     SimpleExpression.BinaryExpression_1_0 returns BehaviorIntegerLiteral
+	 *     Term returns BehaviorIntegerLiteral
+	 *     Term.BinaryExpression_1_0 returns BehaviorIntegerLiteral
+	 *     Factor returns BehaviorIntegerLiteral
+	 *     Factor.BinaryExpression_0_1_0 returns BehaviorIntegerLiteral
+	 *     Value returns BehaviorIntegerLiteral
 	 *     ValueConstant returns BehaviorIntegerLiteral
 	 *     BehaviorIntegerLiteral returns BehaviorIntegerLiteral
 	 *     PropertyIndexValue returns BehaviorIntegerLiteral
@@ -650,20 +637,16 @@ protected void sequence_BehaviorPropertyAssociation(ISerializationContext contex
 	 * 
 	 * Contexts:
 	 *     ValueExpression returns BehaviorRealLiteral
-	 *     LogicalOrExpression returns BehaviorRealLiteral
-	 *     LogicalOrExpression.BinaryExpression_1_0 returns BehaviorRealLiteral
-	 *     LogicalAndExpression returns BehaviorRealLiteral
-	 *     LogicalAndExpression.BinaryExpression_1_0 returns BehaviorRealLiteral
-	 *     RelationalExpression returns BehaviorRealLiteral
-	 *     RelationalExpression.BinaryExpression_1_0 returns BehaviorRealLiteral
-	 *     AdditiveExpression returns BehaviorRealLiteral
-	 *     AdditiveExpression.BinaryExpression_1_0 returns BehaviorRealLiteral
-	 *     MultiplicativeExpression returns BehaviorRealLiteral
-	 *     MultiplicativeExpression.BinaryExpression_1_0 returns BehaviorRealLiteral
-	 *     PowerExpression returns BehaviorRealLiteral
-	 *     PowerExpression.BinaryExpression_1_0 returns BehaviorRealLiteral
-	 *     UnaryExpression returns BehaviorRealLiteral
-	 *     PrimaryExpression returns BehaviorRealLiteral
+	 *     ValueExpression.BinaryExpression_1_0 returns BehaviorRealLiteral
+	 *     Relation returns BehaviorRealLiteral
+	 *     Relation.BinaryExpression_1_0 returns BehaviorRealLiteral
+	 *     SimpleExpression returns BehaviorRealLiteral
+	 *     SimpleExpression.BinaryExpression_1_0 returns BehaviorRealLiteral
+	 *     Term returns BehaviorRealLiteral
+	 *     Term.BinaryExpression_1_0 returns BehaviorRealLiteral
+	 *     Factor returns BehaviorRealLiteral
+	 *     Factor.BinaryExpression_0_1_0 returns BehaviorRealLiteral
+	 *     Value returns BehaviorRealLiteral
 	 *     ValueConstant returns BehaviorRealLiteral
 	 *     BehaviorRealLiteral returns BehaviorRealLiteral
 	 *
@@ -720,20 +703,16 @@ protected void sequence_BehaviorState(ISerializationContext context, BehaviorSta
 	 * 
 	 * Contexts:
 	 *     ValueExpression returns BehaviorStringLiteral
-	 *     LogicalOrExpression returns BehaviorStringLiteral
-	 *     LogicalOrExpression.BinaryExpression_1_0 returns BehaviorStringLiteral
-	 *     LogicalAndExpression returns BehaviorStringLiteral
-	 *     LogicalAndExpression.BinaryExpression_1_0 returns BehaviorStringLiteral
-	 *     RelationalExpression returns BehaviorStringLiteral
-	 *     RelationalExpression.BinaryExpression_1_0 returns BehaviorStringLiteral
-	 *     AdditiveExpression returns BehaviorStringLiteral
-	 *     AdditiveExpression.BinaryExpression_1_0 returns BehaviorStringLiteral
-	 *     MultiplicativeExpression returns BehaviorStringLiteral
-	 *     MultiplicativeExpression.BinaryExpression_1_0 returns BehaviorStringLiteral
-	 *     PowerExpression returns BehaviorStringLiteral
-	 *     PowerExpression.BinaryExpression_1_0 returns BehaviorStringLiteral
-	 *     UnaryExpression returns BehaviorStringLiteral
-	 *     PrimaryExpression returns BehaviorStringLiteral
+	 *     ValueExpression.BinaryExpression_1_0 returns BehaviorStringLiteral
+	 *     Relation returns BehaviorStringLiteral
+	 *     Relation.BinaryExpression_1_0 returns BehaviorStringLiteral
+	 *     SimpleExpression returns BehaviorStringLiteral
+	 *     SimpleExpression.BinaryExpression_1_0 returns BehaviorStringLiteral
+	 *     Term returns BehaviorStringLiteral
+	 *     Term.BinaryExpression_1_0 returns BehaviorStringLiteral
+	 *     Factor returns BehaviorStringLiteral
+	 *     Factor.BinaryExpression_0_1_0 returns BehaviorStringLiteral
+	 *     Value returns BehaviorStringLiteral
 	 *     ValueConstant returns BehaviorStringLiteral
 	 *     BehaviorStringLiteral returns BehaviorStringLiteral
 	 *
@@ -992,6 +971,154 @@ protected void sequence_ExecuteCondition(ISerializationContext context, ExecuteC
 	}
 	
 	
+	/**
+	 * 
+	 * Contexts:
+	 *     Factor returns BinaryExpression
+	 *
+	 * Constraint:
+	 *     (left=Factor_BinaryExpression_0_1_0 operator=BinaryNumericOperator right=Value)
+	 * 

+	 */
+	protected void sequence_Factor(ISerializationContext context, BinaryExpression semanticObject) {
+		if (errorAcceptor != null) {
+			if (transientValues.isValueTransient(semanticObject, BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__LEFT) == ValueTransient.YES)
+				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__LEFT));
+			if (transientValues.isValueTransient(semanticObject, BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__OPERATOR) == ValueTransient.YES)
+				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__OPERATOR));
+			if (transientValues.isValueTransient(semanticObject, BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__RIGHT) == ValueTransient.YES)
+				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BehaviorAnnexPackage.Literals.BINARY_EXPRESSION__RIGHT));
+		}
+		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+		feeder.accept(grammarAccess.getFactorAccess().getBinaryExpressionLeftAction_0_1_0(), semanticObject.getLeft());
+		feeder.accept(grammarAccess.getFactorAccess().getOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0(), semanticObject.getOperator());
+		feeder.accept(grammarAccess.getFactorAccess().getRightValueParserRuleCall_0_1_2_0(), semanticObject.getRight());
+		feeder.finish();
+	}
+	
+	
+	/**
+	 * 
+	 * Contexts:
+	 *     Relation returns BinaryExpression
+	 *
+	 * Constraint:
+	 *     (
+	 *         (left=Relation_BinaryExpression_1_0 operator=RelationalOperator right=SimpleExpression) | 
+	 *         (left=SimpleExpression_BinaryExpression_1_0 operator=BinaryAddingOperator right=Term) | 
+	 *         (left=Term_BinaryExpression_1_0 operator=MultiplyingOperator right=Factor) | 
+	 *         (left=Factor_BinaryExpression_0_1_0 operator=BinaryNumericOperator right=Value)
+	 *     )
+	 * 

+	 */
+	protected void sequence_Factor_Relation_SimpleExpression_Term(ISerializationContext context, BinaryExpression semanticObject) {
+		genericSequencer.createSequence(context, semanticObject);
+	}
+	
+	
+	/**
+	 * 
+	 * Contexts:
+	 *     ValueExpression returns BinaryExpression
+	 *     ValueExpression.BinaryExpression_1_0 returns BinaryExpression
+	 *
+	 * Constraint:
+	 *     (
+	 *         (left=ValueExpression_BinaryExpression_1_0 operator=LogicalOperator right=Relation) | 
+	 *         (left=Relation_BinaryExpression_1_0 operator=RelationalOperator right=SimpleExpression) | 
+	 *         (left=SimpleExpression_BinaryExpression_1_0 operator=BinaryAddingOperator right=Term) | 
+	 *         (left=Term_BinaryExpression_1_0 operator=MultiplyingOperator right=Factor) | 
+	 *         (left=Factor_BinaryExpression_0_1_0 operator=BinaryNumericOperator right=Value)
+	 *     )
+	 * 

+	 */
+	protected void sequence_Factor_Relation_SimpleExpression_Term_ValueExpression(ISerializationContext context, BinaryExpression semanticObject) {
+		genericSequencer.createSequence(context, semanticObject);
+	}
+	
+	
+	/**
+	 * 
+	 * Contexts:
+	 *     Relation.BinaryExpression_1_0 returns BinaryExpression
+	 *     SimpleExpression returns BinaryExpression
+	 *     SimpleExpression.BinaryExpression_1_0 returns BinaryExpression
+	 *
+	 * Constraint:
+	 *     (
+	 *         (left=SimpleExpression_BinaryExpression_1_0 operator=BinaryAddingOperator right=Term) | 
+	 *         (left=Term_BinaryExpression_1_0 operator=MultiplyingOperator right=Factor) | 
+	 *         (left=Factor_BinaryExpression_0_1_0 operator=BinaryNumericOperator right=Value)
+	 *     )
+	 * 

+	 */
+	protected void sequence_Factor_SimpleExpression_Term(ISerializationContext context, BinaryExpression semanticObject) {
+		genericSequencer.createSequence(context, semanticObject);
+	}
+	
+	
+	/**
+	 * 
+	 * Contexts:
+	 *     ValueExpression returns UnaryExpression
+	 *     ValueExpression.BinaryExpression_1_0 returns UnaryExpression
+	 *     Relation returns UnaryExpression
+	 *     Relation.BinaryExpression_1_0 returns UnaryExpression
+	 *     SimpleExpression returns UnaryExpression
+	 *     SimpleExpression.BinaryExpression_1_0 returns UnaryExpression
+	 *
+	 * Constraint:
+	 *     ((operator=UnaryAddingOperator operand=Term) | (operator=UnaryValueOperator operand=Value))
+	 * 

+	 */
+	protected void sequence_Factor_SimpleExpression(ISerializationContext context, UnaryExpression semanticObject) {
+		genericSequencer.createSequence(context, semanticObject);
+	}
+	
+	
+	/**
+	 * 
+	 * Contexts:
+	 *     Term returns BinaryExpression
+	 *     Term.BinaryExpression_1_0 returns BinaryExpression
+	 *
+	 * Constraint:
+	 *     (
+	 *         (left=Term_BinaryExpression_1_0 operator=MultiplyingOperator right=Factor) | 
+	 *         (left=Factor_BinaryExpression_0_1_0 operator=BinaryNumericOperator right=Value)
+	 *     )
+	 * 

+	 */
+	protected void sequence_Factor_Term(ISerializationContext context, BinaryExpression semanticObject) {
+		genericSequencer.createSequence(context, semanticObject);
+	}
+	
+	
+	/**
+	 * 
+	 * Contexts:
+	 *     Term returns UnaryExpression
+	 *     Term.BinaryExpression_1_0 returns UnaryExpression
+	 *     Factor returns UnaryExpression
+	 *
+	 * Constraint:
+	 *     (operator=UnaryValueOperator operand=Value)
+	 * 

+	 */
+	protected void sequence_Factor(ISerializationContext context, UnaryExpression semanticObject) {
+		if (errorAcceptor != null) {
+			if (transientValues.isValueTransient(semanticObject, BehaviorAnnexPackage.Literals.UNARY_EXPRESSION__OPERATOR) == ValueTransient.YES)
+				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BehaviorAnnexPackage.Literals.UNARY_EXPRESSION__OPERATOR));
+			if (transientValues.isValueTransient(semanticObject, BehaviorAnnexPackage.Literals.UNARY_EXPRESSION__OPERAND) == ValueTransient.YES)
+				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BehaviorAnnexPackage.Literals.UNARY_EXPRESSION__OPERAND));
+		}
+		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+		feeder.accept(grammarAccess.getFactorAccess().getOperatorUnaryValueOperatorParserRuleCall_1_1_0(), semanticObject.getOperator());
+		feeder.accept(grammarAccess.getFactorAccess().getOperandValueParserRuleCall_1_2_0(), semanticObject.getOperand());
+		feeder.finish();
+	}
+	
+	
 	/**
 	 * 
 	 * Contexts:
@@ -1015,20 +1142,16 @@ protected void sequence_ForStatement(ISerializationContext context, ForStatement
 	 * Contexts:
 	 *     IntegerValue returns HashPropertyReference
 	 *     ValueExpression returns HashPropertyReference
-	 *     LogicalOrExpression returns HashPropertyReference
-	 *     LogicalOrExpression.BinaryExpression_1_0 returns HashPropertyReference
-	 *     LogicalAndExpression returns HashPropertyReference
-	 *     LogicalAndExpression.BinaryExpression_1_0 returns HashPropertyReference
-	 *     RelationalExpression returns HashPropertyReference
-	 *     RelationalExpression.BinaryExpression_1_0 returns HashPropertyReference
-	 *     AdditiveExpression returns HashPropertyReference
-	 *     AdditiveExpression.BinaryExpression_1_0 returns HashPropertyReference
-	 *     MultiplicativeExpression returns HashPropertyReference
-	 *     MultiplicativeExpression.BinaryExpression_1_0 returns HashPropertyReference
-	 *     PowerExpression returns HashPropertyReference
-	 *     PowerExpression.BinaryExpression_1_0 returns HashPropertyReference
-	 *     UnaryExpression returns HashPropertyReference
-	 *     PrimaryExpression returns HashPropertyReference
+	 *     ValueExpression.BinaryExpression_1_0 returns HashPropertyReference
+	 *     Relation returns HashPropertyReference
+	 *     Relation.BinaryExpression_1_0 returns HashPropertyReference
+	 *     SimpleExpression returns HashPropertyReference
+	 *     SimpleExpression.BinaryExpression_1_0 returns HashPropertyReference
+	 *     Term returns HashPropertyReference
+	 *     Term.BinaryExpression_1_0 returns HashPropertyReference
+	 *     Factor returns HashPropertyReference
+	 *     Factor.BinaryExpression_0_1_0 returns HashPropertyReference
+	 *     Value returns HashPropertyReference
 	 *     ValueConstant returns HashPropertyReference
 	 *     HashPropertyReference returns HashPropertyReference
 	 *
@@ -1129,6 +1252,37 @@ protected void sequence_NamedPropertyField(ISerializationContext context, NamedP
 	}
 	
 	
+	/**
+	 * 
+	 * Contexts:
+	 *     ValueExpression returns ParenthesizedExpression
+	 *     ValueExpression.BinaryExpression_1_0 returns ParenthesizedExpression
+	 *     Relation returns ParenthesizedExpression
+	 *     Relation.BinaryExpression_1_0 returns ParenthesizedExpression
+	 *     SimpleExpression returns ParenthesizedExpression
+	 *     SimpleExpression.BinaryExpression_1_0 returns ParenthesizedExpression
+	 *     Term returns ParenthesizedExpression
+	 *     Term.BinaryExpression_1_0 returns ParenthesizedExpression
+	 *     Factor returns ParenthesizedExpression
+	 *     Factor.BinaryExpression_0_1_0 returns ParenthesizedExpression
+	 *     Value returns ParenthesizedExpression
+	 *     ParenthesizedExpression returns ParenthesizedExpression
+	 *
+	 * Constraint:
+	 *     expression=ValueExpression
+	 * 

+	 */
+	protected void sequence_ParenthesizedExpression(ISerializationContext context, ParenthesizedExpression semanticObject) {
+		if (errorAcceptor != null) {
+			if (transientValues.isValueTransient(semanticObject, BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION) == ValueTransient.YES)
+				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BehaviorAnnexPackage.Literals.PARENTHESIZED_EXPRESSION__EXPRESSION));
+		}
+		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+		feeder.accept(grammarAccess.getParenthesizedExpressionAccess().getExpressionValueExpressionParserRuleCall_1_0(), semanticObject.getExpression());
+		feeder.finish();
+	}
+	
+	
 	/**
 	 * 
 	 * Contexts:
@@ -1189,20 +1343,16 @@ protected void sequence_PropertyReferenceTail(ISerializationContext context, Pro
 	 * Contexts:
 	 *     IntegerValue returns ReferenceExpression
 	 *     ValueExpression returns ReferenceExpression
-	 *     LogicalOrExpression returns ReferenceExpression
-	 *     LogicalOrExpression.BinaryExpression_1_0 returns ReferenceExpression
-	 *     LogicalAndExpression returns ReferenceExpression
-	 *     LogicalAndExpression.BinaryExpression_1_0 returns ReferenceExpression
-	 *     RelationalExpression returns ReferenceExpression
-	 *     RelationalExpression.BinaryExpression_1_0 returns ReferenceExpression
-	 *     AdditiveExpression returns ReferenceExpression
-	 *     AdditiveExpression.BinaryExpression_1_0 returns ReferenceExpression
-	 *     MultiplicativeExpression returns ReferenceExpression
-	 *     MultiplicativeExpression.BinaryExpression_1_0 returns ReferenceExpression
-	 *     PowerExpression returns ReferenceExpression
-	 *     PowerExpression.BinaryExpression_1_0 returns ReferenceExpression
-	 *     UnaryExpression returns ReferenceExpression
-	 *     PrimaryExpression returns ReferenceExpression
+	 *     ValueExpression.BinaryExpression_1_0 returns ReferenceExpression
+	 *     Relation returns ReferenceExpression
+	 *     Relation.BinaryExpression_1_0 returns ReferenceExpression
+	 *     SimpleExpression returns ReferenceExpression
+	 *     SimpleExpression.BinaryExpression_1_0 returns ReferenceExpression
+	 *     Term returns ReferenceExpression
+	 *     Term.BinaryExpression_1_0 returns ReferenceExpression
+	 *     Factor returns ReferenceExpression
+	 *     Factor.BinaryExpression_0_1_0 returns ReferenceExpression
+	 *     Value returns ReferenceExpression
 	 *     ReferenceExpression returns ReferenceExpression
 	 *
 	 * Constraint:
@@ -1283,34 +1433,6 @@ protected void sequence_TimedAction(ISerializationContext context, TimedAction s
 	}
 	
 	
-	/**
-	 * 
-	 * Contexts:
-	 *     ValueExpression returns UnaryExpression
-	 *     LogicalOrExpression returns UnaryExpression
-	 *     LogicalOrExpression.BinaryExpression_1_0 returns UnaryExpression
-	 *     LogicalAndExpression returns UnaryExpression
-	 *     LogicalAndExpression.BinaryExpression_1_0 returns UnaryExpression
-	 *     RelationalExpression returns UnaryExpression
-	 *     RelationalExpression.BinaryExpression_1_0 returns UnaryExpression
-	 *     AdditiveExpression returns UnaryExpression
-	 *     AdditiveExpression.BinaryExpression_1_0 returns UnaryExpression
-	 *     MultiplicativeExpression returns UnaryExpression
-	 *     MultiplicativeExpression.BinaryExpression_1_0 returns UnaryExpression
-	 *     PowerExpression returns UnaryExpression
-	 *     PowerExpression.BinaryExpression_1_0 returns UnaryExpression
-	 *     UnaryExpression returns UnaryExpression
-	 *     PrimaryExpression returns UnaryExpression
-	 *
-	 * Constraint:
-	 *     ((operator='+' | operator='-' | operator='abs' | operator='not') operand=UnaryExpression)
-	 * 

-	 */
-	protected void sequence_UnaryExpression(ISerializationContext context, UnaryExpression semanticObject) {
-		genericSequencer.createSequence(context, semanticObject);
-	}
-	
-	
 	/**
 	 * 
 	 * Contexts:
diff --git a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/serializer/AbstractBehaviorAnnexSyntacticSequencer.java b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/serializer/AbstractBehaviorAnnexSyntacticSequencer.java
index 0ce23089b4..3470de89c5 100644
--- a/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/serializer/AbstractBehaviorAnnexSyntacticSequencer.java
+++ b/ba/org.osate.xtext.aadl2.ba/src-gen/org/osate/xtext/aadl2/ba/serializer/AbstractBehaviorAnnexSyntacticSequencer.java
@@ -30,8 +30,6 @@
 import org.eclipse.xtext.RuleCall;
 import org.eclipse.xtext.nodemodel.INode;
 import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias;
-import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias;
-import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable;
 import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition;
 import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer;
 import org.osate.xtext.aadl2.ba.services.BehaviorAnnexGrammarAccess;
@@ -40,14 +38,10 @@
 public abstract class AbstractBehaviorAnnexSyntacticSequencer extends AbstractSyntacticSequencer {
 
 	protected BehaviorAnnexGrammarAccess grammarAccess;
-	protected AbstractElementAlias match_PrimaryExpression_LeftParenthesisKeyword_2_0_a;
-	protected AbstractElementAlias match_PrimaryExpression_LeftParenthesisKeyword_2_0_p;
 	
 	@Inject
 	protected void init(IGrammarAccess access) {
 		grammarAccess = (BehaviorAnnexGrammarAccess) access;
-		match_PrimaryExpression_LeftParenthesisKeyword_2_0_a = new TokenAlias(true, true, grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_2_0());
-		match_PrimaryExpression_LeftParenthesisKeyword_2_0_p = new TokenAlias(true, false, grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_2_0());
 	}
 	
 	@Override
@@ -62,55 +56,8 @@ protected void emitUnassignedTokens(EObject semanticObject, ISynTransition trans
 		List transitionNodes = collectNodes(fromNode, toNode);
 		for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) {
 			List syntaxNodes = getNodesFor(transitionNodes, syntax);
-			if (match_PrimaryExpression_LeftParenthesisKeyword_2_0_a.equals(syntax))
-				emit_PrimaryExpression_LeftParenthesisKeyword_2_0_a(semanticObject, getLastNavigableState(), syntaxNodes);
-			else if (match_PrimaryExpression_LeftParenthesisKeyword_2_0_p.equals(syntax))
-				emit_PrimaryExpression_LeftParenthesisKeyword_2_0_p(semanticObject, getLastNavigableState(), syntaxNodes);
-			else acceptNodes(getLastNavigableState(), syntaxNodes);
+			acceptNodes(getLastNavigableState(), syntaxNodes);
 		}
 	}
 
-	/**
-	 * 
-	 * Ambiguous syntax:
-	 *     '('*
-	 *
-	 * This ambiguous syntax occurs at:
-	 *     (rule start) (ambiguity) '#' property=QualifiedName
-	 *     (rule start) (ambiguity) 'false' (rule start)
-	 *     (rule start) (ambiguity) operator='+'
-	 *     (rule start) (ambiguity) operator='-'
-	 *     (rule start) (ambiguity) operator='abs'
-	 *     (rule start) (ambiguity) operator='not'
-	 *     (rule start) (ambiguity) reference=Reference
-	 *     (rule start) (ambiguity) value=INTEGER_LIT
-	 *     (rule start) (ambiguity) value=REAL_LIT
-	 *     (rule start) (ambiguity) value=STRING
-	 *     (rule start) (ambiguity) value?='true'
-	 *     (rule start) (ambiguity) {BinaryExpression.left=}
-	 
-	 * 

-	 */
-	protected void emit_PrimaryExpression_LeftParenthesisKeyword_2_0_a(EObject semanticObject, ISynNavigable transition, List nodes) {
-		acceptNodes(transition, nodes);
-	}
-	
-	/**
-	 * 
-	 * Ambiguous syntax:
-	 *     '('+
-	 *
-	 * This ambiguous syntax occurs at:
-	 *     (rule start) (ambiguity) operator='+'
-	 *     (rule start) (ambiguity) operator='-'
-	 *     (rule start) (ambiguity) operator='abs'
-	 *     (rule start) (ambiguity) operator='not'
-	 *     (rule start) (ambiguity) {BinaryExpression.left=}
-	 
-	 * 

-	 */
-	protected void emit_PrimaryExpression_LeftParenthesisKeyword_2_0_p(EObject semanticObject, ISynNavigable transition, List nodes) {
-		acceptNodes(transition, nodes);
-	}
-	
 }
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 e919a4f838..2e80e685a9 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
@@ -2010,57 +2010,68 @@ public class IntegerValueElements extends AbstractParserRuleElementFinder {
 	}
 	public class ValueExpressionElements extends AbstractParserRuleElementFinder {
 		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.ValueExpression");
-		private final RuleCall cLogicalOrExpressionParserRuleCall = (RuleCall)rule.eContents().get(1);
-		
-		//ValueExpression:
-		//    LogicalOrExpression
-		//;
-		@Override public ParserRule getRule() { return rule; }
-		
-		//LogicalOrExpression
-		public RuleCall getLogicalOrExpressionParserRuleCall() { return cLogicalOrExpressionParserRuleCall; }
-	}
-	public class LogicalOrExpressionElements extends AbstractParserRuleElementFinder {
-		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalOrExpression");
 		private final Group cGroup = (Group)rule.eContents().get(1);
-		private final RuleCall cLogicalAndExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+		private final RuleCall cRelationParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
 		private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
 		private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0);
 		private final Assignment cOperatorAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
-		private final RuleCall cOperatorLogicalOrOperatorParserRuleCall_1_1_0 = (RuleCall)cOperatorAssignment_1_1.eContents().get(0);
+		private final RuleCall cOperatorLogicalOperatorParserRuleCall_1_1_0 = (RuleCall)cOperatorAssignment_1_1.eContents().get(0);
 		private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2);
-		private final RuleCall cRightLogicalAndExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0);
+		private final RuleCall cRightRelationParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0);
 		
-		//LogicalOrExpression returns ValueExpression:
-		//    LogicalAndExpression
-		//    ({BinaryExpression.left=current} operator=LogicalOrOperator right=LogicalAndExpression)*
+		//// The expression rules follow the D.7 productions rather than one rule per operator, because the standard puts every
+		//// logical operator on a single precedence level and associates the operators of one level from left to right.
+		//// 'a or b and c' therefore means '(a or b) and c'.
+		//ValueExpression:
+		//    Relation
+		//    ({BinaryExpression.left=current} operator=LogicalOperator right=Relation)*
 		//;
 		@Override public ParserRule getRule() { return rule; }
 		
-		//LogicalAndExpression
-		//({BinaryExpression.left=current} operator=LogicalOrOperator right=LogicalAndExpression)*
+		//Relation
+		//({BinaryExpression.left=current} operator=LogicalOperator right=Relation)*
 		public Group getGroup() { return cGroup; }
 		
-		//LogicalAndExpression
-		public RuleCall getLogicalAndExpressionParserRuleCall_0() { return cLogicalAndExpressionParserRuleCall_0; }
+		//Relation
+		public RuleCall getRelationParserRuleCall_0() { return cRelationParserRuleCall_0; }
 		
-		//({BinaryExpression.left=current} operator=LogicalOrOperator right=LogicalAndExpression)*
+		//({BinaryExpression.left=current} operator=LogicalOperator right=Relation)*
 		public Group getGroup_1() { return cGroup_1; }
 		
 		//{BinaryExpression.left=current}
 		public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; }
 		
-		//operator=LogicalOrOperator
+		//operator=LogicalOperator
 		public Assignment getOperatorAssignment_1_1() { return cOperatorAssignment_1_1; }
 		
-		//LogicalOrOperator
-		public RuleCall getOperatorLogicalOrOperatorParserRuleCall_1_1_0() { return cOperatorLogicalOrOperatorParserRuleCall_1_1_0; }
+		//LogicalOperator
+		public RuleCall getOperatorLogicalOperatorParserRuleCall_1_1_0() { return cOperatorLogicalOperatorParserRuleCall_1_1_0; }
 		
-		//right=LogicalAndExpression
+		//right=Relation
 		public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; }
 		
-		//LogicalAndExpression
-		public RuleCall getRightLogicalAndExpressionParserRuleCall_1_2_0() { return cRightLogicalAndExpressionParserRuleCall_1_2_0; }
+		//Relation
+		public RuleCall getRightRelationParserRuleCall_1_2_0() { return cRightRelationParserRuleCall_1_2_0; }
+	}
+	public class LogicalOperatorElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalOperator");
+		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+		private final RuleCall cLogicalAndOperatorParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+		private final RuleCall cLogicalOrOperatorParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+		
+		//LogicalOperator returns ecore::EString:
+		//    LogicalAndOperator | LogicalOrOperator
+		//;
+		@Override public ParserRule getRule() { return rule; }
+		
+		//LogicalAndOperator | LogicalOrOperator
+		public Alternatives getAlternatives() { return cAlternatives; }
+		
+		//LogicalAndOperator
+		public RuleCall getLogicalAndOperatorParserRuleCall_0() { return cLogicalAndOperatorParserRuleCall_0; }
+		
+		//LogicalOrOperator
+		public RuleCall getLogicalOrOperatorParserRuleCall_1() { return cLogicalOrOperatorParserRuleCall_1; }
 	}
 	public class LogicalOrOperatorElements extends AbstractParserRuleElementFinder {
 		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalOrOperator");
@@ -2090,48 +2101,6 @@ public class LogicalOrOperatorElements extends AbstractParserRuleElementFinder {
 		//'xor'
 		public Keyword getXorKeyword_1() { return cXorKeyword_1; }
 	}
-	public class LogicalAndExpressionElements extends AbstractParserRuleElementFinder {
-		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalAndExpression");
-		private final Group cGroup = (Group)rule.eContents().get(1);
-		private final RuleCall cRelationalExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
-		private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
-		private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0);
-		private final Assignment cOperatorAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
-		private final RuleCall cOperatorLogicalAndOperatorParserRuleCall_1_1_0 = (RuleCall)cOperatorAssignment_1_1.eContents().get(0);
-		private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2);
-		private final RuleCall cRightRelationalExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0);
-		
-		//LogicalAndExpression returns ValueExpression:
-		//    RelationalExpression
-		//    ({BinaryExpression.left=current} operator=LogicalAndOperator right=RelationalExpression)*
-		//;
-		@Override public ParserRule getRule() { return rule; }
-		
-		//RelationalExpression
-		//({BinaryExpression.left=current} operator=LogicalAndOperator right=RelationalExpression)*
-		public Group getGroup() { return cGroup; }
-		
-		//RelationalExpression
-		public RuleCall getRelationalExpressionParserRuleCall_0() { return cRelationalExpressionParserRuleCall_0; }
-		
-		//({BinaryExpression.left=current} operator=LogicalAndOperator right=RelationalExpression)*
-		public Group getGroup_1() { return cGroup_1; }
-		
-		//{BinaryExpression.left=current}
-		public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; }
-		
-		//operator=LogicalAndOperator
-		public Assignment getOperatorAssignment_1_1() { return cOperatorAssignment_1_1; }
-		
-		//LogicalAndOperator
-		public RuleCall getOperatorLogicalAndOperatorParserRuleCall_1_1_0() { return cOperatorLogicalAndOperatorParserRuleCall_1_1_0; }
-		
-		//right=RelationalExpression
-		public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; }
-		
-		//RelationalExpression
-		public RuleCall getRightRelationalExpressionParserRuleCall_1_2_0() { return cRightRelationalExpressionParserRuleCall_1_2_0; }
-	}
 	public class LogicalAndOperatorElements extends AbstractParserRuleElementFinder {
 		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.LogicalAndOperator");
 		private final Group cGroup = (Group)rule.eContents().get(1);
@@ -2152,303 +2121,391 @@ public class LogicalAndOperatorElements extends AbstractParserRuleElementFinder
 		//('then')?
 		public Keyword getThenKeyword_1() { return cThenKeyword_1; }
 	}
-	public class RelationalExpressionElements extends AbstractParserRuleElementFinder {
-		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.RelationalExpression");
+	public class RelationElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.Relation");
 		private final Group cGroup = (Group)rule.eContents().get(1);
-		private final RuleCall cAdditiveExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+		private final RuleCall cSimpleExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
 		private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
 		private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0);
 		private final Assignment cOperatorAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
-		private final Alternatives cOperatorAlternatives_1_1_0 = (Alternatives)cOperatorAssignment_1_1.eContents().get(0);
-		private final Keyword cOperatorEqualsSignKeyword_1_1_0_0 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(0);
-		private final Keyword cOperatorExclamationMarkEqualsSignKeyword_1_1_0_1 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(1);
-		private final Keyword cOperatorLessThanSignKeyword_1_1_0_2 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(2);
-		private final Keyword cOperatorLessThanSignEqualsSignKeyword_1_1_0_3 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(3);
-		private final Keyword cOperatorGreaterThanSignKeyword_1_1_0_4 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(4);
-		private final Keyword cOperatorGreaterThanSignEqualsSignKeyword_1_1_0_5 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(5);
+		private final RuleCall cOperatorRelationalOperatorParserRuleCall_1_1_0 = (RuleCall)cOperatorAssignment_1_1.eContents().get(0);
 		private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2);
-		private final RuleCall cRightAdditiveExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0);
+		private final RuleCall cRightSimpleExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0);
 		
-		//RelationalExpression returns ValueExpression:
-		//    AdditiveExpression
-		//    ({BinaryExpression.left=current} operator=('=' | '!=' | '<' | '<=' | '>' | '>=')
-		//        right=AdditiveExpression)?
+		//Relation returns ValueExpression:
+		//    SimpleExpression
+		//    ({BinaryExpression.left=current} operator=RelationalOperator right=SimpleExpression)?
 		//;
 		@Override public ParserRule getRule() { return rule; }
 		
-		//AdditiveExpression
-		//({BinaryExpression.left=current} operator=('=' | '!=' | '<' | '<=' | '>' | '>=')
-		//    right=AdditiveExpression)?
+		//SimpleExpression
+		//({BinaryExpression.left=current} operator=RelationalOperator right=SimpleExpression)?
 		public Group getGroup() { return cGroup; }
 		
-		//AdditiveExpression
-		public RuleCall getAdditiveExpressionParserRuleCall_0() { return cAdditiveExpressionParserRuleCall_0; }
+		//SimpleExpression
+		public RuleCall getSimpleExpressionParserRuleCall_0() { return cSimpleExpressionParserRuleCall_0; }
 		
-		//({BinaryExpression.left=current} operator=('=' | '!=' | '<' | '<=' | '>' | '>=')
-		//    right=AdditiveExpression)?
+		//({BinaryExpression.left=current} operator=RelationalOperator right=SimpleExpression)?
 		public Group getGroup_1() { return cGroup_1; }
 		
 		//{BinaryExpression.left=current}
 		public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; }
 		
-		//operator=('=' | '!=' | '<' | '<=' | '>' | '>=')
+		//operator=RelationalOperator
 		public Assignment getOperatorAssignment_1_1() { return cOperatorAssignment_1_1; }
 		
-		//('=' | '!=' | '<' | '<=' | '>' | '>=')
-		public Alternatives getOperatorAlternatives_1_1_0() { return cOperatorAlternatives_1_1_0; }
+		//RelationalOperator
+		public RuleCall getOperatorRelationalOperatorParserRuleCall_1_1_0() { return cOperatorRelationalOperatorParserRuleCall_1_1_0; }
+		
+		//right=SimpleExpression
+		public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; }
+		
+		//SimpleExpression
+		public RuleCall getRightSimpleExpressionParserRuleCall_1_2_0() { return cRightSimpleExpressionParserRuleCall_1_2_0; }
+	}
+	public class RelationalOperatorElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.RelationalOperator");
+		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+		private final Keyword cEqualsSignKeyword_0 = (Keyword)cAlternatives.eContents().get(0);
+		private final Keyword cExclamationMarkEqualsSignKeyword_1 = (Keyword)cAlternatives.eContents().get(1);
+		private final Keyword cLessThanSignKeyword_2 = (Keyword)cAlternatives.eContents().get(2);
+		private final Keyword cLessThanSignEqualsSignKeyword_3 = (Keyword)cAlternatives.eContents().get(3);
+		private final Keyword cGreaterThanSignKeyword_4 = (Keyword)cAlternatives.eContents().get(4);
+		private final Keyword cGreaterThanSignEqualsSignKeyword_5 = (Keyword)cAlternatives.eContents().get(5);
+		
+		//RelationalOperator returns ecore::EString:
+		//    '=' | '!=' | '<' | '<=' | '>' | '>='
+		//;
+		@Override public ParserRule getRule() { return rule; }
+		
+		//'=' | '!=' | '<' | '<=' | '>' | '>='
+		public Alternatives getAlternatives() { return cAlternatives; }
 		
 		//'='
-		public Keyword getOperatorEqualsSignKeyword_1_1_0_0() { return cOperatorEqualsSignKeyword_1_1_0_0; }
+		public Keyword getEqualsSignKeyword_0() { return cEqualsSignKeyword_0; }
 		
 		//'!='
-		public Keyword getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1() { return cOperatorExclamationMarkEqualsSignKeyword_1_1_0_1; }
+		public Keyword getExclamationMarkEqualsSignKeyword_1() { return cExclamationMarkEqualsSignKeyword_1; }
 		
 		//'<'
-		public Keyword getOperatorLessThanSignKeyword_1_1_0_2() { return cOperatorLessThanSignKeyword_1_1_0_2; }
+		public Keyword getLessThanSignKeyword_2() { return cLessThanSignKeyword_2; }
 		
 		//'<='
-		public Keyword getOperatorLessThanSignEqualsSignKeyword_1_1_0_3() { return cOperatorLessThanSignEqualsSignKeyword_1_1_0_3; }
+		public Keyword getLessThanSignEqualsSignKeyword_3() { return cLessThanSignEqualsSignKeyword_3; }
 		
 		//'>'
-		public Keyword getOperatorGreaterThanSignKeyword_1_1_0_4() { return cOperatorGreaterThanSignKeyword_1_1_0_4; }
+		public Keyword getGreaterThanSignKeyword_4() { return cGreaterThanSignKeyword_4; }
 		
 		//'>='
-		public Keyword getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_5() { return cOperatorGreaterThanSignEqualsSignKeyword_1_1_0_5; }
-		
-		//right=AdditiveExpression
-		public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; }
-		
-		//AdditiveExpression
-		public RuleCall getRightAdditiveExpressionParserRuleCall_1_2_0() { return cRightAdditiveExpressionParserRuleCall_1_2_0; }
+		public Keyword getGreaterThanSignEqualsSignKeyword_5() { return cGreaterThanSignEqualsSignKeyword_5; }
 	}
-	public class AdditiveExpressionElements extends AbstractParserRuleElementFinder {
-		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.AdditiveExpression");
+	public class SimpleExpressionElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.SimpleExpression");
 		private final Group cGroup = (Group)rule.eContents().get(1);
-		private final RuleCall cMultiplicativeExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+		private final Alternatives cAlternatives_0 = (Alternatives)cGroup.eContents().get(0);
+		private final Group cGroup_0_0 = (Group)cAlternatives_0.eContents().get(0);
+		private final Action cUnaryExpressionAction_0_0_0 = (Action)cGroup_0_0.eContents().get(0);
+		private final Assignment cOperatorAssignment_0_0_1 = (Assignment)cGroup_0_0.eContents().get(1);
+		private final RuleCall cOperatorUnaryAddingOperatorParserRuleCall_0_0_1_0 = (RuleCall)cOperatorAssignment_0_0_1.eContents().get(0);
+		private final Assignment cOperandAssignment_0_0_2 = (Assignment)cGroup_0_0.eContents().get(2);
+		private final RuleCall cOperandTermParserRuleCall_0_0_2_0 = (RuleCall)cOperandAssignment_0_0_2.eContents().get(0);
+		private final RuleCall cTermParserRuleCall_0_1 = (RuleCall)cAlternatives_0.eContents().get(1);
 		private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
 		private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0);
 		private final Assignment cOperatorAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
-		private final Alternatives cOperatorAlternatives_1_1_0 = (Alternatives)cOperatorAssignment_1_1.eContents().get(0);
-		private final Keyword cOperatorPlusSignKeyword_1_1_0_0 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(0);
-		private final Keyword cOperatorHyphenMinusKeyword_1_1_0_1 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(1);
+		private final RuleCall cOperatorBinaryAddingOperatorParserRuleCall_1_1_0 = (RuleCall)cOperatorAssignment_1_1.eContents().get(0);
 		private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2);
-		private final RuleCall cRightMultiplicativeExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0);
-		
-		//AdditiveExpression returns ValueExpression:
-		//    MultiplicativeExpression
-		//    ({BinaryExpression.left=current} operator=('+' | '-') right=MultiplicativeExpression)*
+		private final RuleCall cRightTermParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0);
+		
+		//// The unary adding operator leads the whole simple expression, so it binds below the multiplying and the numeric
+		//// operators: '-a mod b' is '-(a mod b)' and '-a ** b' is '-(a ** b)'. D.7 admits '-' only; '+' remains accepted here
+		//// and is tracked separately as issue #3170.
+		//SimpleExpression returns ValueExpression:
+		//    ({UnaryExpression} operator=UnaryAddingOperator operand=Term | Term)
+		//    ({BinaryExpression.left=current} operator=BinaryAddingOperator right=Term)*
 		//;
 		@Override public ParserRule getRule() { return rule; }
 		
-		//MultiplicativeExpression
-		//({BinaryExpression.left=current} operator=('+' | '-') right=MultiplicativeExpression)*
+		//({UnaryExpression} operator=UnaryAddingOperator operand=Term | Term)
+		//({BinaryExpression.left=current} operator=BinaryAddingOperator right=Term)*
 		public Group getGroup() { return cGroup; }
 		
-		//MultiplicativeExpression
-		public RuleCall getMultiplicativeExpressionParserRuleCall_0() { return cMultiplicativeExpressionParserRuleCall_0; }
+		//({UnaryExpression} operator=UnaryAddingOperator operand=Term | Term)
+		public Alternatives getAlternatives_0() { return cAlternatives_0; }
+		
+		//{UnaryExpression} operator=UnaryAddingOperator operand=Term
+		public Group getGroup_0_0() { return cGroup_0_0; }
+		
+		//{UnaryExpression}
+		public Action getUnaryExpressionAction_0_0_0() { return cUnaryExpressionAction_0_0_0; }
+		
+		//operator=UnaryAddingOperator
+		public Assignment getOperatorAssignment_0_0_1() { return cOperatorAssignment_0_0_1; }
+		
+		//UnaryAddingOperator
+		public RuleCall getOperatorUnaryAddingOperatorParserRuleCall_0_0_1_0() { return cOperatorUnaryAddingOperatorParserRuleCall_0_0_1_0; }
+		
+		//operand=Term
+		public Assignment getOperandAssignment_0_0_2() { return cOperandAssignment_0_0_2; }
+		
+		//Term
+		public RuleCall getOperandTermParserRuleCall_0_0_2_0() { return cOperandTermParserRuleCall_0_0_2_0; }
+		
+		//Term
+		public RuleCall getTermParserRuleCall_0_1() { return cTermParserRuleCall_0_1; }
 		
-		//({BinaryExpression.left=current} operator=('+' | '-') right=MultiplicativeExpression)*
+		//({BinaryExpression.left=current} operator=BinaryAddingOperator right=Term)*
 		public Group getGroup_1() { return cGroup_1; }
 		
 		//{BinaryExpression.left=current}
 		public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; }
 		
-		//operator=('+' | '-')
+		//operator=BinaryAddingOperator
 		public Assignment getOperatorAssignment_1_1() { return cOperatorAssignment_1_1; }
 		
-		//('+' | '-')
-		public Alternatives getOperatorAlternatives_1_1_0() { return cOperatorAlternatives_1_1_0; }
+		//BinaryAddingOperator
+		public RuleCall getOperatorBinaryAddingOperatorParserRuleCall_1_1_0() { return cOperatorBinaryAddingOperatorParserRuleCall_1_1_0; }
 		
-		//'+'
-		public Keyword getOperatorPlusSignKeyword_1_1_0_0() { return cOperatorPlusSignKeyword_1_1_0_0; }
+		//right=Term
+		public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; }
+		
+		//Term
+		public RuleCall getRightTermParserRuleCall_1_2_0() { return cRightTermParserRuleCall_1_2_0; }
+	}
+	public class UnaryAddingOperatorElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.UnaryAddingOperator");
+		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+		private final Keyword cHyphenMinusKeyword_0 = (Keyword)cAlternatives.eContents().get(0);
+		private final Keyword cPlusSignKeyword_1 = (Keyword)cAlternatives.eContents().get(1);
+		
+		//UnaryAddingOperator returns ecore::EString:
+		//    '-' | '+'
+		//;
+		@Override public ParserRule getRule() { return rule; }
+		
+		//'-' | '+'
+		public Alternatives getAlternatives() { return cAlternatives; }
 		
 		//'-'
-		public Keyword getOperatorHyphenMinusKeyword_1_1_0_1() { return cOperatorHyphenMinusKeyword_1_1_0_1; }
+		public Keyword getHyphenMinusKeyword_0() { return cHyphenMinusKeyword_0; }
 		
-		//right=MultiplicativeExpression
-		public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; }
+		//'+'
+		public Keyword getPlusSignKeyword_1() { return cPlusSignKeyword_1; }
+	}
+	public class BinaryAddingOperatorElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.BinaryAddingOperator");
+		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+		private final Keyword cPlusSignKeyword_0 = (Keyword)cAlternatives.eContents().get(0);
+		private final Keyword cHyphenMinusKeyword_1 = (Keyword)cAlternatives.eContents().get(1);
+		
+		//BinaryAddingOperator returns ecore::EString:
+		//    '+' | '-'
+		//;
+		@Override public ParserRule getRule() { return rule; }
 		
-		//MultiplicativeExpression
-		public RuleCall getRightMultiplicativeExpressionParserRuleCall_1_2_0() { return cRightMultiplicativeExpressionParserRuleCall_1_2_0; }
+		//'+' | '-'
+		public Alternatives getAlternatives() { return cAlternatives; }
+		
+		//'+'
+		public Keyword getPlusSignKeyword_0() { return cPlusSignKeyword_0; }
+		
+		//'-'
+		public Keyword getHyphenMinusKeyword_1() { return cHyphenMinusKeyword_1; }
 	}
-	public class MultiplicativeExpressionElements extends AbstractParserRuleElementFinder {
-		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.MultiplicativeExpression");
+	public class TermElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.Term");
 		private final Group cGroup = (Group)rule.eContents().get(1);
-		private final RuleCall cPowerExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+		private final RuleCall cFactorParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
 		private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
 		private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0);
 		private final Assignment cOperatorAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
-		private final Alternatives cOperatorAlternatives_1_1_0 = (Alternatives)cOperatorAssignment_1_1.eContents().get(0);
-		private final Keyword cOperatorAsteriskKeyword_1_1_0_0 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(0);
-		private final Keyword cOperatorSolidusKeyword_1_1_0_1 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(1);
-		private final Keyword cOperatorModKeyword_1_1_0_2 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(2);
-		private final Keyword cOperatorRemKeyword_1_1_0_3 = (Keyword)cOperatorAlternatives_1_1_0.eContents().get(3);
+		private final RuleCall cOperatorMultiplyingOperatorParserRuleCall_1_1_0 = (RuleCall)cOperatorAssignment_1_1.eContents().get(0);
 		private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2);
-		private final RuleCall cRightPowerExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0);
+		private final RuleCall cRightFactorParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0);
 		
-		//MultiplicativeExpression returns ValueExpression:
-		//    PowerExpression
-		//    ({BinaryExpression.left=current} operator=('*' | '/' | 'mod' | 'rem') right=PowerExpression)*
+		//Term returns ValueExpression:
+		//    Factor
+		//    ({BinaryExpression.left=current} operator=MultiplyingOperator right=Factor)*
 		//;
 		@Override public ParserRule getRule() { return rule; }
 		
-		//PowerExpression
-		//({BinaryExpression.left=current} operator=('*' | '/' | 'mod' | 'rem') right=PowerExpression)*
+		//Factor
+		//({BinaryExpression.left=current} operator=MultiplyingOperator right=Factor)*
 		public Group getGroup() { return cGroup; }
 		
-		//PowerExpression
-		public RuleCall getPowerExpressionParserRuleCall_0() { return cPowerExpressionParserRuleCall_0; }
+		//Factor
+		public RuleCall getFactorParserRuleCall_0() { return cFactorParserRuleCall_0; }
 		
-		//({BinaryExpression.left=current} operator=('*' | '/' | 'mod' | 'rem') right=PowerExpression)*
+		//({BinaryExpression.left=current} operator=MultiplyingOperator right=Factor)*
 		public Group getGroup_1() { return cGroup_1; }
 		
 		//{BinaryExpression.left=current}
 		public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; }
 		
-		//operator=('*' | '/' | 'mod' | 'rem')
+		//operator=MultiplyingOperator
 		public Assignment getOperatorAssignment_1_1() { return cOperatorAssignment_1_1; }
 		
-		//('*' | '/' | 'mod' | 'rem')
-		public Alternatives getOperatorAlternatives_1_1_0() { return cOperatorAlternatives_1_1_0; }
+		//MultiplyingOperator
+		public RuleCall getOperatorMultiplyingOperatorParserRuleCall_1_1_0() { return cOperatorMultiplyingOperatorParserRuleCall_1_1_0; }
+		
+		//right=Factor
+		public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; }
+		
+		//Factor
+		public RuleCall getRightFactorParserRuleCall_1_2_0() { return cRightFactorParserRuleCall_1_2_0; }
+	}
+	public class MultiplyingOperatorElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.MultiplyingOperator");
+		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+		private final Keyword cAsteriskKeyword_0 = (Keyword)cAlternatives.eContents().get(0);
+		private final Keyword cSolidusKeyword_1 = (Keyword)cAlternatives.eContents().get(1);
+		private final Keyword cModKeyword_2 = (Keyword)cAlternatives.eContents().get(2);
+		private final Keyword cRemKeyword_3 = (Keyword)cAlternatives.eContents().get(3);
+		
+		//MultiplyingOperator returns ecore::EString:
+		//    '*' | '/' | 'mod' | 'rem'
+		//;
+		@Override public ParserRule getRule() { return rule; }
+		
+		//'*' | '/' | 'mod' | 'rem'
+		public Alternatives getAlternatives() { return cAlternatives; }
 		
 		//'*'
-		public Keyword getOperatorAsteriskKeyword_1_1_0_0() { return cOperatorAsteriskKeyword_1_1_0_0; }
+		public Keyword getAsteriskKeyword_0() { return cAsteriskKeyword_0; }
 		
 		//'/'
-		public Keyword getOperatorSolidusKeyword_1_1_0_1() { return cOperatorSolidusKeyword_1_1_0_1; }
+		public Keyword getSolidusKeyword_1() { return cSolidusKeyword_1; }
 		
 		//'mod'
-		public Keyword getOperatorModKeyword_1_1_0_2() { return cOperatorModKeyword_1_1_0_2; }
+		public Keyword getModKeyword_2() { return cModKeyword_2; }
 		
 		//'rem'
-		public Keyword getOperatorRemKeyword_1_1_0_3() { return cOperatorRemKeyword_1_1_0_3; }
-		
-		//right=PowerExpression
-		public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; }
-		
-		//PowerExpression
-		public RuleCall getRightPowerExpressionParserRuleCall_1_2_0() { return cRightPowerExpressionParserRuleCall_1_2_0; }
+		public Keyword getRemKeyword_3() { return cRemKeyword_3; }
 	}
-	public class PowerExpressionElements extends AbstractParserRuleElementFinder {
-		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.PowerExpression");
-		private final Group cGroup = (Group)rule.eContents().get(1);
-		private final RuleCall cUnaryExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
-		private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
-		private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0);
+	public class FactorElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.Factor");
+		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+		private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+		private final RuleCall cValueParserRuleCall_0_0 = (RuleCall)cGroup_0.eContents().get(0);
+		private final Group cGroup_0_1 = (Group)cGroup_0.eContents().get(1);
+		private final Action cBinaryExpressionLeftAction_0_1_0 = (Action)cGroup_0_1.eContents().get(0);
+		private final Assignment cOperatorAssignment_0_1_1 = (Assignment)cGroup_0_1.eContents().get(1);
+		private final RuleCall cOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0 = (RuleCall)cOperatorAssignment_0_1_1.eContents().get(0);
+		private final Assignment cRightAssignment_0_1_2 = (Assignment)cGroup_0_1.eContents().get(2);
+		private final RuleCall cRightValueParserRuleCall_0_1_2_0 = (RuleCall)cRightAssignment_0_1_2.eContents().get(0);
+		private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+		private final Action cUnaryExpressionAction_1_0 = (Action)cGroup_1.eContents().get(0);
 		private final Assignment cOperatorAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
-		private final Keyword cOperatorAsteriskAsteriskKeyword_1_1_0 = (Keyword)cOperatorAssignment_1_1.eContents().get(0);
-		private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2);
-		private final RuleCall cRightPowerExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0);
-		
-		//PowerExpression returns ValueExpression:
-		//    UnaryExpression
-		//    ({BinaryExpression.left=current} operator='**' right=PowerExpression)?
+		private final RuleCall cOperatorUnaryValueOperatorParserRuleCall_1_1_0 = (RuleCall)cOperatorAssignment_1_1.eContents().get(0);
+		private final Assignment cOperandAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2);
+		private final RuleCall cOperandValueParserRuleCall_1_2_0 = (RuleCall)cOperandAssignment_1_2.eContents().get(0);
+		
+		//// A factor admits at most one exponentiation and applies a unary numeric or boolean operator to a single value, so
+		//// 'a ** b ** c', 'abs -a', and 'not not a' need explicit parentheses.
+		//Factor returns ValueExpression:
+		//    Value
+		//    ({BinaryExpression.left=current} operator=BinaryNumericOperator right=Value)?
+		//    | {UnaryExpression} operator=UnaryValueOperator operand=Value
 		//;
 		@Override public ParserRule getRule() { return rule; }
 		
-		//UnaryExpression
-		//({BinaryExpression.left=current} operator='**' right=PowerExpression)?
-		public Group getGroup() { return cGroup; }
+		//Value
+		//({BinaryExpression.left=current} operator=BinaryNumericOperator right=Value)?
+		//| {UnaryExpression} operator=UnaryValueOperator operand=Value
+		public Alternatives getAlternatives() { return cAlternatives; }
+		
+		//Value
+		//({BinaryExpression.left=current} operator=BinaryNumericOperator right=Value)?
+		public Group getGroup_0() { return cGroup_0; }
 		
-		//UnaryExpression
-		public RuleCall getUnaryExpressionParserRuleCall_0() { return cUnaryExpressionParserRuleCall_0; }
+		//Value
+		public RuleCall getValueParserRuleCall_0_0() { return cValueParserRuleCall_0_0; }
 		
-		//({BinaryExpression.left=current} operator='**' right=PowerExpression)?
-		public Group getGroup_1() { return cGroup_1; }
+		//({BinaryExpression.left=current} operator=BinaryNumericOperator right=Value)?
+		public Group getGroup_0_1() { return cGroup_0_1; }
 		
 		//{BinaryExpression.left=current}
-		public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; }
+		public Action getBinaryExpressionLeftAction_0_1_0() { return cBinaryExpressionLeftAction_0_1_0; }
 		
-		//operator='**'
-		public Assignment getOperatorAssignment_1_1() { return cOperatorAssignment_1_1; }
+		//operator=BinaryNumericOperator
+		public Assignment getOperatorAssignment_0_1_1() { return cOperatorAssignment_0_1_1; }
 		
-		//'**'
-		public Keyword getOperatorAsteriskAsteriskKeyword_1_1_0() { return cOperatorAsteriskAsteriskKeyword_1_1_0; }
+		//BinaryNumericOperator
+		public RuleCall getOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0() { return cOperatorBinaryNumericOperatorParserRuleCall_0_1_1_0; }
 		
-		//right=PowerExpression
-		public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; }
-		
-		//PowerExpression
-		public RuleCall getRightPowerExpressionParserRuleCall_1_2_0() { return cRightPowerExpressionParserRuleCall_1_2_0; }
-	}
-	public class UnaryExpressionElements extends AbstractParserRuleElementFinder {
-		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.UnaryExpression");
-		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
-		private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
-		private final Action cUnaryExpressionAction_0_0 = (Action)cGroup_0.eContents().get(0);
-		private final Assignment cOperatorAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1);
-		private final Alternatives cOperatorAlternatives_0_1_0 = (Alternatives)cOperatorAssignment_0_1.eContents().get(0);
-		private final Keyword cOperatorPlusSignKeyword_0_1_0_0 = (Keyword)cOperatorAlternatives_0_1_0.eContents().get(0);
-		private final Keyword cOperatorHyphenMinusKeyword_0_1_0_1 = (Keyword)cOperatorAlternatives_0_1_0.eContents().get(1);
-		private final Keyword cOperatorAbsKeyword_0_1_0_2 = (Keyword)cOperatorAlternatives_0_1_0.eContents().get(2);
-		private final Keyword cOperatorNotKeyword_0_1_0_3 = (Keyword)cOperatorAlternatives_0_1_0.eContents().get(3);
-		private final Assignment cOperandAssignment_0_2 = (Assignment)cGroup_0.eContents().get(2);
-		private final RuleCall cOperandUnaryExpressionParserRuleCall_0_2_0 = (RuleCall)cOperandAssignment_0_2.eContents().get(0);
-		private final RuleCall cPrimaryExpressionParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
-		
-		//UnaryExpression returns ValueExpression:
-		//    {UnaryExpression} operator=('+' | '-' | 'abs' | 'not') operand=UnaryExpression
-		//    | PrimaryExpression
-		//;
-		@Override public ParserRule getRule() { return rule; }
+		//right=Value
+		public Assignment getRightAssignment_0_1_2() { return cRightAssignment_0_1_2; }
 		
-		//{UnaryExpression} operator=('+' | '-' | 'abs' | 'not') operand=UnaryExpression
-		//| PrimaryExpression
-		public Alternatives getAlternatives() { return cAlternatives; }
+		//Value
+		public RuleCall getRightValueParserRuleCall_0_1_2_0() { return cRightValueParserRuleCall_0_1_2_0; }
 		
-		//{UnaryExpression} operator=('+' | '-' | 'abs' | 'not') operand=UnaryExpression
-		public Group getGroup_0() { return cGroup_0; }
+		//{UnaryExpression} operator=UnaryValueOperator operand=Value
+		public Group getGroup_1() { return cGroup_1; }
 		
 		//{UnaryExpression}
-		public Action getUnaryExpressionAction_0_0() { return cUnaryExpressionAction_0_0; }
+		public Action getUnaryExpressionAction_1_0() { return cUnaryExpressionAction_1_0; }
 		
-		//operator=('+' | '-' | 'abs' | 'not')
-		public Assignment getOperatorAssignment_0_1() { return cOperatorAssignment_0_1; }
+		//operator=UnaryValueOperator
+		public Assignment getOperatorAssignment_1_1() { return cOperatorAssignment_1_1; }
 		
-		//('+' | '-' | 'abs' | 'not')
-		public Alternatives getOperatorAlternatives_0_1_0() { return cOperatorAlternatives_0_1_0; }
+		//UnaryValueOperator
+		public RuleCall getOperatorUnaryValueOperatorParserRuleCall_1_1_0() { return cOperatorUnaryValueOperatorParserRuleCall_1_1_0; }
 		
-		//'+'
-		public Keyword getOperatorPlusSignKeyword_0_1_0_0() { return cOperatorPlusSignKeyword_0_1_0_0; }
+		//operand=Value
+		public Assignment getOperandAssignment_1_2() { return cOperandAssignment_1_2; }
 		
-		//'-'
-		public Keyword getOperatorHyphenMinusKeyword_0_1_0_1() { return cOperatorHyphenMinusKeyword_0_1_0_1; }
+		//Value
+		public RuleCall getOperandValueParserRuleCall_1_2_0() { return cOperandValueParserRuleCall_1_2_0; }
+	}
+	public class BinaryNumericOperatorElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.BinaryNumericOperator");
+		private final Keyword cAsteriskAsteriskKeyword = (Keyword)rule.eContents().get(1);
 		
-		//'abs'
-		public Keyword getOperatorAbsKeyword_0_1_0_2() { return cOperatorAbsKeyword_0_1_0_2; }
+		//BinaryNumericOperator returns ecore::EString:
+		//    '**'
+		//;
+		@Override public ParserRule getRule() { return rule; }
 		
-		//'not'
-		public Keyword getOperatorNotKeyword_0_1_0_3() { return cOperatorNotKeyword_0_1_0_3; }
+		//'**'
+		public Keyword getAsteriskAsteriskKeyword() { return cAsteriskAsteriskKeyword; }
+	}
+	public class UnaryValueOperatorElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.UnaryValueOperator");
+		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+		private final Keyword cAbsKeyword_0 = (Keyword)cAlternatives.eContents().get(0);
+		private final Keyword cNotKeyword_1 = (Keyword)cAlternatives.eContents().get(1);
+		
+		//UnaryValueOperator returns ecore::EString:
+		//    'abs' | 'not'
+		//;
+		@Override public ParserRule getRule() { return rule; }
 		
-		//operand=UnaryExpression
-		public Assignment getOperandAssignment_0_2() { return cOperandAssignment_0_2; }
+		//'abs' | 'not'
+		public Alternatives getAlternatives() { return cAlternatives; }
 		
-		//UnaryExpression
-		public RuleCall getOperandUnaryExpressionParserRuleCall_0_2_0() { return cOperandUnaryExpressionParserRuleCall_0_2_0; }
+		//'abs'
+		public Keyword getAbsKeyword_0() { return cAbsKeyword_0; }
 		
-		//PrimaryExpression
-		public RuleCall getPrimaryExpressionParserRuleCall_1() { return cPrimaryExpressionParserRuleCall_1; }
+		//'not'
+		public Keyword getNotKeyword_1() { return cNotKeyword_1; }
 	}
-	public class PrimaryExpressionElements extends AbstractParserRuleElementFinder {
-		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.PrimaryExpression");
+	public class ValueElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.Value");
 		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
 		private final RuleCall cValueConstantParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
 		private final RuleCall cReferenceExpressionParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
-		private final Group cGroup_2 = (Group)cAlternatives.eContents().get(2);
-		private final Keyword cLeftParenthesisKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0);
-		private final RuleCall cValueExpressionParserRuleCall_2_1 = (RuleCall)cGroup_2.eContents().get(1);
-		private final Keyword cRightParenthesisKeyword_2_2 = (Keyword)cGroup_2.eContents().get(2);
+		private final RuleCall cParenthesizedExpressionParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
 		
-		//PrimaryExpression returns ValueExpression:
+		//Value returns ValueExpression:
 		//    ValueConstant
 		//    | ReferenceExpression
-		//    | '(' ValueExpression ')'
+		//    | ParenthesizedExpression
 		//;
 		@Override public ParserRule getRule() { return rule; }
 		
 		//ValueConstant
 		//| ReferenceExpression
-		//| '(' ValueExpression ')'
+		//| ParenthesizedExpression
 		public Alternatives getAlternatives() { return cAlternatives; }
 		
 		//ValueConstant
@@ -2457,17 +2514,39 @@ public class PrimaryExpressionElements extends AbstractParserRuleElementFinder {
 		//ReferenceExpression
 		public RuleCall getReferenceExpressionParserRuleCall_1() { return cReferenceExpressionParserRuleCall_1; }
 		
-		//'(' ValueExpression ')'
-		public Group getGroup_2() { return cGroup_2; }
+		//ParenthesizedExpression
+		public RuleCall getParenthesizedExpressionParserRuleCall_2() { return cParenthesizedExpressionParserRuleCall_2; }
+	}
+	public class ParenthesizedExpressionElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.ParenthesizedExpression");
+		private final Group cGroup = (Group)rule.eContents().get(1);
+		private final Keyword cLeftParenthesisKeyword_0 = (Keyword)cGroup.eContents().get(0);
+		private final Assignment cExpressionAssignment_1 = (Assignment)cGroup.eContents().get(1);
+		private final RuleCall cExpressionValueExpressionParserRuleCall_1_0 = (RuleCall)cExpressionAssignment_1.eContents().get(0);
+		private final Keyword cRightParenthesisKeyword_2 = (Keyword)cGroup.eContents().get(2);
+		
+		//// A parenthesized value expression is one value of the enclosing factor. The group is an object of its own so that the
+		//// grouping the model records is the grouping the source requested, and so that the serializer emits it from the model
+		//// rather than reconstructing it from the parse text.
+		//ParenthesizedExpression:
+		//    '(' expression=ValueExpression ')'
+		//;
+		@Override public ParserRule getRule() { return rule; }
+		
+		//'(' expression=ValueExpression ')'
+		public Group getGroup() { return cGroup; }
 		
 		//'('
-		public Keyword getLeftParenthesisKeyword_2_0() { return cLeftParenthesisKeyword_2_0; }
+		public Keyword getLeftParenthesisKeyword_0() { return cLeftParenthesisKeyword_0; }
+		
+		//expression=ValueExpression
+		public Assignment getExpressionAssignment_1() { return cExpressionAssignment_1; }
 		
 		//ValueExpression
-		public RuleCall getValueExpressionParserRuleCall_2_1() { return cValueExpressionParserRuleCall_2_1; }
+		public RuleCall getExpressionValueExpressionParserRuleCall_1_0() { return cExpressionValueExpressionParserRuleCall_1_0; }
 		
 		//')'
-		public Keyword getRightParenthesisKeyword_2_2() { return cRightParenthesisKeyword_2_2; }
+		public Keyword getRightParenthesisKeyword_2() { return cRightParenthesisKeyword_2; }
 	}
 	public class ValueConstantElements extends AbstractParserRuleElementFinder {
 		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.osate.xtext.aadl2.ba.BehaviorAnnex.ValueConstant");
@@ -3213,16 +3292,21 @@ public class ArrayIndexElements extends AbstractParserRuleElementFinder {
 	private final BehaviorTimeElements pBehaviorTime;
 	private final IntegerValueElements pIntegerValue;
 	private final ValueExpressionElements pValueExpression;
-	private final LogicalOrExpressionElements pLogicalOrExpression;
+	private final LogicalOperatorElements pLogicalOperator;
 	private final LogicalOrOperatorElements pLogicalOrOperator;
-	private final LogicalAndExpressionElements pLogicalAndExpression;
 	private final LogicalAndOperatorElements pLogicalAndOperator;
-	private final RelationalExpressionElements pRelationalExpression;
-	private final AdditiveExpressionElements pAdditiveExpression;
-	private final MultiplicativeExpressionElements pMultiplicativeExpression;
-	private final PowerExpressionElements pPowerExpression;
-	private final UnaryExpressionElements pUnaryExpression;
-	private final PrimaryExpressionElements pPrimaryExpression;
+	private final RelationElements pRelation;
+	private final RelationalOperatorElements pRelationalOperator;
+	private final SimpleExpressionElements pSimpleExpression;
+	private final UnaryAddingOperatorElements pUnaryAddingOperator;
+	private final BinaryAddingOperatorElements pBinaryAddingOperator;
+	private final TermElements pTerm;
+	private final MultiplyingOperatorElements pMultiplyingOperator;
+	private final FactorElements pFactor;
+	private final BinaryNumericOperatorElements pBinaryNumericOperator;
+	private final UnaryValueOperatorElements pUnaryValueOperator;
+	private final ValueElements pValue;
+	private final ParenthesizedExpressionElements pParenthesizedExpression;
 	private final ValueConstantElements pValueConstant;
 	private final BehaviorIntegerLiteralElements pBehaviorIntegerLiteral;
 	private final BehaviorRealLiteralElements pBehaviorRealLiteral;
@@ -3289,16 +3373,21 @@ public BehaviorAnnexGrammarAccess(GrammarProvider grammarProvider,
 		this.pBehaviorTime = new BehaviorTimeElements();
 		this.pIntegerValue = new IntegerValueElements();
 		this.pValueExpression = new ValueExpressionElements();
-		this.pLogicalOrExpression = new LogicalOrExpressionElements();
+		this.pLogicalOperator = new LogicalOperatorElements();
 		this.pLogicalOrOperator = new LogicalOrOperatorElements();
-		this.pLogicalAndExpression = new LogicalAndExpressionElements();
 		this.pLogicalAndOperator = new LogicalAndOperatorElements();
-		this.pRelationalExpression = new RelationalExpressionElements();
-		this.pAdditiveExpression = new AdditiveExpressionElements();
-		this.pMultiplicativeExpression = new MultiplicativeExpressionElements();
-		this.pPowerExpression = new PowerExpressionElements();
-		this.pUnaryExpression = new UnaryExpressionElements();
-		this.pPrimaryExpression = new PrimaryExpressionElements();
+		this.pRelation = new RelationElements();
+		this.pRelationalOperator = new RelationalOperatorElements();
+		this.pSimpleExpression = new SimpleExpressionElements();
+		this.pUnaryAddingOperator = new UnaryAddingOperatorElements();
+		this.pBinaryAddingOperator = new BinaryAddingOperatorElements();
+		this.pTerm = new TermElements();
+		this.pMultiplyingOperator = new MultiplyingOperatorElements();
+		this.pFactor = new FactorElements();
+		this.pBinaryNumericOperator = new BinaryNumericOperatorElements();
+		this.pUnaryValueOperator = new UnaryValueOperatorElements();
+		this.pValue = new ValueElements();
+		this.pParenthesizedExpression = new ParenthesizedExpressionElements();
 		this.pValueConstant = new ValueConstantElements();
 		this.pBehaviorIntegerLiteral = new BehaviorIntegerLiteralElements();
 		this.pBehaviorRealLiteral = new BehaviorRealLiteralElements();
@@ -3774,8 +3863,12 @@ public ParserRule getIntegerValueRule() {
 		return getIntegerValueAccess().getRule();
 	}
 	
+	//// The expression rules follow the D.7 productions rather than one rule per operator, because the standard puts every
+	//// logical operator on a single precedence level and associates the operators of one level from left to right.
+	//// 'a or b and c' therefore means '(a or b) and c'.
 	//ValueExpression:
-	//    LogicalOrExpression
+	//    Relation
+	//    ({BinaryExpression.left=current} operator=LogicalOperator right=Relation)*
 	//;
 	public ValueExpressionElements getValueExpressionAccess() {
 		return pValueExpression;
@@ -3785,16 +3878,15 @@ public ParserRule getValueExpressionRule() {
 		return getValueExpressionAccess().getRule();
 	}
 	
-	//LogicalOrExpression returns ValueExpression:
-	//    LogicalAndExpression
-	//    ({BinaryExpression.left=current} operator=LogicalOrOperator right=LogicalAndExpression)*
+	//LogicalOperator returns ecore::EString:
+	//    LogicalAndOperator | LogicalOrOperator
 	//;
-	public LogicalOrExpressionElements getLogicalOrExpressionAccess() {
-		return pLogicalOrExpression;
+	public LogicalOperatorElements getLogicalOperatorAccess() {
+		return pLogicalOperator;
 	}
 	
-	public ParserRule getLogicalOrExpressionRule() {
-		return getLogicalOrExpressionAccess().getRule();
+	public ParserRule getLogicalOperatorRule() {
+		return getLogicalOperatorAccess().getRule();
 	}
 	
 	//LogicalOrOperator returns ecore::EString:
@@ -3808,18 +3900,6 @@ public ParserRule getLogicalOrOperatorRule() {
 		return getLogicalOrOperatorAccess().getRule();
 	}
 	
-	//LogicalAndExpression returns ValueExpression:
-	//    RelationalExpression
-	//    ({BinaryExpression.left=current} operator=LogicalAndOperator right=RelationalExpression)*
-	//;
-	public LogicalAndExpressionElements getLogicalAndExpressionAccess() {
-		return pLogicalAndExpression;
-	}
-	
-	public ParserRule getLogicalAndExpressionRule() {
-		return getLogicalAndExpressionAccess().getRule();
-	}
-	
 	//LogicalAndOperator returns ecore::EString:
 	//    'and' ('then')?
 	//;
@@ -3831,78 +3911,151 @@ public ParserRule getLogicalAndOperatorRule() {
 		return getLogicalAndOperatorAccess().getRule();
 	}
 	
-	//RelationalExpression returns ValueExpression:
-	//    AdditiveExpression
-	//    ({BinaryExpression.left=current} operator=('=' | '!=' | '<' | '<=' | '>' | '>=')
-	//        right=AdditiveExpression)?
+	//Relation returns ValueExpression:
+	//    SimpleExpression
+	//    ({BinaryExpression.left=current} operator=RelationalOperator right=SimpleExpression)?
+	//;
+	public RelationElements getRelationAccess() {
+		return pRelation;
+	}
+	
+	public ParserRule getRelationRule() {
+		return getRelationAccess().getRule();
+	}
+	
+	//RelationalOperator returns ecore::EString:
+	//    '=' | '!=' | '<' | '<=' | '>' | '>='
 	//;
-	public RelationalExpressionElements getRelationalExpressionAccess() {
-		return pRelationalExpression;
+	public RelationalOperatorElements getRelationalOperatorAccess() {
+		return pRelationalOperator;
 	}
 	
-	public ParserRule getRelationalExpressionRule() {
-		return getRelationalExpressionAccess().getRule();
+	public ParserRule getRelationalOperatorRule() {
+		return getRelationalOperatorAccess().getRule();
 	}
 	
-	//AdditiveExpression returns ValueExpression:
-	//    MultiplicativeExpression
-	//    ({BinaryExpression.left=current} operator=('+' | '-') right=MultiplicativeExpression)*
+	//// The unary adding operator leads the whole simple expression, so it binds below the multiplying and the numeric
+	//// operators: '-a mod b' is '-(a mod b)' and '-a ** b' is '-(a ** b)'. D.7 admits '-' only; '+' remains accepted here
+	//// and is tracked separately as issue #3170.
+	//SimpleExpression returns ValueExpression:
+	//    ({UnaryExpression} operator=UnaryAddingOperator operand=Term | Term)
+	//    ({BinaryExpression.left=current} operator=BinaryAddingOperator right=Term)*
 	//;
-	public AdditiveExpressionElements getAdditiveExpressionAccess() {
-		return pAdditiveExpression;
+	public SimpleExpressionElements getSimpleExpressionAccess() {
+		return pSimpleExpression;
 	}
 	
-	public ParserRule getAdditiveExpressionRule() {
-		return getAdditiveExpressionAccess().getRule();
+	public ParserRule getSimpleExpressionRule() {
+		return getSimpleExpressionAccess().getRule();
 	}
 	
-	//MultiplicativeExpression returns ValueExpression:
-	//    PowerExpression
-	//    ({BinaryExpression.left=current} operator=('*' | '/' | 'mod' | 'rem') right=PowerExpression)*
+	//UnaryAddingOperator returns ecore::EString:
+	//    '-' | '+'
 	//;
-	public MultiplicativeExpressionElements getMultiplicativeExpressionAccess() {
-		return pMultiplicativeExpression;
+	public UnaryAddingOperatorElements getUnaryAddingOperatorAccess() {
+		return pUnaryAddingOperator;
 	}
 	
-	public ParserRule getMultiplicativeExpressionRule() {
-		return getMultiplicativeExpressionAccess().getRule();
+	public ParserRule getUnaryAddingOperatorRule() {
+		return getUnaryAddingOperatorAccess().getRule();
 	}
 	
-	//PowerExpression returns ValueExpression:
-	//    UnaryExpression
-	//    ({BinaryExpression.left=current} operator='**' right=PowerExpression)?
+	//BinaryAddingOperator returns ecore::EString:
+	//    '+' | '-'
 	//;
-	public PowerExpressionElements getPowerExpressionAccess() {
-		return pPowerExpression;
+	public BinaryAddingOperatorElements getBinaryAddingOperatorAccess() {
+		return pBinaryAddingOperator;
 	}
 	
-	public ParserRule getPowerExpressionRule() {
-		return getPowerExpressionAccess().getRule();
+	public ParserRule getBinaryAddingOperatorRule() {
+		return getBinaryAddingOperatorAccess().getRule();
 	}
 	
-	//UnaryExpression returns ValueExpression:
-	//    {UnaryExpression} operator=('+' | '-' | 'abs' | 'not') operand=UnaryExpression
-	//    | PrimaryExpression
+	//Term returns ValueExpression:
+	//    Factor
+	//    ({BinaryExpression.left=current} operator=MultiplyingOperator right=Factor)*
 	//;
-	public UnaryExpressionElements getUnaryExpressionAccess() {
-		return pUnaryExpression;
+	public TermElements getTermAccess() {
+		return pTerm;
 	}
 	
-	public ParserRule getUnaryExpressionRule() {
-		return getUnaryExpressionAccess().getRule();
+	public ParserRule getTermRule() {
+		return getTermAccess().getRule();
 	}
 	
-	//PrimaryExpression returns ValueExpression:
+	//MultiplyingOperator returns ecore::EString:
+	//    '*' | '/' | 'mod' | 'rem'
+	//;
+	public MultiplyingOperatorElements getMultiplyingOperatorAccess() {
+		return pMultiplyingOperator;
+	}
+	
+	public ParserRule getMultiplyingOperatorRule() {
+		return getMultiplyingOperatorAccess().getRule();
+	}
+	
+	//// A factor admits at most one exponentiation and applies a unary numeric or boolean operator to a single value, so
+	//// 'a ** b ** c', 'abs -a', and 'not not a' need explicit parentheses.
+	//Factor returns ValueExpression:
+	//    Value
+	//    ({BinaryExpression.left=current} operator=BinaryNumericOperator right=Value)?
+	//    | {UnaryExpression} operator=UnaryValueOperator operand=Value
+	//;
+	public FactorElements getFactorAccess() {
+		return pFactor;
+	}
+	
+	public ParserRule getFactorRule() {
+		return getFactorAccess().getRule();
+	}
+	
+	//BinaryNumericOperator returns ecore::EString:
+	//    '**'
+	//;
+	public BinaryNumericOperatorElements getBinaryNumericOperatorAccess() {
+		return pBinaryNumericOperator;
+	}
+	
+	public ParserRule getBinaryNumericOperatorRule() {
+		return getBinaryNumericOperatorAccess().getRule();
+	}
+	
+	//UnaryValueOperator returns ecore::EString:
+	//    'abs' | 'not'
+	//;
+	public UnaryValueOperatorElements getUnaryValueOperatorAccess() {
+		return pUnaryValueOperator;
+	}
+	
+	public ParserRule getUnaryValueOperatorRule() {
+		return getUnaryValueOperatorAccess().getRule();
+	}
+	
+	//Value returns ValueExpression:
 	//    ValueConstant
 	//    | ReferenceExpression
-	//    | '(' ValueExpression ')'
+	//    | ParenthesizedExpression
+	//;
+	public ValueElements getValueAccess() {
+		return pValue;
+	}
+	
+	public ParserRule getValueRule() {
+		return getValueAccess().getRule();
+	}
+	
+	//// A parenthesized value expression is one value of the enclosing factor. The group is an object of its own so that the
+	//// grouping the model records is the grouping the source requested, and so that the serializer emits it from the model
+	//// rather than reconstructing it from the parse text.
+	//ParenthesizedExpression:
+	//    '(' expression=ValueExpression ')'
 	//;
-	public PrimaryExpressionElements getPrimaryExpressionAccess() {
-		return pPrimaryExpression;
+	public ParenthesizedExpressionElements getParenthesizedExpressionAccess() {
+		return pParenthesizedExpression;
 	}
 	
-	public ParserRule getPrimaryExpressionRule() {
-		return getPrimaryExpressionAccess().getRule();
+	public ParserRule getParenthesizedExpressionRule() {
+		return getParenthesizedExpressionAccess().getRule();
 	}
 	
 	//ValueConstant:
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 d4d5493cf2..51bb0004c8 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
@@ -222,58 +222,87 @@ IntegerValue:
     | ReferenceExpression
 ;
 
+// The expression rules follow the D.7 productions rather than one rule per operator, because the standard puts every
+// logical operator on a single precedence level and associates the operators of one level from left to right.
+// 'a or b and c' therefore means '(a or b) and c'.
 ValueExpression:
-    LogicalOrExpression
+    Relation
+    ({BinaryExpression.left=current} operator=LogicalOperator right=Relation)*
 ;
 
-LogicalOrExpression returns ValueExpression:
-    LogicalAndExpression
-    ({BinaryExpression.left=current} operator=LogicalOrOperator right=LogicalAndExpression)*
+LogicalOperator returns ecore::EString:
+    LogicalAndOperator | LogicalOrOperator
 ;
 
 LogicalOrOperator returns ecore::EString:
     'or' ('else')? | 'xor'
 ;
 
-LogicalAndExpression returns ValueExpression:
-    RelationalExpression
-    ({BinaryExpression.left=current} operator=LogicalAndOperator right=RelationalExpression)*
-;
-
 LogicalAndOperator returns ecore::EString:
     'and' ('then')?
 ;
 
-RelationalExpression returns ValueExpression:
-    AdditiveExpression
-    ({BinaryExpression.left=current} operator=('=' | '!=' | '<' | '<=' | '>' | '>=')
-        right=AdditiveExpression)?
+Relation returns ValueExpression:
+    SimpleExpression
+    ({BinaryExpression.left=current} operator=RelationalOperator right=SimpleExpression)?
+;
+
+RelationalOperator returns ecore::EString:
+    '=' | '!=' | '<' | '<=' | '>' | '>='
+;
+
+// The unary adding operator leads the whole simple expression, so it binds below the multiplying and the numeric
+// operators: '-a mod b' is '-(a mod b)' and '-a ** b' is '-(a ** b)'. D.7 admits '-' only; '+' remains accepted here
+// and is tracked separately as issue #3170.
+SimpleExpression returns ValueExpression:
+    ({UnaryExpression} operator=UnaryAddingOperator operand=Term | Term)
+    ({BinaryExpression.left=current} operator=BinaryAddingOperator right=Term)*
+;
+
+UnaryAddingOperator returns ecore::EString:
+    '-' | '+'
+;
+
+BinaryAddingOperator returns ecore::EString:
+    '+' | '-'
 ;
 
-AdditiveExpression returns ValueExpression:
-    MultiplicativeExpression
-    ({BinaryExpression.left=current} operator=('+' | '-') right=MultiplicativeExpression)*
+Term returns ValueExpression:
+    Factor
+    ({BinaryExpression.left=current} operator=MultiplyingOperator right=Factor)*
 ;
 
-MultiplicativeExpression returns ValueExpression:
-    PowerExpression
-    ({BinaryExpression.left=current} operator=('*' | '/' | 'mod' | 'rem') right=PowerExpression)*
+MultiplyingOperator returns ecore::EString:
+    '*' | '/' | 'mod' | 'rem'
 ;
 
-PowerExpression returns ValueExpression:
-    UnaryExpression
-    ({BinaryExpression.left=current} operator='**' right=PowerExpression)?
+// A factor admits at most one exponentiation and applies a unary numeric or boolean operator to a single value, so
+// 'a ** b ** c', 'abs -a', and 'not not a' need explicit parentheses.
+Factor returns ValueExpression:
+    Value
+    ({BinaryExpression.left=current} operator=BinaryNumericOperator right=Value)?
+    | {UnaryExpression} operator=UnaryValueOperator operand=Value
 ;
 
-UnaryExpression returns ValueExpression:
-    {UnaryExpression} operator=('+' | '-' | 'abs' | 'not') operand=UnaryExpression
-    | PrimaryExpression
+BinaryNumericOperator returns ecore::EString:
+    '**'
 ;
 
-PrimaryExpression returns ValueExpression:
+UnaryValueOperator returns ecore::EString:
+    'abs' | 'not'
+;
+
+Value returns ValueExpression:
     ValueConstant
     | ReferenceExpression
-    | '(' ValueExpression ')'
+    | ParenthesizedExpression
+;
+
+// A parenthesized value expression is one value of the enclosing factor. The group is an object of its own so that the
+// grouping the model records is the grouping the source requested, and so that the serializer emits it from the model
+// rather than reconstructing it from the parse text.
+ParenthesizedExpression:
+    '(' expression=ValueExpression ')'
 ;
 
 ValueConstant:
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 c21d130fd1..ecfa67c247 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
@@ -34,7 +34,6 @@
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.util.EContentAdapter;
 import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
 import org.osate.aadl2.Aadl2Factory;
 import org.osate.aadl2.AccessCategory;
 import org.osate.aadl2.AccessSpecification;
@@ -155,6 +154,7 @@
 import org.osate.xtext.aadl2.ba.behaviorAnnex.ModeSwitchCondition;
 import org.osate.xtext.aadl2.ba.behaviorAnnex.ModeSwitchTrigger;
 import org.osate.xtext.aadl2.ba.behaviorAnnex.NamedPropertyField;
+import org.osate.xtext.aadl2.ba.behaviorAnnex.ParenthesizedExpression;
 import org.osate.xtext.aadl2.ba.behaviorAnnex.PropertyArrayIndex;
 import org.osate.xtext.aadl2.ba.behaviorAnnex.PropertyIndexPropertyReference;
 import org.osate.xtext.aadl2.ba.behaviorAnnex.PropertyIndexValue;
@@ -276,7 +276,6 @@ private static final class Builder {
 				new IdentityHashMap<>();
 		private final Map variables = new java.util.TreeMap<>(String.CASE_INSENSITIVE_ORDER);
 		private final List> iterativeScopes = new ArrayList<>();
-		private final java.util.Set consumedParentheses = Collections.newSetFromMap(new IdentityHashMap<>());
 		private final IdentityHashMap> resolvedPaths = new IdentityHashMap<>();
 		private final IdentityHashMap resolvedReferences = new IdentityHashMap<>();
 
@@ -864,17 +863,33 @@ private org.osate.ba.aadlba.IntegerValue toIntegerValue(final IntegerValue value
 
 		private ValueExpression toValueExpression(
 				final org.osate.xtext.aadl2.ba.behaviorAnnex.ValueExpression expression) {
-			final var result = trace(FACTORY.createValueExpression(), expression);
+			return toValueExpression(expression, expression);
+		}
+
+		/**
+		 * Translates one D.7 value expression. A group traces to the {@code ParenthesizedExpression} that spans the
+		 * parentheses rather than to the expression inside them, so a diagnostic about the group covers the source the
+		 * reader sees as the operand.
+		 */
+		private ValueExpression toValueExpression(
+				final org.osate.xtext.aadl2.ba.behaviorAnnex.ValueExpression expression, final EObject traceSource) {
+			final var result = trace(FACTORY.createValueExpression(), traceSource);
 			appendLogical(result, expression);
 			return result;
 		}
 
+		/**
+		 * Flattens the left-associated chain of logical operators the grammar builds into the relation and operator
+		 * lists of one strict value expression, which is how the strict model represents D.7's single logical
+		 * precedence level. Only the left operand can be another logical operation, so a parenthesized group stays one
+		 * relation instead of being spliced into the enclosing expression.
+		 */
 		private void appendLogical(final ValueExpression result,
 				final org.osate.xtext.aadl2.ba.behaviorAnnex.ValueExpression expression) {
 			if (expression instanceof BinaryExpression binary && isLogical(binary.getOperator())) {
 				appendLogical(result, binary.getLeft());
 				result.getLogicalOperators().add(logicalOperator(binary.getOperator()));
-				appendLogical(result, binary.getRight());
+				result.getRelations().add(toRelation(binary.getRight()));
 			} else {
 				result.getRelations().add(toRelation(expression));
 			}
@@ -895,22 +910,15 @@ private Relation toRelation(final org.osate.xtext.aadl2.ba.behaviorAnnex.ValueEx
 		private SimpleExpression toSimpleExpression(
 				final org.osate.xtext.aadl2.ba.behaviorAnnex.ValueExpression expression) {
 			final var result = trace(FACTORY.createSimpleExpression(), expression);
-			if (isParenthesized(expression) && consumedParentheses.add(expression)) {
-				try {
-					final var term = trace(FACTORY.createTerm(), expression);
-					final var factor = trace(FACTORY.createFactor(), expression);
-					factor.setFirstValue(toValueExpression(expression));
-					term.getFactors().add(factor);
-					result.getTerms().add(term);
-				} finally {
-					consumedParentheses.remove(expression);
-				}
-			} else {
-				appendAdding(result, expression);
-			}
+			appendAdding(result, expression);
 			return result;
 		}
 
+		/**
+		 * The grammar admits the unary adding operator only ahead of the first term of a simple expression, so the
+		 * recursion reaches it as the leftmost operand and it becomes the simple expression's own operator instead of
+		 * being lost inside a term or a factor.
+		 */
 		private void appendAdding(final SimpleExpression result,
 				final org.osate.xtext.aadl2.ba.behaviorAnnex.ValueExpression expression) {
 			if (expression instanceof BinaryExpression binary && isAdding(binary.getOperator())) {
@@ -945,22 +953,15 @@ private void appendMultiplying(final Term result,
 
 		private Factor toFactor(final org.osate.xtext.aadl2.ba.behaviorAnnex.ValueExpression expression) {
 			final var result = trace(FACTORY.createFactor(), expression);
-			if (isParenthesized(expression) && consumedParentheses.add(expression)) {
-				try {
-					result.setFirstValue(toValueExpression(expression));
-				} finally {
-					consumedParentheses.remove(expression);
-				}
-			} else if (expression instanceof BinaryExpression binary && "**".equals(binary.getOperator())) {
+			if (expression instanceof BinaryExpression binary && "**".equals(binary.getOperator())) {
 				result.setFirstValue(toValue(binary.getLeft()));
 				result.setBinaryNumericOperator(BinaryNumericOperator.MULTIPLY_MULTIPLY);
 				result.setSecondValue(toValue(binary.getRight()));
-			} else if (expression instanceof UnaryExpression unary) {
-				if ("abs".equals(unary.getOperator())) {
-					result.setUnaryNumericOperator(UnaryNumericOperator.ABS);
-				} else if ("not".equals(unary.getOperator())) {
-					result.setUnaryBooleanOperator(UnaryBooleanOperator.NOT);
-				}
+			} else if (expression instanceof UnaryExpression unary && "abs".equals(unary.getOperator())) {
+				result.setUnaryNumericOperator(UnaryNumericOperator.ABS);
+				result.setFirstValue(toValue(unary.getOperand()));
+			} else if (expression instanceof UnaryExpression unary && "not".equals(unary.getOperator())) {
+				result.setUnaryBooleanOperator(UnaryBooleanOperator.NOT);
 				result.setFirstValue(toValue(unary.getOperand()));
 			} else {
 				result.setFirstValue(toValue(expression));
@@ -968,13 +969,14 @@ private Factor toFactor(final org.osate.xtext.aadl2.ba.behaviorAnnex.ValueExpres
 			return result;
 		}
 
+		/**
+		 * A parenthesized group becomes the nested strict value expression that D.7's {@code value} production admits,
+		 * which is what keeps the requested grouping in the strict model. Any other composite expression is nested the
+		 * same way rather than losing its operator.
+		 */
 		private Value toValue(final org.osate.xtext.aadl2.ba.behaviorAnnex.ValueExpression expression) {
-			if (isParenthesized(expression) && consumedParentheses.add(expression)) {
-				try {
-					return toValueExpression(expression);
-				} finally {
-					consumedParentheses.remove(expression);
-				}
+			if (expression instanceof ParenthesizedExpression group) {
+				return toValueExpression(group.getExpression(), group);
 			}
 			if (expression instanceof org.osate.xtext.aadl2.ba.behaviorAnnex.ValueConstant constant) {
 				return toValueConstant(constant);
@@ -1582,15 +1584,6 @@ private static long parseInteger(final String value, final long fallback) {
 			}
 		}
 
-		private static boolean isParenthesized(final EObject expression) {
-			final var node = NodeModelUtils.findActualNodeFor(expression);
-			if (node == null) {
-				return false;
-			}
-			final var text = node.getText().strip();
-			return text.startsWith("(") && text.endsWith(")");
-		}
-
 		private static boolean isLogical(final String operator) {
 			return switch (operator) {
 			case "and", "and then", "or", "or else", "xor" -> true;